zip

a=[1,2,3]
b=[4,5,6]
zip(a,b) # 返回的是zip object at location
list(zip(a,b)] # 可视化
>>>[(1,4),(2,5),(3,6)]
for i,j in zip(a,b)
print(i/2,j*2)

lambda

短时间内使用的小的匿名函数，不同的编程语言里面都有这个内容。

'''
语法：lambda [参数]：[表达式]
可接受任意数量的参数，但是只能有一个表达式
'''
def fun1(x,y):
return(x+y)
fun1(2,3)
>>>5
fun2=lambda x,y:x+y # 也能定义
fun2(2,3)
>>>5

map函数的使用方法：

将功能附加给参数
map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列

可以成为转化的方式，也可以类似于lambda一样对元素的操作

a=list(map(int,input().split()))
# 这个方法很有用！
>>> def square(x) :
# 计算平方数
...
return x ** 2
...
>>> map(square, [1,2,3,4,5])
# 计算列表各个元素的平方
<map object at 0x100d3d550>
# 返回迭代器
>>> list(map(square, [1,2,3,4,5]))
# 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))
# 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
>>>

正则表达式

正则表达式是对字符串的一种逻辑公式，就是实现定义好一些特定的字符，及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。通常用来检索，替换那些符合摸个模式的文本，常用于字符串操作。

Prime处理素数的方法

基础版本的思路就是从2到N-1进行for循环检测，但是只要想到只要判断从2到根号N就能判断这个数是否是素数，可以降低时间复杂度。
这个是数学上面的概念

import math
def isprime(n):
if n%2==0 and n!=2:
return False
if n%3==0 and n!=3:
return False
i=3
while i<=math.sqrt(n):
if n%i==0:
return False
i+=2
return True

递归核心思想

def func1(x):
if x>0:
print(x)
func1(x-1)
def func2(x):
if x>0:
func2(x-1)
print(x)
print(func1(3))
print(func2(3))

递归核心思想：
1、边界条件
2、递归函数不断向边界逼近，而且一定是可达的

在编程当中就是寻找递归条件和停止条件
在python的模块化编程之后需要添加self，但是在函数式编程当中像上面展示的一样，并不需要添加

递归三大要素：
第一要素：明确函数的功能
第二要素：寻找递归的结束条件
第三要素：函数的等价关系式
不断缩小参数的范围

操作符

print

print("www","runoob","com",sep=".")
# 设置间隔符
www.runoob.com
print(' '.join(x)) # 在空格之间增加x的元素作为输出，x可以是list
print(i,end='')
print(i,end=' ')
# 这两个的区别就是最后输出的时候有什么东西
# 占位格式输出
print("%04d - %04d = %04d"%(dec,ac,num))
print("%s - %s = %s"%(dec,ac,num))
# 规范化数据格式
num = "%04d"%(num)

input

python的输入返回的是str类型

input.split()
split()中间可以打印控制窗口的输入提示，也可以控制输入的分隔符

host, port, username, passwd, dbname = input("请输入服务器地址,端口号,用户名，密码及数据库名，空格隔开：").split()
# 注意input()的返回类型是str
# input.split()的返回类型是list
print(host,port,username,passwd,dbname)
num=str("{:0>4}".format(input())) # 按照四位格式补齐

sort和sotred之间的区别

sort()是内置函数

针对removereservesort没有返回值的状况使用sorted函数，并且x.sort().reserve()会报错，因为没有返回值，而sorted(x).reserve()这才是正确做法
sorted
实际上可以用于任意可迭代对象
返回一个列表

字符串操作

字符串转化为大小写

string = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca',
np.nan, 'CABA', 'dog', 'cat'])
print(string)
string.str.lower()
string.str.upper()

练习题（认为不错的）

不是很明白为什么有很多的题目并不是在考算法，单纯只是考察你对题目概念的一种理解方式，可能在对数学运算上抽象出矩阵进行科研有帮助吧。

1010 一元多项式求导 (25 分)

这道题的代码值得研究！

a=list(map(int,input().split()))
n=len(a)
res=[]
for i in range(0,n,2):
m=a[i]*a[i+1]
b=a[i+1]-1
if m:
res.append(str(m))
res.append(str(b))
if not (len(res)):
print('0 0')
else:
print(' '.join(res))

1011 A+B 和 C (15 分)

n=int(input())
dic={}
for i in range(n):
dic[i]=list(map(int,input().split()))
for i in range(n):
if dic[i][0]+dic[i][1]>dic[i][2]:
print("Case #{}: true".format(i+1))
else:
print("Case #{}: false".format(i+1))

1015 德才论 (25 分)

存在两个测试点运行超时

def rank(x):
return x[3],int(x[1]),-int(x[0])
a=list(map(int,input().split()))
n=a[0];l=a[1];h=a[2]
a=[];b=[];c=[];d=[]
for i in range(n):
x=input().split()
if int(x[1])<l or int(x[2])<l:
continue
x.append(int(x[1])+int(x[2]))
if int(x[1])>=h and int(x[2])>=h:
a.append(x)
elif int(x[1])>=h and int(x[2])<h:
b.append(x)
elif int(x[1])<h and int(x[2])<h and int(x[1])>=int(x[2]):
c.append(x)
else:
d.append(x)
a=sorted(a,key=rank,reverse=True)
b=sorted(b,key=rank,reverse=True)
c=sorted(c,key=rank,reverse=True)
d=sorted(d,key=rank,reverse=True)
e=a+b+c+d
print(len(e))
for i in e:
print(' '.join(i[:-1]))

1019. 数字黑洞 (20)

错误解法：

num=input()
while True:
ac=str().join(sorted(list(num)))
dec=int( ac[-1::-1])
ac=int(ac)
num=dec - ac
print("%04d - %04d = %04d"%(dec,ac,num))
if num in (0,6174): # 这个和range(6194)有什么区别？
break
num="%04d"%(num)

错误结果：

45
0054 - 0045 = 0009 # 0054 应该是5400
9000 - 0009 = 8991
9981 - 1899 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174

正确解法：

# num=input()
num=str("{:0>4}".format(input())) # 就是输入的时候需要进行格式补齐
while True:
ac=str().join(sorted(list(num)))
dec=int( ac[-1::-1])
ac=int(ac)
num=dec - ac
print("%04d - %04d = %04d"%(dec,ac,num))
if num in (0,6174): # 这个和range(6194)有什么区别？
break
num="%04d"%(num)

1020 月饼 (25 分)

python没有类似结构体的存放方式，如何才能做类似这种操作？

a = input().split() # 种类 需求量
b = input().split() # 供应量
c = input().split() # 总价
price = {i:float(c[i])/float(b[i]) for i in range(int(a[0]))}
price2 = sorted(price, key=lambda i:price[i], reverse=True)
# price2 单价非递增排序
result = 0
n = int(a[1])
for i in price2:
if n>=float(b[i]):
result += int(c[i])
n -= float(b[i])
else:
result += n*price[i]
break
print("%.2f" % result)

1025 反转链表 (25 分)(未解决）

什么样的情况下代码会出现不适合用console运行的情况？？？

# 这个代码c的风格太明显了
link=[None]*100000
#add最大99999
head,N,K=map(int,input().split(' '))
for i in range(N):
add,data,next=map(int,input().split(' '))
link[add]=[data,next]
T,p=[],head
while -1!=p:
if None==link[p]:break
#print(p,*node)
T.append(["%05d"%(p) ,link[p][0]])
p=link[p][1]
for j in range(K-1,len(T),K):
i=j-K+1
while i<j:
T[i],T[j]=T[j],T[i]
i+=1
j-=1
T.append(['-1'])
for i in range(len(T)-1):
print("%s %d %s"%(T[i][0],T[i][1],T[i+1][0]))

python代码的老毛病，解释型程序，代码有大量循环语句和输入输出语句的时候，会大幅度降低代码的速度，cpython了解一下？

和上面的Python解法完全一样，只因为输入输出快了，所以能AC。

#include <stdio.h>
#include<map>
using namespace std;
pair<int, int> A[100000];	//0~99999
A[]=<data,next>
int main(){
int head, N, K;
scanf("%d %d %d", &head, &N, &K);
pair<int, int> *link = new pair<int, int>[N+1];	//用顺序表模拟链表
while (N-- > 0) {
int p, data, next;
scanf("%d %d %d", &p, &data, &next);
A[p] = { data,next };	//直接映射哈希存储：p为关键词
}
int len = 0;	//link数组（代表链表）的有效长度
while (-1 != head) {
link[len++] = { head,A[head].first };	//={add,data}
head = A[head].second;
//=next
}
for (int step = K; step <= len; step+=K) {	//每凑足K个逆置
for (int i = step - K, j = step - 1; i < j; i++, j--) {
swap(link[i], link[j]);	//交换
}
}
for (int i = 0; true; ) {
printf("%05d %d ", link[i].first, link[i].second);
if (++i<len)
printf("%05dn", link[i].first);
else{	//是最后一个
printf("-1n"); break;
}
}
return 0;
}

其实没比Python版本长多少，所以此题不适合用Python。

函数库部分

Pandas

数据操作

1、DataFrame 求平均值操作：

# 实现1
df.mean()
# 实现2
df['age'].sum()/df.count(axis=0)['age']

2、删除缺失行/填充

# 删除
df.dropna(how = 'any')
# 填充
df.fillna(value=3)# 一般填充都是使用众数或者中位数

文件读取

df3.to_csv('animal.csv', index=True, header=True, sep=','))# 默认为True写入
#df.to_csv('animal.csv' )
df_animal = pd.read_csv('animal.csv',header = 1)# Header默认为0,表示数据的第几行为列标签,数据为列名行以下的数据
df_animal

最后

以上就是大力微笑为你收集整理的PAT_程序设计笔记（更新中）ziplambdamap函数的使用方法：正则表达式Prime处理素数的方法递归核心思想操作符练习题（认为不错的）函数库部分的全部内容，希望文章能够帮你解决PAT_程序设计笔记（更新中）ziplambdamap函数的使用方法：正则表达式Prime处理素数的方法递归核心思想操作符练习题（认为不错的）函数库部分所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。