PAT_程序设计笔记（更新中）

PAT传送门

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]
>>>

正则表达式

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

.	表示任何单个字符
[ ]	字符集，对单个字符给出取值范围	[abc]表示a,b,c [a-z]表示a到z的所有单个字符
[^]	非字符集，对单个字符给出排除范围	[^abc]表示非a或b或c的单个字符
*	前一个字符的零次或无限次扩展	abc*表示ab,abc,abcc,abccc等
+	前一个字符的一次或无限次扩展	abc+表示abc,abcc,abccc等
?	前一个字符零次或一次扩展	abc?表示ab,abc
|	左右表达式任意一个	abc|def表示abc,def
{m}	扩展前一个字符m次	ab{2}c表示abbc
{m,n}	扩展前一个字符m至n次（含n次）	ab{1,2}表示abc,abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串的结尾
()	分组标记，内部只能使用|操作符	(abc)表示abc,(abc|def)表示abc,def
\d	数字，等价于[0-9]	–

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()是内置函数

针对remove\reserve\sort没有返回值的状况使用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("%05d\n", link[i].first);
		else{	//是最后一个
			printf("-1\n"); 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