Python算法比赛用到的函数或模块

输入接收

# 输入接收形式，列表、字典等用推导式
n,d=map(int,input().split())
list_q=[[i for i in map(int,input().split())] for j in range(n)]

输出

print(' '.join(map(str,list)))

可以用的模块或函数

import math
# 不能直接导入collections，只能使用里面的部分类
from collections import Counter
from collections import deque
from collections import OrderedDict
import heapq
import functools
import sys
import io
import re
import string
import time
from datetime import datetime

for循环

students = ['Alice', 'Bob', 'Charlie']
scores = [90, 80, 85]
for student, score in zip(students, scores):
    print(student, score)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed_matrix = [list(row) for row in zip(*matrix)]
print(transposed_matrix)

进制转换

# 十进制转二进制
print(bin(10))  # output:0b1010
# 十进制转八进制
print(oct(10))  # output:0o12
# 十进制转十六进制
print(hex(10))  # output:0xa
# 二进制转十进制
print(int("1010", 2))  # output:10
# 八进制转十进制
print(int("12", 8))  # output:10
# 十六进制转十进制
print(int("0A", 16))  # output:10
# 二进制转八进制
print(oct(int("1010", 2)))  # output:0o12
# 二进制转十六进制
print(hex(int("1010", 2)))  # output:0xa

常用math方法

import math

# 返回大于或等于x的最小整数
print(math.ceil(4.1))  # output:5
# 返回小于或等于x的最大整数
print(math.floor(4.9))  # output:4
# 返回x的平方根。x必须大于等于 0，否则会产生ValueError
print(math.sqrt(9))  # output:3.0
print(math.pow(2, 3))  # output:8.0
# 返回e的x次幂
print(math.exp(1))  # 2.718281828459045
# 则返回以base为底x的对数,如果没有指定base,则以e为底
print(math.log(10))  # 2.302585092994046
print(math.log(100, 10))  # 2.0
# 分别返回x（弧度制）的正弦、余弦和正切值
print(math.sin(math.pi / 2))  # 1.0
print(math.cos(0))  # 1.0
print(math.tan(math.pi / 4))  # 0.9999999999999999
# 分别返回x的反正弦、反余弦和反正切值（结果是弧度制）
print(math.asin(1))  # 1.5707963267948966
print(math.acos(0))  # 1.5707963267948966
print(math.atan(1))  # 0.7853981633974483
# 将弧度转换为角度
print(math.degrees(math.pi / 2))  # 90.0
# 将角度转换为弧度
print(math.radians(90))  # output:1.5707963267948966
# 返回n!
print(math.factorial(5))  # output:120
# 返回a和b的最大公约数
print(math.gcd(12, 18, 3))  # output:3
# 从5个元素中取出3个元素的组合数
print(math.comb(5, 3))  # output:10
# 计算两个相同维度的点之间的欧几里得距离
print(math.dist((1, 2), (4, 6)))  # output:5.0
print(math.fabs(-10))  # output:10.0
print(math.fmod(10, 2))  # output:0.0

常用字符串方法

• f - strings

# f-strings
name = "Alice"
age = 25
print(f"My name is {name} and I'm {age}years old.")
# output:My name is Alice and I'm 25years old.
num1 = 3.14159
num2 = 3
print(f"浮点数格式化输出：{num1:.2f}；整数格式化输出：{num2:d}")
# output:浮点数格式化输出：3.14；整数格式化输出：3

• 增

str1 = '123'
str2 = 'abc'
str1 += str2
print(str1)  # output:123abc

• 删

str = "123 abc"
str = str.replace("3 a", "")
print(str)  # output:12bc
str = '123 abc'
str = str[2:5]
print(str)  # output:3 a
# strip()：用于去除字符串开头和结尾的指定字符，默认为空白字符（包括空格、制表符、换行符等）
print(' a b c '.strip())  # output:a b c
# 只去开头
print(' a b c '.lstrip())  # output:a b c
# 只去结尾
print(' a b c '.rstrip())  # output: a b c

• 改

print('abc abc'.replace('a', 'A'))  # output:Abc Abc
# 根据转换表（通过maketrans()函数创建）来替换字符串中的字符
trans_table = str.maketrans("abc", "***")
print(trans_table)  # {97: 42, 98: 42, 99: 42}
print('abc123'.translate(trans_table))  # output:***123

• 查

# 查找子字符串第一次出现的位置。
# 如找到，返回起始索引；如没找到，返回-1
# find()从左开始查找，rfind()从右开始查找
print('abc abc'.find('a'))  # output:0
print('abc abc'.rfind('abc'))  # output:4
# index(),rindex与find(),rfind()对应，
# 区别在于没找到，前两个引发ValueError异常，后两个返回-1
print('abc abc'.index('abc'))  # output:0
print('abc abc'.rindex('abc'))  # output:4

• 其它

print('abc abc'.count('abc'))  # output:2
# ord()返回单个字符的 Unicode 码点,与chr对应
print(ord('A'))  # output:65
print(chr(65))  # output:A
# split()从左开始分割，rsplist()从右开始分割
print('a,b,c'.split(","))  # output:['a', 'b', 'c']
print('a,b,c'.rsplit(","))  # output:['a', 'b', 'c']
print('|'.join('abc'))  # output:a|b|c
print('|'.join(['abc', 'abc']))  # output:abc|abc
print('ABC'.lower())  # output:abc
print('abc'.upper())  # output:ABC
# 大小写互换
print('abc ABC'.swapcase())  # output:ABC abc
# 每个单词的首字母转换为大写，其余字母转换为小写
print('abc abc'.title())  # output:Abc Abc
# 字符串第一个字母转换为大写，其余字母转换为小写
print('aBC ABC'.capitalize())  # output:Abc abc
print(len('abc'))  # output:3
# 判断字符串是否以指定的子字符串开头
print('abc abc'.startswith('abc'))  # output:True
# 判断字符串是否以指定的子字符串结尾
print('abc abc'.endswith('abc'))  # output:True
# isalpha()：判断字符串中的所有字符是否都是字母
print('abc'.isalpha())  # output:True
print('abc123'.isalpha())  # output:False
# isdigit()：判断字符串中的所有字符是否都是数字
print('123'.isdigit())  # output:True
# 判断是否都是大写字母
print('ABC'.isupper())  # output:True
# 判断是否都是大写字母
print('abc'.islower())  # output:True
# 判断首字母是否是大写
print('Abc'.istitle())  # output:True
# 判断是否都是空白字符。空白字符包括空格、制表符（\t）、换行符（\n）、回车符（\r）等
print('  '.isspace())  # output:True

常用列表方法

• 增

# append()用于在列表的末尾添加一个元素
list = [1, 2, 3]
list.append(4)
print(list)  # output:[1, 2, 3, 4]
# extend()将一个可迭代对象中的元素逐个添加到列表的末尾。
list = [1, 2, 3]
list.extend((1, 2, 3))  # '123' [1,2,3]
print(list)  # output:[1, 2, 3, 1, 2, 3]
# insert()用于在列表的指定位置插入一个元素。
# 它接受两个参数，第一个参数是要插入的位置索引，第二个参数是要插入的元素。
list = [1, 2, 3]
list.insert(1, 4)
print(list)  # output:[1, 4, 2, 3]

• 删

# remove()用于从列表中删除第一个匹配的指定元素。
# 如果列表中不存在该元素，则会抛出异常。
list = [1, 2, 3, 2]
list.remove(2)
print(list)  # output:[1, 3, 2]
# 用于删除并返回列表中指定位置的元素。
# 如果不指定位置，默认删除并返回列表的最后一个元素。
list = ['a', 'b', 'c']
print(list.pop(1))  # output:b
print(list)  # output:['a', 'c']

• 改

# 通过索引修改单个元素
my_list = [1, 2, 3, 4, 5]
my_list[1] = 6
my_list[2] = 7
print(my_list)  # output:[1, 6, 7, 4, 5]
# 通过切片修改多个元素
my_list = [1, 2, 3, 4, 5]
my_list[1:3] = [6, 7]
print(my_list)  # output:[1, 6, 7, 4, 5]

• 查

# index()用于返回列表中第一个匹配的指定元素的索引。
# 如果列表中不存在该元素，则会抛出异常。
print([1, 2, 3, 2].index(2))  # output:1

• 其它

# count()用于统计列表中指定元素出现的次数
print([1, 2, 3, 2].count(2))  # output:2
# sort()用于对列表中的元素进行排序。
# 默认是升序排序，如果要进行降序排序，可以设置reverse=True参数。
list = [3, 1, 4, 1]
list.sort()
print(list)  # output:[1, 1, 3, 4]
list = [3, 1, 4, 1]
list.sort(reverse=True)
print(list)  # output:[4, 3, 1, 1]
# reverse()用于将列表中的元素反转
list = [1, 3, 2]
list.reverse()
print(list)  # output:[2, 3, 1]

常用字典方法

• 增

# update()用于将一个字典中的键-值对更新到另一个字典中。
# 如果被更新的字典中已经存在相同的键，则会用新的值覆盖旧的值；
# 如果不存在，则会添加新的键-值对。
my_dict1 = {'a': 1, 'b': 2}
my_dict2 = {'b': 3, 'c': 4}
my_dict1.update(my_dict2)
print(my_dict1) # output:{'a': 1, 'b': 3, 'c': 4}

• 删

# pop()用于移除字典中指定键的键 - 值对，并返回被移除的值。
# 如果键不存在，会引发KeyError异常
# （可以通过第二个参数指定不存在时的默认返回值）。
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.pop('a')
print(my_dict)  # output:{'b': 2, 'c': 3}
print(value)  # output:1
try:
    value2 = my_dict.pop('d')
except KeyError:
    print("键不存在")  # output:键不存在
value3 = my_dict.pop('e', 0)
print(value3)  # output:0
# popitem()移除(以后进先出的顺序)并返回字典中的一个键-值对
my_dict = {'a': 1, 'b': 2, 'c': 3}
item = my_dict.popitem()
print(my_dict)  # output:{'a': 1, 'b': 2}
print(item)  # output:('c', 3)
# clear()用于清空字典中的所有键 - 值对，将字典变为一个空字典
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)  # output:{}

• 改

# setdefault()设置键值对，如果键不存在，在表中增添键值对，返回默认值，默认值可以修改
dict = {'a': 1, 'b': 2}
print(dict.setdefault('c'))  # output:None
print(dict)  # output:{'a': 1, 'b': 2, 'c': None}
dict = {'a': 1, 'b': 2}
print(dict.setdefault('c', 3))  # output:3
print(dict)  # output:{'a': 1, 'b': 2, 'c': 3}

• 查

dict = {'a': 1, 'b': 2}
# get()获取键对应值，不改变字典，如果键不存在，返回默认值，默认值可以修改
print(dict.get('c'))  # output:None
print(dict.get('c', 3))  # output:3
print(dict)  # output:{'a': 1, 'b': 2}

• 其它

# keys()返回一个可迭代视图对象,表示字典中的所有键
print({'a': 1, 'b': 2, 'c': 3}.keys())
# output:dict_keys(['a', 'b', 'c'])
for key in {'a': 1, 'b': 2, 'c': 3}.keys():
    print(key)
# output:
# a
# b
# c
# values()返回一个可迭代视图对象,表示字典中的所有值
print({'a': 1, 'b': 2, 'c': 3}.values())
# output:dict_values([1, 2, 3])
for value in {'a': 1, 'b': 2, 'c': 3}.values():
    print(value)
# output:
# 1
# 2
# 3
# items()返回一个可迭代视图对象,其中的每个元素是一个包含键和值的元组
print({'a': 1, 'b': 2, 'c': 3}.items())
# output:dict_items([('a', 1), ('b', 2), ('c', 3)])
for item in {'a': 1, 'b': 2, 'c': 3}.items():
    print(item)
# output:
# ('a', 1)
# ('b', 2)
# ('c', 3)
for key,value in {'a': 1, 'b': 2, 'c': 3}.items():
    print(key,value)
# output:
# a 1
# b 2
# c 3

常用集合方法

• 增

list1 = {1, 2, 3}
print(list1)  # output:{1, 2, 3}
# 向集合中添加一个元素。如果元素已存在，集合不会发生变化。
print(list1.add(4))  # output:None
print(list1) # {1, 2, 3, 4}
# 将一个可迭代对象中的元素添加到集合中。
print(list1.update([5, 6 ,7]))  # output:None
print(list1) # {1, 2, 3, 4, 5, 6, 7}

• 删

# 删除指定的元素,如果元素不存在，会抛出KeyError异常。
print({1, 2, 3}.remove(3))  # output:None
# 删除指定的元素,如果元素不存在，不会会抛出异常。
print({1, 2, 3}.discard(3))  # output:None

• 改

set中对的元素是不可变的，不能直接修改，没有修改方法，可以通过删+增进行间接修改

• 查

# 检查元素是否在集合中
print(2 in {1, 2, 3})  # output:True

• 其它

# 求交集，返回一个新的集合
print({1, 2, 3} & {3, 4, 5})  # output:{3}
# 求并集，返回一个新的集合
print({1, 2, 3} | {3, 4, 5})  # output:{1, 2, 3, 4, 5}
# 求差集，返回一个新的集合
print({1, 2, 3} - {3, 4, 5})  # output:{1, 2}
# 求对称差集，返回一个新的集合
print({1, 2, 3} ^ {3, 4, 5})  # output:{1, 2, 4, 5}

# 检查一个集合是否是另一个集合的超集
print({1, 2}.issubset({1, 2, 3}))  # output:True
# 检查一个集合是否是另一个集合的超集
print({1, 2, 3}.issuperset({1, 2}))  # output:True

常用元组方法

• 查

my_tuple = (1, 2, 3, 2, 4)
print(my_tuple.index(2))  # output:1

• 其它

my_tuple = (1, 2, 2, 3, 4)
print(my_tuple.count(2))  # output:2

collections模块部分类的常用方法

• Counter类

from collections import Counter

# Counter是一个容器，用于对可哈希（散列）对象进行计数，对元素出现次数进行统计
# 列表和字典和集合不可哈希，或者说不可散列
# 字符串、元组可哈希
# 虽然列表本身不可哈希，但是Counter类在内部并不是直接对列表进行哈希操作
list = [1, 2, 3, 2, 1, 3, 1]
counter_obj = Counter(list)
print(counter_obj)  # output:Counter({1: 3, 2: 2, 3: 2})
# Counter对象可以看作是一个字典子类，可以使用索引访问
print(counter_obj[1])  # output:3

# most_common()返回一个按照元素计数从高到低排序的元组列表
print(counter_obj.most_common())  # output:[(1, 3), (2, 2), (3, 2)]
# 返回出现次数最多的前2个元素及其计数的元组列表
print(counter_obj.most_common(2))  # output:[(1, 3), (2, 2)]

# update()方法
# 用于更新Counter对象的计数。
# 可以传入一个可迭代对象，将其中元素的计数添加到当前Counter对象中
counter1 = Counter([1, 2, 3])
counter2 = Counter([3, 4, 5])
counter1.update(counter2)
print(counter1)  # output:Counter({3: 2, 1: 1, 2: 1, 4: 1, 5: 1})

# elements()方法返回一个迭代器，该迭代器会根据元素的计数重复返回元素。
# 简单地说，它会按照元素出现的次数，将元素逐个返回
# 元素返回的顺序是不确定的，因为Counter是基于字典的，字典本身是无序的。
elements_iter = counter_obj.elements()
print(counter_obj)  # output:Counter({1: 3, 2: 2, 3: 2})
for element in elements_iter:
    print(element)
# output:
# 1
# 1
# 1
# 2
# 2
# 3
# 3

# clear()方法用于清空Counter对象中的所有元素计数
print("Before clear:", counter_obj)
# output:Before clear: Counter({1: 3, 2: 2, 3: 2})
counter_obj.clear()
print("After clear:", counter_obj)
# output:After clear: Counter()

• deque类
• • 增

from collections import deque

# 可以通过maxlen参数限制deque的最大长度
d = deque(maxlen = 3)

# insert()方法用于在双端队列的指定位置插入一个元素。
# 创建一个双端队列
my_deque = deque([1, 2, 3])
# 在索引为1的位置插入元素4
my_deque.insert(1, 4)
print(my_deque)  # output：deque([1, 4, 2, 3])

# append()在deque的右端（尾部）添加一个元素
d = deque([1, 2, 3])
d.append(4)
print(d)  # output：deque([1, 2, 3, 4])

# appendleft()在deque的左端（头部）添加一个元素
d = deque([1, 2, 3])
d.appendleft(0)
print(d)  # output：deque([0, 1, 2, 3])

# extend()在deque的右端（尾部）扩展一个可迭代对象（如列表、元组等）
d = deque([1, 2, 3])
new_elements = [4, 5, 6]
d.extend(new_elements)
print(d)  # output：deque([1, 2, 3, 4, 5, 6])

# extendleft()在deque的左端（头部）扩展一个可迭代对象
# 不过需要注意的是，当扩展一个可迭代对象时，其中的元素会以逆序的方式添加到deque的头部
d = deque([1, 2, 3])
new_elements = [4, 5, 6]
d.extendleft(new_elements)
print(d)  # output：deque([6, 5, 4, 1, 2, 3])

• • 删

from collections import deque

# pop()删除并返回deque的右端（尾部）的元素，不能索引删除
d = deque([1, 2, 3])
last_element = d.pop()
print(last_element)  # output：3
print(d)  # output：deque([1, 2])

# popleft()删除并返回deque的左端（头部）的元素，不能索引删除
d = deque([1, 2, 3])
first_element = d.popleft()
print(first_element)  # output：1
print(d)  # output：deque([2, 3])

# remove方法用于从双端队列deque中移除第一个匹配的元素
# 如果没有找到要移除的元素，会抛出ValueError异常
my_deque = deque([1, 2, 3, 2])
my_deque.remove(2)
print(my_deque)  # output：deque([1, 3, 2])

• • 改

pop()+inset()/append() popleft()+inset()/appendleft()

• • 查

from collections import deque

# 使用索引访问deque中的元素
d = deque([1, 2, 3])
print(d[0])  # output：1
print(d[1])  # output：2

# index方法用于返回指定元素在双端队列中的位置（索引）
d = deque([10, 20, 30, 20])
print(d.index(20))  # output:1

• • 其它

from collections import deque

# clear()清空双端队列中的所有元素
my_deque = deque([1, 2, 3])
print(len(my_deque))  # output:3
my_deque.clear()
print(len(my_deque))  # output:0

# rotate()将deque中的元素旋转
# 正数参数表示向右旋转，负数参数表示向左旋转
d = deque([1, 2, 3, 4, 5])
d.rotate(1)
print(d)  # output：deque([5, 1, 2, 3, 4])
d.rotate(-2)
print(d)  # output：deque([2, 3, 4, 5, 1])

# copy()创建deque对象的浅拷贝
# 浅拷贝意味着它会创建一个新的deque对象
# 新对象中的元素是原始deque对象中元素的引用
d1 = deque([1, 2, 3])
d2 = d1.copy()
print(d1)  # output:deque([1, 2, 3])
print(d2)  # output:deque([1, 2, 3])

# count()计算指定元素在双端队列中出现的次数
my_deque = deque([1, 2, 3, 2, 1])
print(my_deque.count(1))  # output:2
print(my_deque.count(4))  # output:0

# reverse方法用于反转双端队列中的元素顺序
my_deque = deque([1, 2, 3])
my_deque.reverse()
print(my_deque)  # output:deque([3, 2, 1])

• defaultdict类

from collections import defaultdict

# 它的主要作用是在访问时字典中不存在的键时，能够返回一个默认值
# 访问前字典是没有默认值的
# 而不是像普通字典那样抛出KeyError异常。

# 默认值是一个整数（默认为 0）
my_dict = defaultdict(int)
print(my_dict)  # output:defaultdict(<class 'int'>, {})
my_dict['key1'] += 1
print(my_dict['key1'])  # output:1
print(my_dict['key2'])  # output:0

# 默认值是列表（默认为空列表）
my_list_dict = defaultdict(list)
my_list_dict['key1'].append(1)
print(my_list_dict['key1'])  # output:[1]
print(my_list_dict['key2'])  # output:[]


# 自定义默认值函数
def custom_default():
    return ["default value"]


my_custom_dict = defaultdict(custom_default)
print(my_custom_dict['key1'])  # output:['default value']

# 统计一个列表中元素出现的次数，使用defaultdict比使用普通字典更简洁
# 使用defaultdict
my_list = [1, 2, 3, 1, 2]
count_dict = defaultdict(int)
for i in my_list:
    count_dict[i] += 1
print(count_dict)  # output:defaultdict(<class 'int'>, {1: 2, 2: 2, 3: 1})
# 使用普通字典
my_list = [1, 2, 3, 1, 2]
count_dict = {}
for i in my_list:
    if i in count_dict:
        count_dict[i] += 1
    else:
        count_dict[i] = 1
print(count_dict)  # output:{1: 2, 2: 2, 3: 1}

• OrderedDict类

from collections import OrderedDict

# OrderedDict是 Python 中的一个字典子类
# 与普通字典不同的是，OrderedDict会记住元素插入的顺序
# 在普通字典中，迭代字典的键或值时，顺序是不确定的（通常是按照哈希值排序）
# 而OrderedDict会按照元素插入的顺序进行迭代
# 实际上普通字典在python高版本中也具有一定的顺序性
ordered_dict = OrderedDict()
ordered_dict['first'] = 1
ordered_dict['second'] = 2
ordered_dict['third'] = 3
for key, value in ordered_dict.items():
    print(key, value)
# first 1
# second 2
# third 3

# 普通字典相等只需要存在的键值对相同，不需要键值对的顺序相同
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
print(dict1 == dict2)
# 有序字典相等不仅需要存在的键值对相同，还需要键值对的顺序相同
ordered_dict1 = OrderedDict([('a', 1), ('b', 2)])
ordered_dict2 = OrderedDict([('b', 2), ('a', 1)])
print(ordered_dict1 == ordered_dict2)

heapq模块常用方法

• heapq.heapify(x)

import heapq

# heapq.heapify(x)将列表x转换为堆
# 在堆数据结构中，最小元素总是位于根节点（索引为 0）
# 这个操作是在原列表上进行的，会改变列表的顺序
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
heapq.heapify(my_list)
print(my_list)
# output:[1, 1, 2, 3, 3, 9, 4, 6, 5, 5, 5]

• heapq.heappush(heap, item)

import heapq

# 将item添加到heap堆中
# 这个操作会维护堆的性质，即将新元素插入到合适的位置，以保证堆的有序性。
my_heap = []
heapq.heappush(my_heap, 3)
heapq.heappush(my_heap, 1)
heapq.heappush(my_heap, 4)
print(my_heap)  # output:[1, 3, 4]

• heapq.heappop(heap)

import heapq

# 从heap堆中弹出并返回最小的元素
# 这个操作会重新调整堆，使得剩余元素仍然保持堆的性质
my_heap = [1, 3, 4]
min_item = heapq.heappop(my_heap)
print(min_item)  # output:1
print(my_heap)  # output:[3, 4]

• heapq.heapreplace(heap, item)

import heapq

# 弹出并返回堆中的最小元素，然后将item插入堆中
# 这个操作比先调用heappop()然后再调用heappush()稍微高效一些
# 因为它可以在一次操作中完成这两个步骤
my_heap = [1, 3, 4]
new_item = 0
replaced_item = heapq.heapreplace(my_heap, new_item)
print(replaced_item)  # output:1
print(my_heap)  # output:[0, 3, 4]

• heapq.nlargest(n, iterable, key=None)

import heapq

# 从iterable可迭代对象中返回最大的n个元素
# 如果提供了key参数，它应该是一个接受一个参数的函数，用于从每个元素中提取比较键
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
largest_3 = heapq.nlargest(3, my_list)
print(largest_3)

students = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78},
    {'name': 'David', 'score': 90}
]
top_two_students = heapq.nlargest(2, students, key=lambda s: s['score'])
print(top_two_students)  # output:[9, 6, 5]

• heapq.nsmallest(n, iterable, key=None)

import heapq

# 从iterable可迭代对象中返回最小的n个元素
# 和nlargest类似，如果有key参数，则用于提取比较键
my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
smallest_3 = heapq.nsmallest(3, my_list)
print(smallest_3)
# output:[{'name': 'Bob', 'score': 92}, {'name': 'David', 'score': 90}]

nums = [4, 2, 7, 1]
result = heapq.nsmallest(2, nums)
print(result)  # output:[1, 1, 2]

itertools模块常用方法

• count(start=0, step=1)

import itertools

# 创建一个从start开始，以step为步长的无限迭代器
for i in itertools.count(1, 2):
    if i > 10:
        break
    print(i)
# output:
# 1
# 3
# 5
# 7
# 9

• cycle(iterable)

import itertools

# 对一个可迭代对象进行无限循环
count = 0
for i in itertools.cycle('ABC'):
    if count > 5:
        break
    print(i)
    count += 1
#output:
# A
# B
# C
# A
# B
# C

• repeat(object[, times])

import itertools

# 重复object指定的times次（如果不指定times，则无限重复）
for i in itertools.repeat('Hello', 3):
    print(i)
# output:
# Hello
# Hello
# Hello

• product(*iterables, repeat=1)

import itertools

# 不指定repeat,计算多个可迭代对象的笛卡尔积
# 指定repeat，则计算可迭代对象自身的笛卡尔积repeat次
list4 = [1, 2]
list5 = ['a', 'b']
for i in itertools.product(list4, list5):
    print(i)
# output:
# (1, 'a')
# (1, 'b')
# (2, 'a')

# 指定repeat，则计算可迭代对象自身的笛卡尔积repeat次
list6 = [1, 2]
for i in itertools.product(list6, repeat=3):
    print(i)
# output:
# (2, 'b')
# (1, 1, 1)
# (1, 1, 2)
# (1, 2, 1)
# (1, 2, 2)
# (2, 1, 1)
# (2, 1, 2)
# (2, 2, 1)
# (2, 2, 2)

• chain(*iterables)

import itertools

# 将多个可迭代对象连接成一个单一的迭代器
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for i in itertools.chain(list1, list2):
    print(i)
# output:
# 1
# 2
# 3
# a
# b
# c

• permutations(iterable, r=None)

import itertools

# 返回可迭代对象中元素的所有排列
# 如果r指定长度，则返回指定长度的排列
list = [1, 2, 3]
for i in itertools.permutations(list):
    print(i)
# output:
# (1, 2, 3)
# (1, 3, 2)
# (2, 1, 3)
# (2, 3, 1)
# (3, 1, 2)
# (3, 2, 1)

for i in itertools.permutations(list, 2):
    print(i)
# output:
# (1, 2)
# (1, 3)
# (2, 1)
# (2, 3)
# (3, 1)
# (3, 2)

• accumulate(iterable,func=None)

import itertools

numbers = [1, 2, 3, 4]
accumulated_sum = itertools.accumulate(numbers)
print(list(accumulated_sum))  # output:[1, 3, 6, 10]
result = itertools.accumulate(numbers, lambda x, y: x * y)
print(list(result))  # output:[1, 2, 6, 24]

functools模块常用方法

• functools.partial(func,*args,**keywords)

它的主要作用是基于一个现有的函数创建一个新的部分应用（partial application）函数。 当某个函数有多个参数，且在很多情况下部分参数的值是固定的，就可以使用functools.partial来创建一个更简单的函数。 func：这是要进行部分应用的原始函数。例如，可以是自定义的函数，也可以是 Python 内置函数。 *args：这是要预先填充（固定）的位置参数。这些参数会按照顺序填充到原始函数func的参数列表中。 **keywords：这是要预先填充（固定）的关键字参数。这些参数会以关键字参数的形式传递给原始函数func

from functools import partial


def add(x, y):
    return x + y


add_five = partial(add, 5)
result = add_five(3)
print(result)  # output:8

lambda表达式

# 对简单函数的简单写法,x是参数，x+1是返回值
add_one = lambda x:x + 1
result = add_one(2)
print(result)

sort()和sorted()

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
# sort()是列表专用，对原列表进行排序
my_list.sort(key=None, reverse=False)
print(my_list)  # output:[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
names = ["Smith, John", "Doe, Jane", "Johnson, Adam"]
names.sort(key=lambda item: item.split(", ")[1])
print(names)
numbers = [-3, 1, -5, 2]
numbers.sort(key=lambda x: abs(x))
print(numbers)
students = [{"name": "Alice", "grade": 85},
            {"name": "Bob", "grade": 90},
            {"name": "Charlie", "grade": 80}]
students.sort(key=lambda student: student["grade"])
print(students)
'''
output:[{'name': 'Charlie', 'grade': 80}, {'name': 
'Alice', 'grade': 85}, {'name': 'Bob', 'grade': 90}]
'''
my_tuple = (3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
# 接受可迭代对象（如列表、元组、字符串等），返回一个新的已排序列表
new_list = sorted(my_tuple, key=None, reverse=False)
print(my_tuple)  # output:(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
print(new_list)  # output:[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

无需导包，直接用的方法

print(abs(-10))  # output:10
print(pow(2, 3))  # output:8
print(pow(2, 3, 5))  # 2**3%5=3 output:8
print(divmod(10, 3))  # 10/3=3···1 output:(3,1)
print(*range(10, 0, -1))  # output:10 9 8 7 6 5 4 3 2 1
print(round(2.3456, 1))  # output:2.3
print(round(2.3456, 2))  # output:2.35
print(round(2.3456, 3))  # output:2.346
print(max(1, 2, 3))  # output:3
print(min(1, 2, 3))  # output:1
print(complex(3, 4))  # output:(3+4j)
print(sum([1, 2, 3, 4]))  # output:10
# 执行字符串中的代码
print(eval("5 * 10"))  # output:50
print(len([1, 2, 3]))  # output:3
# zip()将多个可迭代对象中对应的元素打包成一个个元组，
# 然后返回由这些元组组成的一个可迭代对象
# 返回值是迭代器对象
print(list(zip([1, 2, 3], ['a', 'b', 'c'])))  # output:[(1, 'a'), (2, 'b'), (3, 'c')]
print(*list(zip([1, 2, 3], ['a', 'b', 'c'])))  # output:(1, 'a') (2, 'b') (3, 'c')
# 将一个可迭代对象组合为一个索引序列，同时列出数据和数据下标。
# 这个函数返回的是一个枚举对象，该对象是一个可以迭代的类型。
# 基本语法为enumerate(iterable, start = 0)，start指定索引的起始值，默认为0
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)
# output:
# 1 apple
# 2 banana
# 3 cherry
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
for index, (element1, element2) in enumerate(zip(list1, list2)):
    print(index, element1, element2)
# output:
# 0 1 a
# 1 2 b
# 2 3 c
# reversed(iterable)返回一个反向的迭代器对象
print(list(reversed([1, 2, 3])))  # output:[3, 2, 1]

栈的实现

stack.append(3)
print(stack)
top_element = stack.pop()
print(top_element)
print(stack)
top_element = stack[-1]
print(top_element)
print(stack)
if len(stack) == 0:
    print("栈为空")
else:
    print("栈不为空")
from collections import deque

队列的实现

class Queue:
    def __init__(self):
        self.queue = []
    def enqueue(self, item):
        self.queue.append(item)
    def dequeue(self):
        if self.is_empty():
            raise IndexError("队列为空")
        return self.queue.pop(0)
    def is_empty(self):
        return len(self.queue) == 0
q = Queue()
q.enqueue(4)
q.enqueue(5)
print(q.dequeue())  # output:4
print(q.is_empty())  # output:False

双端队列的实现

class MyDeque:
    def __init__(self):
        self.items = []

    def append(self, item):
        # 在右端添加元素
        self.items.append(item)

    def appendleft(self, item):
        # 在左端添加元素
        self.items.insert(0, item)

    def pop(self):
        # 从右端删除元素
        if len(self.items) == 0:
            raise IndexError("双端队列为空，无法删除元素")
        return self.items.pop()

    def popleft(self):
        # 从左端删除元素
        if len(self.items) == 0:
            raise IndexError("双端队列为空，无法删除元素")
        return self.items.pop(0)

    def __len__(self):
        # 返回双端队列的长度
        return len(self.items)
my_custom_deque = MyDeque()
my_custom_deque.append(1)
my_custom_deque.appendleft(0)
print("从右端删除的元素:", my_custom_deque.pop())
print("从左端删除的元素:", my_custom_deque.popleft())
print("双端队列的长度:", len(my_custom_deque))

二叉树的实现

# 定义二叉树节点类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# 定义二叉树类
class BinaryTree:
    def __init__(self):
        self.root = None

    # 插入节点方法
    def insert(self, val):
        if self.root is None:
            self.root = TreeNode(val)
        else:
            self._insert(val, self.root)

    def _insert(self, val, node):
        if val < node.val:
            if node.left is None:
                node.left = TreeNode(val)
            else:
                self._insert(val, node.left)
        else:
            if node.right is None:
                node.right = TreeNode(val)
            else:
                self._insert(val, node.right)

    # 中序遍历方法
    def inorder_traversal(self):
        result = []
        self._inorder_traversal(self.root, result)
        return result

    def _inorder_traversal(self, node, result):
        if node:
            self._inorder_traversal(node.left, result)
            result.append(node.val)
            self._inorder_traversal(node.right, result)

    # 前序遍历方法
    def preorder_traversal(self):
        result = []
        self._preorder_traversal(self.root, result)
        return result

    def _preorder_traversal(self, node, result):
        if node:
            result.append(node.val)
            self._preorder_traversal(node.left, result)
            self._preorder_traversal(node.right, result)

    # 后序遍历方法
    def postorder_traversal(self):
        result = []
        self._postorder_traversal(self.root, result)
        return result

    def _postorder_traversal(self, node, result):
        if node:
            self._postorder_traversal(node.left, result)
            self._postorder_traversal(node.right, result)
            result.append(node.val)


# 创建二叉树对象
tree = BinaryTree()

# 插入节点
tree.insert(5)
tree.insert(3)
tree.insert(7)
tree.insert(2)
tree.insert(4)
tree.insert(6)
tree.insert(8)

# 各种遍历输出
print("中序遍历:", tree.inorder_traversal())
print("前序遍历:", tree.preorder_traversal())
print("后序遍历:", tree.postorder_traversal())