1298 字

3 分钟

python竞赛常用模块总结

2026-01-31

笔记

python

/

竞赛

统计加载中...

python竞赛常用模块总结#

一.快速读取输入#

使用sys模块，读取效率较高，推荐使用。

简单快读模板#

重新定义input函数，使读取效率加快。

1
import sys
2
input = lambda: sys.stdin.readline().strip()

快速读取一行`sys.stdin.readline()`#

1
import sys
2

3
# 读取一行，包含末尾的\n
4
line = sys.stdin.readline()
5

6
# 去掉首尾换行符
7
line = sys.stdin.readline().strip()
8

9
# 读取整数
10
n = int(sys.stdin.readline())
11

12
# 读取多个整数
13
a, b = map(int, sys.stdin.readline().split())

快速读取所有输入`sys.stdin.read()`#

1
import sys
2

3
# 读取所有输入，返回一个字符串
4
all_input = sys.stdin.read()
5

6
# 常用模式：按空白字符分割
7
data = sys.stdin.read().split()
8

9
# 转换为整数列表
10
numbers = list(map(int, sys.stdin.read().split()))

二.常用数学函数#

内置数学函数#

基本数学运算#

函数	名称	说明	示例
`abs(x)`	绝对值函数	返回x的绝对值	`abs(-5) → 5`
`pow(x, y[, z])`	快速幂	`pow(x, y)`返回 $x^y$ `pow(x, y, z)`返回 $x^y \bmod z$	`pow(2, 3) → 8`, `pow(2, 3, 5) → 3`
`round(x,n)`	四舍五入	`round(x)`保留整数 `round(x, n)`保留`n`位小数	`round(3.14) → 3` `round(3.14159, 2) → 3.14`
`divmod(x, y)`	整除函数	返回`(x//y, x%y)`	`divmod(7, 2) → (3, 1)`

进制转换#

函数	名称	说明	示例
`bin(x)`	二进制转换	返回整数x的二进制表示	`bin(10) → '0b1010'`
`oct(x)`	八进制转换	返回整数x的八进制表示	`oct(10) → '0o12'`
`hex(x)`	十六进制转换	返回整数x的十六进制表示	`hex(10) → '0xa'`

math模块#

导入math模块

1
import math

基本数学运算#

函数/常量	名称	说明	示例
`sqrt(x)`	平方根	返回x的平方根	`sqrt(4) → 2.0`
`ceil(x)`	向上取整	返回大于等于x的最小整数	`ceil(3.14) → 4`
`floor(x)`	向下取整	返回小于等于x的最大整数	`floor(3.99) → 3`

数论函数#

函数	名称	说明	示例
`gcd(a, b)`	最大公约数	返回a和b的最大公约数	`gcd(12, 18) → 6`
`lcm(a, b)`	最小公倍数	返回a和b的最小公倍数	`lcm(4, 6) → 12`
`comb(n, k)`	组合数	返回 $C_n^k$	`comb(5, 2) → 10`
`perm(n, k)`	排列数	返回 $P_n^k$	`perm(5, 2) → 20`
`factorial(n)`	阶乘	返回 $n!$	`factorial(5) → 120`

数学常量#

常量	名称	说明	示例
`pi`	圆周率	数学常量π	`pi → 3.14159...`
`e`	自然对数底	数学常量e	`e → 2.71828...`
`inf`	无穷大	正无穷大	`inf → inf`
`nan`	非数字	非数字值	`nan → nan`

其他函数#

函数	名称	说明	示例
`isqrt(x)`	整数平方根	返回x的整数平方根	`isqrt(16) → 4`
`dist(p, q)`	距离	返回两点之间的欧几里得距离	`dist((0,0), (3,4)) → 5.0`

三.is判断函数#

判断字符串是否满足某种条件，返回True或False。

字符串判断方法（str对象方法）#

字符类型判断#

方法	名称	说明	示例
`isalnum()`	字母数字判断	字符串是否由字母和数字组成	`"abc123".isalnum() → True`
`isalpha()`	字母判断	字符串是否只由字母组成	`"abc".isalpha() → True`
`isdecimal()`	十进制数字	字符串是否只包含十进制数字	`"123".isdecimal() → True`
`isdigit()`	数字判断	字符串是否只包含数字	`"123".isdigit() → True`

格式与大小写判断#

方法	名称	说明	示例
`islower()`	小写判断	字符串是否至少有一个字母且所有字母都是小写	`"abc".islower() → True`
`isupper()`	大写判断	字符串是否至少有一个字母且所有字母都是大写	`"ABC".isupper() → True`
`istitle()`	标题判断	字符串是否每个单词首字母大写	`"Hello World".istitle() → True`

常用数据结构模块#

导入collections模块

1
from collections import deque, Counter

常用数据结构：

类/函数	名称	说明	示例
`deque`	双端队列	线程安全，快速从两端添加或删除元素	`deque([1,2,3])`
`Counter`	计数器	统计可哈希对象	`Counter('abcabc')`

deque 双端队列#

方法	说明	示例
`deque()`	初始化	创建一个新的双端队列
`append(x)`	右端添加x	`d.append(4)`
`appendleft(x)`	左端添加x	`d.appendleft(0)`
`pop()`	右端弹出	`d.pop() → 4`
`popleft()`	左端弹出	`d.popleft() → 0`
`extend(iterable)`	右端扩展	`d.extend([5,6])`
`extendleft(iterable)`	左端扩展	`d.extendleft([-1,-2])`
`rotate(n)`	旋转n步	`d.rotate(1)`
`clear()`	清空队列	`d.clear()`

Counter 计数器#

方法	说明	示例
`Counter()`	初始化	创建一个新的计数器，可以像字典一样使用
`most_common(n)`	前n个最常见元素	`Counter('abracadabra').most_common(3)` → `[('a', 5), ('b', 2), ('r', 2)]`
`total()`	计数总和	`Counter('abc').total() → 3`

堆操作#

导入heapq模块

1
import heapq

堆默认为最小堆，即堆顶为最小元素。

函数	名称	说明	示例
`heapify(x)`	堆化	将列表x转换为堆	`heapify([3,1,2])` → 堆为[1,3,2]
`heappush(heap, item)`	入堆	将item加入堆	`heappush(heap, 4)`
`heappop(heap)`	出堆	弹出并返回堆顶元素	`heappop(heap)` → 1
`heappushpop(heap, item)`	先入后出	将item入堆然后弹出堆顶	`heappushpop(heap, 0)` → 0
`heapreplace(heap, item)`	先出后入	弹出堆顶然后将item入堆	`heapreplace(heap, 5)` → 1
`nlargest(n, iterable)`	前n个最大	返回iterable中前n个最大元素	`nlargest(3, [1,5,2,4,3])` → [5,4,3]
`nsmallest(n, iterable)`	前n个最小	返回iterable中前n个最小元素	`nsmallest(3, [1,5,2,4,3])` → [1,2,3]

二分查找#

导入bisect模块

1
import bisect

这些函数用于在已排序的列表中进行二分查找。

函数	名称	说明	示例
`bisect_left(a, x)`	左插入点	返回第一个大于等于x的索引	`bisect_left([1,2,4], 2)` → 1
`bisect(a, x)`	右插入点	返回第一个大于x的索引	`bisect([1,2,4], 2)` → 2
`insort_left(a, x)`	左插入	找到第一个大于等于x的索引，将x插入该位置	`insort_left([1,2,4], 2)` → [1,2,2,4]
`insort(a, x)`	右插入	找到第一个大于x的索引，将x插入该位置	`insort([1,2,4], 2)` → [1,2,2,4]

迭代与序列#

所有函数概览表

函数	名称	说明	时间复杂度	示例
`len()`	获取长度	返回对象长度（元素个数）	O(1)	`len([1,2,3]) → 3`
`reversed()`	反转序列	返回序列的反向迭代器	O(1)	`list(reversed([1,2,3])) → [3,2,1]`
`sorted()`	排序	返回排序后的新列表	O(n log n)	`sorted([3,1,2]) → [1,2,3]`
`enumerate()`	枚举	返回(索引, 元素)对的迭代器	O(1)	`list(enumerate(['a','b'])) → [(0,'a'),(1,'b')]`
`zip()`	组合	将多个可迭代对象组合成元组迭代器	O(1)	`list(zip([1,2],['a','b'])) → [(1,'a'),(2,'b')]`
`slice()`	创建切片对象	创建切片对象用于扩展切片	O(1)	`arr[slice(1,3)]`
`filter()`	过滤	过滤可迭代对象，保留满足条件的元素	O(n)	`list(filter(lambda x: x>0, [-1,0,1,2])) → [1,2]`
`map()`	映射	对可迭代对象的每个元素应用函数	O(n)	`list(map(str, [1,2,3])) → ['1','2','3']`
`all()`	所有为真	所有元素都为真时返回True	O(n)	`all([True, True]) → True`
`any()`	任一为真	任一元素为真时返回True	O(n)	`any([False, True]) → True`

reversed()-反转序列#

1
# 反转列表（返回迭代器）
2
list(reversed([1, 2, 3])) # [3, 2, 1]
3

4
# 反转字符串
5
list(reversed("abc")) # ['c', 'b', 'a']
6

7
# 反转范围对象
8
list(reversed(range(5))) # [4, 3, 2, 1, 0]
9

10
# 与切片反转对比
11
arr = [1, 2, 3]
12
arr[::-1] # [3, 2, 1]（返回新列表）
13
reversed(arr) # <list_reverseiterator>（返回迭代器）
14

15
# 遍历反向迭代器
16
for item in reversed([1, 2, 3]):
17
    print(item)                     # 3, 2, 1

特点

返回迭代器，节省内存
原始序列不会被修改

enumerate()-枚举索引#

1
# 基本用法
2
list(enumerate(['a', 'b', 'c']))  # [(0, 'a'), (1, 'b'), (2, 'c')]
3

4
# 指定起始索引
5
list(enumerate(['a', 'b', 'c'], start=1))  # [(1, 'a'), (2, 'b'), (3, 'c')]

zip()-组合多个可迭代对象#

1
# 组合两个列表
2
list(zip([1, 2, 3], ['a', 'b', 'c']))  # [(1, 'a'), (2, 'b'), (3, 'c')]
3

4
# 长度不等时以最短的为准
5
list(zip([1, 2, 3], ['a', 'b']))       # [(1, 'a'), (2, 'b')]
6

7
# 组合三个列表
8
list(zip([1, 2], ['a', 'b'], ['x', 'y']))  # [(1, 'a', 'x'), (2, 'b', 'y')]
9

10
# 解压（使用*操作符）
11
pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
12
nums, letters = zip(*pairs)            # nums=(1,2,3), letters=('a','b','c')
13

14
# 矩阵转置
15
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
16
transposed = list(zip(*matrix))        # [(1,4,7), (2,5,8), (3,6,9)]
17

18
# 遍历组合
19
names = ['Alice', 'Bob', 'Charlie']
20
scores = [85, 92, 78]
21
for name, score in zip(names, scores):
22
    print(f"{name}: {score}")  # Alice: 85, Bob: 92, Charlie: 78

slice()-创建切片对象#

1
# 创建切片对象
2
s = slice(1, 4) # 等价于 [1:4]
3
arr = [0, 1, 2, 3, 4, 5]
4
arr[s] # [1, 2, 3]
5

6
# 带步长的切片
7
s = slice(0, 5, 2) # 等价于 [0:5:2]
8
arr[s] # [0, 2, 4]
9

10
# 省略开始或结束
11
s = slice(None, 3) # [:3]
12
arr[s] # [0, 1, 2]
13

14
# 动态创建切片
15
def get_slice(arr, start=None, stop=None, step=None):
16
    s = slice(start, stop, step)
17
    return arr[s]
18

19
get_slice([0,1,2,3,4], 1, 4) # [1, 2, 3]
20

21
# 获取切片属性
22
s = slice(1, 5, 2)
23
s.start # 1
24
s.stop # 5
25
s.step # 2

filter()-过滤序列#

1
# 过滤偶数
2
nums = [1, 2, 3, 4, 5, 6]
3
even = list(filter(lambda x: x % 2 == 0, nums))  # [2, 4, 6]
4

5
# 过滤非空字符串
6
words = ['hello', '', 'world', '', '!']
7
non_empty = list(filter(None, words))            # ['hello', 'world', '!']
8
# 注意：filter(None, iterable)会过滤掉bool值为False的元素
9

10
# 过滤正数
11
list(filter(lambda x: x > 0, [-2, -1, 0, 1, 2]))  # [1, 2]
12

13
# 使用函数作为过滤条件
14
def is_vowel(char):
15
    return char.lower() in 'aeiou'
16
list(filter(is_vowel, 'hello world')) # ['e', 'o', 'o']
17

18
# 惰性求值（返回迭代器）
19
filtered = filter(lambda x: x > 0, [-1, 0, 1, 2])
20
next(filtered) # 1

map()-映射函数#

1
# 转换为字符串
2
list(map(str, [1, 2, 3]))                # ['1', '2', '3']
3

4
# 平方运算
5
list(map(lambda x: x**2, [1, 2, 3, 4]))  # [1, 4, 9, 16]
6

7
# 多个序列运算
8
list(map(lambda x, y: x + y, [1, 2, 3], [10, 20, 30]))  # [11, 22, 33]
9

10
# 内置函数作为映射函数
11
list(map(abs, [-1, 2, -3, 4]))           # [1, 2, 3, 4]
12

13
# 多参数函数
14
def add(a, b, c):
15
    return a + b + c
16

17
list(map(add, [1, 2, 3], [10, 20, 30], [100, 200, 300]))  # [111, 222, 333]

all()和any()-逻辑判断#

1
# all(): 所有元素为True时返回True
2
all([True, True, True])           # True
3
all([True, False, True])          # False
4
all([])                           # True（空序列）
5

6
# any(): 任一元素为True时返回True
7
any([False, False, True])         # True
8
any([False, False, False])        # False
9
any([])                           # False（空序列）
10

11
# 实际应用
12
# 检查所有数字是否为正数
13
all(x > 0 for x in [1, 2, 3, 4])   # True
14
all(x > 0 for x in [1, 2, -3, 4])  # False
15

16
# 检查是否有正数
17
any(x > 0 for x in [-1, -2, 3])    # True
18

19
# 检查所有字符串是否非空
20
strings = ['hello', 'world', '']
21
all(strings) # False（空字符串为False）
22
any(strings) # True
23

24
# 结合map使用
25
all(map(str.isalpha, 'abc123')) # False（有数字）
26
all(map(str.isalpha, 'abc')) # True

python竞赛常用模块总结

https://fairycrane.website/posts/py_mod/

作者

仙鹤

发布于

2026-01-31

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

大一上数学公式整理

有你在的今天

python竞赛常用模块总结#

一.快速读取输入#

简单快读模板#

快速读取一行sys.stdin.readline()#

快速读取所有输入sys.stdin.read()#

二.常用数学函数#

内置数学函数#

基本数学运算#

进制转换#

math模块#

基本数学运算#

数论函数#

数学常量#

其他函数#

三.is判断函数#

字符串判断方法（str对象方法）#

字符类型判断#

格式与大小写判断#

常用数据结构模块#

deque 双端队列#

Counter 计数器#

堆操作#

二分查找#

迭代与序列#

reversed()-反转序列#

enumerate()-枚举索引#

zip()-组合多个可迭代对象#

slice()-创建切片对象#

filter()-过滤序列#

map()-映射函数#

all()和any()-逻辑判断#

快速读取一行`sys.stdin.readline()`#

快速读取所有输入`sys.stdin.read()`#