Python 常用的函数及模板

最近开始用Python刷题，以下方法和函数都是基于Python3，记录一下常用的排序函数，常用的容器等，学到一些新的也会加进去

创建三维 的 l * m * n 数组：

L = [ [ [0] * n for i in range(m) ] for i in range(l)]

# [[[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]], [[0, 0], [0, 0], [0, 0]]]
# l[4][3][2] 矩阵
l = [[[0 for i in range(2)] for j in range(3)] for k in range(4)]

# 创建值为2的字典，可嵌套
dp = defaultdict(lambda : defaultdict(lambda : 2))

list排序：

#list为二维以上数组，且list为2维以上的数组，会按照l[i]的长度，l[0]的大小，l[1]的大小降序排序，优先级依次为l的长度，l[0],l[1]的大小升序排序
from operator import *

l = [[1,2,3],[1,1,3],[2,1,2],[1,1,1,1]]
l.sort(key = lambda x :(len(x),x[0],x[1]))
#输出为： [[1, 1, 3], [1, 2, 3], [2, 1, 2], [1, 1, 1, 1]]

#排序时可以选择加上 参数 revrese,即为按lambda设置的参数倒序输出
l.sort(key = lambda x:(len(x),x[0],x[1]),reverse = True)
#输出为：[[1, 1, 1, 1], [2, 1, 2], [1, 2, 3], [1, 1, 3]]

#需导入 from operator import *
l.sort(key = itemgetter(0,1))
#以上述的结果按第一列第二列的值进行排序，排序的结果为：[[1, 1, 1, 1], [1, 1, 3], [1, 2, 3], [2, 1, 2]]

# 第一种方法：
import functools
nums = '1325135'
#一定要写清楚哪种方法返回1，哪种返回-1，按照设置-1的顺序排序
def cmp(s1,s2):
    return -1 if s1 > s2 else 1
	# return 1 if s1 + s2 < s2 + s1 else -1
nums = [str(i) for i in nums]
#按照nums的关键字排序,但是是按cmp的规则逆序排序
nums.sort(key = functools.cmp_to_key(cmp))
# 输出为['5', '5', '3', '3', '2', '1', '1']


#第二种方法：将key的值设置为类，在类的__lt__函数中设置排序顺序，最后得到的顺序与自己设置的一样
# __gt__为大于，升序，__lt__为小于，降序，只能取其中一个
class LargerNumKey(str):
    # def __lt__(x, y):
    #     return x < y
    def __gt__(x,y):
        return x > y
nums.sort(key = LargerNumKey)
# 输出为['1', '1', '2', '3', '3', '5', '5']


arr = [0,1,2,3,4,5,6,7,8]
l = [0, 1, 1, 2, 1, 2, 2, 3, 1]
# 将两个list zip后按照l的大小的相对位置进行排序
r = [y for x,y in sorted(zip(l,arr))]
# 输出为r = [0,1,2,4,8,3,5,6,7]

zip

a = [i for i in range(4)]
b = [i for i in range(4,10)]
c = zip(a,b)
# c为[(0,4),(1,5),(2,6),(3,7)]
d,e = zip(*c)
# d = (0, 1, 2, 3),e = (4, 5, 6, 7)

# python 版本要求 3.10 以上可用
from itertools import pairwise

a = [[1, 3, 4], [2, 3, 5], [3, 2]]
for i,j in pairwise(a):
    print(i,j)
# [1, 3, 4] [2, 3, 5]
# [2, 3, 5] [3, 2]

字典排序：

#字典中的函数
d = {'a':12,'b':23,'aa':13,'bad':23}
print(d.keys()),print(d.values())
#输出为：dict_keys(['a', 'b', 'aa', 'bad']) dict_values([12, 23, 13, 23])
print(d.items())
#输出以字典d键值对的元祖：dict_items([('a', 12), ('b', 23), ('aa', 13), ('bad', 23)])
print(d.get(1),d.get('a'))
#输出为：None 12

#对字典排序，字典没有sort方法
print(sorted(d))
#默认对d的键进行排序，逆序输出，输出为：['a', 'aa', 'b', 'bad']
print(sorted(d.values))
#对d的值进行排序，逆序输出，输出为：[12, 13, 23, 23]

t= sorted(d.items(),key=lambda x:x[0])
print(t)
#以d.items()为对象排序，按照键的值升序排序，输出为元组，结果为：[('a', 12), ('aa', 13), ('b', 23), ('bad', 23)]

from operator import itemgetter
print(sorted(d.items(),key=itemgetter(0)))
#itemgetter(0)，获取key，按key值排序，与lambda类似，同样也可以进行多值排序，在itemgetter中加入(0,1)，输出为元组，结果为：[('a', 12), ('aa', 13), ('b', 23), ('bad', 23)]

集合操作

# 如果创建空集合，s = set(),集合元素不能为list,dict
s = {1, 2, 3, 4}
s1 = {1, 100, 50, 90, "test"}
s.add((1, 2, 3))

# {1, 2, 3, 4, (1, 2, 3)}
print(s)

# {0, 1, 2, 3, 4, 10, (1, 2, 3)}
# 将元素中的数据挨个加入集合
s.update([1, 2, 4, 10, 0])
print(s)
# 整体加入集合

s.add("test")
# {0, 1, 2, 3, 4, 10, (1, 2, 3), 'test'}
print(s)

# remove方法需要元素在集合中，不然会报错
s.remove(1)
print(s)

# 元素在集合中就删除，不在集合中也不会报错
s.discard(1010)
s.discard(10)
print(s)

# 集合的运算

# 集合的交集,集合s不变
p = s.intersection(s1)
# 运算符操作，效果一样
p = s & s1
# {'test'}
print(p)

# 集合的并集,集合s不变
p = s.union(s1)
# 运算符操作
p = s | s1
# {0, 1, 2, 3, 4, 100, (1, 2, 3), 50, 'test', 90}
print(p)

# 在集合s中但不在集合s1中，集合s不变
p = s.difference(s1)
# 运算符操作
p = s - s1
# {0, 2, 3, 4, (1, 2, 3)}
print(p)

# 返回 (s | s1) - (s & s1)
p = s.symmetric_difference(s1)
# {0, 1, 2, 3, 4, (1, 2, 3), 90, 100, 50}
print(p)

堆的使用

h = []
#i为小根堆，-i为大根堆
for i in nums:
    heapq.heappush(h,-i)
for i in range(k -1):
    heapq.heappop(h)
return -h[0]

字符串处理

p = [1,2,5,4,6,7]
data = ' '.join([str(i) for i in p])
print(data,type(data))
# 将list中的数字转为字符串并用空格隔开
# 1 2 5 4 6 7 <class 'str'>
data = data.split()
print(data)
# 去除空格 ['1', '2', '5', '4', '6', '7']
data = [int(i) for i in data]
# 转换为int 型list
# print(data) [1, 2, 5, 4, 6, 7]

双端队列

from collections import *
# 初始化队列为list
q = deque([])
# 从右侧加入数据
q.append(1)
# 从左侧加入数据
q.appendleft(2)
l = [1,4,2,5]
q.append(l)
# print(q) deque([2, 1, [1, 4, 2, 5]])
q.popleft()
q.pop()
# print(q) deque([1])

dict创建

# 创建默value 值为0，key值为26个小写字母
d1 = {chr(x): 0 for x in range(ord('a'), ord('z') + 1)}

python 处理输入数据

c,n,m = map(int,input().strip().split())
# 输入整形数组
l = list(map(int, input().strip().split()))
# 多组输入
while True:
    try:
        data=map(int,input().strip().split())
    except EOFError:
        break

保留有效数字

a = 3.12156
# 方法一
print('%.1f' % a)

# 方法二
print('{:.1f}'.format(a))

SortedList

# SortedKeyList([4, 3, 3, 2, 1], key=<function <lambda> at 0x0000024D35D4F160>)
S = SortedList([1, 2, 3, 4, 3], key=lambda x: -x)

# SortedKeyList([1, 1, 2, 3, 3, 4, 23, 23, 42], key=<built-in function pos>) neg 为降序，pos为升序
S = SortedList([1, 2, 3, 4, 3], key=pos)

# 添加元素
# 加入元素,复杂度O(log n)
S.add(23)
print(S)
# 将列表中的元素依次加入，复杂度O(k * long(n))
S.update([23, 42, 1])
print(S)

# 删除元素
# 存在元素删除，不存在不会报错，复杂度O(log n)
S.discard(100)

# 移除一个元素，如果元素不存在，报错ValueError。复杂度O(log(n)).
# S.remove(value=199)
print(S)
# 移除指定下标元素，如果有序序列为空或者下标超限，报错IndexError. 复杂度O(log n)
S.pop(index=-1)

print(S)
# 查找元素
t = S.bisect_left(100)
print(t)