py笔记

头文件：

import sys
import math
import heapq
import bisect

from collections import deque,Counter
from functools import cmp_to_key

input = sys.stdin.readline

def solve():
    pass

T=int(input())
for _ in range(T)://py没有自增自减
    solve()

#多组输入，EOF为止
while True:
    try:
        solve()
    except EOFError:
        break

C++                                  Python
---------------------------------------------------------------
cin >> n;                            n = int(input())
cin >> a >> b;                       a,b = map(int,input().split())
cin >> s;                            s = input().strip()
cout << ans << '\n';                 print(ans)
                                     a = list(map(int,input().split()))//读入数组

vector<int> a(n);                    a = [0] * n //一维数组
vector<int> a(n, -1);                a = [-1] * n
vector<vector<int>> g(n);            g = [[] for _ in range(n)]//二维数组不能直接乘。用于建图
a.push_back(x);                      a.append(x)
a.size()                             len(a)
a.empty()                            not a
for(int i=0;i<n;i++)                 for i in range(n): //遍历
for(int i=n-1;i>=0;i--)              for i in range(n-1,-1,-1):
for(auto x : a)                      for x in a:
swap(a,b);                           a,b = b,a   //交换
queue<int> q;                        q = deque() //队列
q.push(x);                           q.append(x)
q.front(); q.pop();                  q.popleft()
stack<int> st;                       st = []     //栈
st.push(x);                          st.append(x)
st.top();                            st[-1]
st.pop();                            st.pop()
priority_queue<int> q;               import heapq,q = []//该模块让列表实现小根堆
q.push({d,u});                       heapq.heappush(q,(d,u))
q.top(); q.pop();                    heapq.heappop(q)
                                     heapq.heappush(q,-x) //大根堆
                                     x = -heapq.heappop(q) //大根堆                                                       
unordered_set<int> st;               st = set()  //set
st.insert(x);                        st.add(x)
st.count(x);                         x in st
st.erase(x);                         st.discard(x)
                                     
string s;                            s = "" //字符串
s.size();                            len(s)
s.substr(i,k);                       s[i:i+k]
s += t;                              s += t
to_string(x);                        str(x)//变量类型可以互换
                                     max(w)//列表最大值直接获得
                                     sum(w)//列表求和
                                     INF = float('inf') 
                                     dist = [INF] * (n + 1)//初始化为正无穷
pair<int,int> p={a,b};               p = (a,b) //元组
auto [x,y]=p;                        x,y = p
const int INF = 1e9;                 INF = 10**9 //数学
快速幂取模                            pow(a,b,mod)

__gcd(a,b);                          math.gcd(a,b)

关于math模块：

math.gcd(12,18)	最大公约数	6
math.lcm(12,18)	最小公倍数	36
math.sqrt(16)	平方根（浮点数）	4.0
math.isqrt(17)	整数平方根	4
math.ceil(3.2)	向上取整	4
math.floor(3.8)	向下取整	3
math.factorial(5) 阶乘	120
math.comb(5,2)	组合数	10
math.perm(5,2)	排列数	20

关于进制：

#十进制转其他
print(format(10, 'b'))  # 1010   返回的是字符串
print(format(10, 'o'))  # 12
print(format(10, 'x'))  # a
#其他进制转十进制
print(int('1010', 2))  # 10
print(int('12', 8))    # 10
print(int('a', 16))    # 10

关于输出：

#默认参数
print(a,sep=' ',end='\n')
print(a) #默认结尾换行
print(a, b, c) #默认空格间隔，最后换行
print(*a) #默认空格间隔，最后换行
print(1, 2, 3, sep=',') #逗号间隔，最后换行
print(1,end='') #设置为空，最后不换行

关于map和Counter：

mp = {}
mp["Alice"] = 90#赋值
mp[x] = mp.get(x, 0) + 1#访问，若不存在返回参数二，不会自动创建
for x, y in mp.items():#遍历
    print(x, y)
for x in sorted(mp):#像c++中按键递增
    print(x, mp[x])

from collections import Counter#专用来计数
a = [1, 2, 1, 3, 2, 1]
mp = Counter(a)
print(mp[1])  # 3
print(mp[2])  # 2

关于二维数组初始化：

a = [[0] * m for _ in range(n)]#n*m

n, m = map(int, input().split())#读入二维数组
a = []
for _ in range(n):
    row = list(map(int, input().split()))
    a.append(row)

for i in range(n):#遍历
    for j in range(m):
        print(a[i][j], end=' ')
    print()

关于二分查找bisect模块：

import bisect
bisect_left(a, x)#返回列表a中第一个>=x的下标，相当于下面
lower_bound(a.begin(), a.end(), x) - a.begin();
bisect_right(a, x)# 严格>
upper_bound(a.begin(), a.end(), x) - a.begin();
#还可以实现统计一个数字出现多少次
ans = bisect_right(a, x) - bisect_left(a, x)

关于排序：

a.sort()                # 升序
a.sort(reverse=True)    # 降序

# 自定义比较函数
from functools import cmp_to_key
def cmp(x, y):
    if x + y > y + x:
        return -1 #x在前
    elif x + y < y + x:
        return 1
    return 0
a.sort(key=cmp_to_key(cmp))

字符串不能直接sort：

#字符串排序
a=sorted(s,reverse=True)#sorted函数返回列表
q=''.join(a)#将列表再组装成字符串。
#join函数实现：将a（可以是列表或字符串）各元素以特定字符为间隔组成字符串返回

关于字符的ASCII码：

#py中不能像c++直接减，用ord函数
ch = 'b'
d = ord(ch) - ord('a')

易错点：

#数组复制易错点
a = [1, 2, 3]
b = a
b[0] = 10
print(a)  # [10, 2, 3]
//要用b = a.copy()

#并查集find函数不能链式赋值

#py类中的函数首参数必须是self，所有力扣尽量用嵌套函数
#嵌套函数中,全局或外部变量可以直接访问，但修改需要声明，否则默认是局部变量：全局变量用 global a ，外部函数变量用nonlocal a。