python3 leetcode 刷题常用api

python3 leetcode 刷题常用api

1. 基础类型与操作

# 整数、浮点数
x = int('10')          # 字符串转整数，可指定base=int('ff',16)
y = float('3.14')      # 字符串转浮点数
divmod(a, b)           # 返回 (a//b, a%b)
pow(a, b, mod)         # 快速幂取模 a^b % mod
abs(x)                 # 绝对值
round(x, ndigits)      # 四舍五入
max(iterable, key=func)
min(iterable, key=func)
sum(iterable, start=0)

# 布尔值
all(iterable)          # 全真返回True
any(iterable)          # 任一真返回True

# 字符与ASCII
ord('A')               # 65
chr(65)                # 'A'

2. 列表（list）完整API

# 创建
lst = []                       
lst = [0]*n                    
lst = list(range(10))          
lst = [expr for x in iterable] # 列表推导
lst = [expr for x in iterable if cond]

# 元素操作
lst.append(x)          # 末尾加
lst.extend(iterable)   # 扩展，等价 +=
lst.insert(i, x)       # 在索引i前插入
lst.pop()              # 移除并返回末尾
lst.pop(i)             # 移除并返回索引i处
lst.remove(x)          # 删除第一个值为x的元素
lst.clear()            # 清空
del lst[i]             # 删除索引i
del lst[i:j]           # 删除切片

# 查找与计数
lst.index(x, start, end)   # 返回第一个匹配索引，找不到抛异常
lst.count(x)               # 计数

# 排序与反转
lst.sort(key=None, reverse=False)   # 原地排序
sorted(lst, key, reverse)           # 返回新列表
lst.reverse()              # 原地反转
reversed(lst)              # 返回迭代器

# 复制
lst2 = lst.copy()          # 浅拷贝
lst2 = lst[:]              # 同样浅拷贝
import copy; copy.deepcopy(lst)  # 深拷贝

# 其他
len(lst)                   # 长度
any(lst) / all(lst)        # 元素真假判断
max(lst)/min(lst)          # 极值

3. 元组（tuple）与命名元组

t = (1,2,3)                # 不可变
t = 1,2,3                  # 同样
t = (1,)                   # 单元素元组
x, y = (1,2)               # 解包
from collections import namedtuple
Point = namedtuple('Point', ['x','y'])
p = Point(10,20)
p.x, p.y                   # 10,20

4. 字典（dict）完整API

d = {}                     
d = dict(a=1,b=2)          
d = {k:v for k,v in iterable}  # 字典推导

# 访问
d[key]                     # 键不存在时抛出KeyError
d.get(key, default)        # 安全获取
d.setdefault(key, default) # 若不存在则设置并返回
d.keys()                   # 返回视图
d.values()
d.items()                  # (key,value)对

# 添加/修改
d[key] = value
d.update(other_dict)       # 合并，覆盖相同键

# 删除
del d[key]
d.pop(key, default)        # 移除并返回值
d.popitem()                # 移除并返回最后一个键值对（Python3.7+ 为插入顺序）

# 其他
len(d)
key in d                   # 检查键是否存在
d.clear()
d.copy()                   # 浅拷贝
d = {**d1, **d2}           # 合并（Python3.5+）

5. 集合（set）完整API

s = set()                  
s = {1,2,3}                
s = set([1,2,3])           

# 元素操作
s.add(x)
s.remove(x)                # 不存在抛异常
s.discard(x)               # 不存在不抛异常
s.pop()                    # 移除并返回任意元素（集合无序）
s.clear()

# 集合运算
s1.union(s2)               # 并集 | 
s1.intersection(s2)        # 交集 &
s1.difference(s2)          # 差集 -
s1.symmetric_difference(s2)# 对称差 ^
s1.issubset(s2)            # <=
s1.issuperset(s2)          # >=
s1.isdisjoint(s2)          # 无交集返回True

len(s)
x in s

6. 字符串（str）全部常用方法

s = "hello"
# 大小写
s.upper() / s.lower() / s.swapcase() / s.capitalize() / s.title()
# 判断
s.isdigit() / s.isalpha() / s.isalnum() / s.islower() / s.isupper() / s.isspace()
# 查找
s.find(sub, start, end)    # 返回索引，找不到返回-1
s.rfind(sub)               # 从右找
s.index(sub)               # 类似find，找不到抛异常
s.count(sub)
# 条件判断
s.startswith(prefix) / s.endswith(suffix)
# 替换与分割
s.replace(old, new, count)
s.split(sep=None, maxsplit=-1)   # 返回列表
s.rsplit()                 # 从右分割
s.splitlines()             # 按换行分割
s.partition(sep)           # 返回 (head, sep, tail)
# 去除空白
s.strip(chars) / s.lstrip() / s.rstrip()
# 填充对齐
s.center(width, fillchar)
s.ljust(width), s.rjust(width)
s.zfill(width)             # 左边补0
# 拼接
sep.join(iterable)         # 将可迭代对象用sep连接成字符串
# 格式化
f"value = {x}"
"{} {}".format(a,b)
# 其他
len(s)
s[::-1]                    # 反转
s * n                      # 重复

7. 数学模块（math）和内置

import math
math.inf, math.nan
math.pi, math.e
math.ceil(x) / math.floor(x) / math.trunc(x)
math.sqrt(x)               # 平方根
math.pow(x,y)              # x**y
math.exp(x) / math.log(x)  # 自然对数
math.log10(x)
math.gcd(a,b) / math.lcm(a,b) (3.9+)
math.factorial(n)
math.comb(n,k) / math.perm(n,k)  # 组合/排列数
math.isclose(a,b,rel_tol,abs_tol)

# 内置数学
abs(x), pow(x,y,mod), round(x), divmod(a,b)

8. 迭代器与生成器

range(start, stop, step)   # 不可变序列，用于循环
enumerate(iterable, start=0)   # 产生 (index, value)
zip(*iterables)            # 并行聚合，最短长度截断
zip_longest(*iter, fillvalue=None) # itertools中

map(func, *iterables)      # 返回迭代器
filter(func, iterable)     # 返回满足func的迭代器
from functools import reduce
reduce(func, iterable, initial)  # 累积计算

# 生成器表达式
gen = (x**2 for x in range(10))

# 自定义生成器
def gen():
    yield value
    yield from iterable

9. 排序与顺序统计

sorted(iterable, key=None, reverse=False)
list.sort(key=None, reverse=False)    # 原地

# 第k大/小（部分排序）
import heapq
heapq.nlargest(k, iterable, key=None)
heapq.nsmallest(k, iterable, key=None)

# 内置极值
max(iterable, key=func)
min(iterable, key=func)

10. 堆（heapq）完整

import heapq
heap = []
heapq.heappush(heap, item)   # 推入
heapq.heappop(heap)          # 弹出最小
heapq.heappushpop(heap, item)# 推入然后弹出
heapq.heapreplace(heap, item)# 弹出然后推入
heapq.heapify(lst)           # 原地将列表转为最小堆
heap[0]                      # 查看最小元素不弹出
# 最大堆技巧：存负值
heapq.heappush(heap, -x)
max_val = -heapq.heappop(heap)

11. 双端队列（deque）

from collections import deque
dq = deque(iterable, maxlen)   # 可限制最大长度
dq.append(x)
dq.appendleft(x)
dq.pop()
dq.popleft()
dq.extend(iterable)
dq.extendleft(iterable)        # 逆序添加
dq.rotate(n)                   # 向右循环移动n步（n负则左移）
dq.remove(value)               # 删除第一个匹配项
dq.count(x)                    # 计数
dq.clear()
len(dq)

12. 计数器（Counter）

from collections import Counter
cnt = Counter(iterable)        # 统计频率
cnt = Counter({1:3, 2:5})      # 直接赋值
cnt.most_common(k)             # 返回频率最高的k个元素列表
cnt.total()                    # Python3.10+，总数
cnt.elements()                 # 按频率展开为迭代器
cnt.subtract(iterable)         # 减去计数
cnt += cnt2                    # 合并，只保留正计数
cnt -= cnt2                    # 差集，只保留正计数
cnt & cnt2                     # 交集（取较小计数）
cnt | cnt2                     # 并集（取较大计数）

13. 默认字典（defaultdict）

from collections import defaultdict
dd = defaultdict(int)          # 缺失键返回0
dd = defaultdict(list)         # 缺失键返回[]
dd = defaultdict(set)          # 缺失键返回set()
dd = defaultdict(lambda: "N/A")
dd[key]                        # 若缺失自动创建默认值

14. 有序字典（OrderedDict，Python3.7+普通dict已有序，但有些方法仍有用）

from collections import OrderedDict
od = OrderedDict()
od.move_to_end(key, last=True)   # 移动键到末尾（或开头）
od.popitem(last=True)            # 弹出最后（或最前）键值对

15. 链式映射（ChainMap）

from collections import ChainMap
cm = ChainMap(d1, d2, d3)      # 按顺序查找键
cm.maps                         # 列表形式的字典列表
cm.new_child(d)                 # 在前面添加新字典
cm.parents                      # 去除第一个字典后的ChainMap

16. 队列（queue，线程安全，刷题较少用，但提及）

from queue import Queue
q = Queue(maxsize=0)           # 0表示无限
q.put(item)
item = q.get()
q.empty(), q.full()

17. 栈（使用list模拟）

stack = []
stack.append(x)   # push
x = stack.pop()   # pop
top = stack[-1]   # peek

18. 位运算

&   # 按位与
|   # 按位或
^   # 按位异或
~   # 按位取反
<<  # 左移
>>  # 右移
n.bit_length()     # 返回二进制位数
int.bit_count()    # Python3.8+ 返回1的个数（popcount）
bin(n)             # 返回二进制字符串如'0b101'
format(n, 'b')     # 无'0b'的二进制串

19. itertools 模块（高频）

import itertools
# 无限迭代器
itertools.count(start=0, step=1)   # 生成无限序列
itertools.cycle(iterable)          # 无限循环
itertools.repeat(object, times)    # 重复生成

# 有限组合
itertools.product(*iterables, repeat=1)    # 笛卡尔积
itertools.permutations(iterable, r)        # 排列（有序）
itertools.combinations(iterable, r)        # 组合（无序）
itertools.combinations_with_replacement(iterable, r) # 可重复组合

# 拉链与填充
itertools.zip_longest(*iterables, fillvalue=None)

# 累积
itertools.accumulate(iterable, func=operator.add) # 前缀累加，可指定其他二元函数

# 链式
itertools.chain(*iterables)        # 将多个可迭代对象串联
itertools.chain.from_iterable(iterable_of_iterables)

# 分组（需有序）
itertools.groupby(iterable, key=None)   # 返回(key, group_iter)

# 切片
itertools.islice(iterable, start, stop, step)

# 笛卡尔积等

20. functools 模块

from functools import lru_cache, reduce, partial, cmp_to_key

@lru_cache(maxsize=None)   # 记忆化递归，自动缓存
def fib(n):
    return n if n<2 else fib(n-1)+fib(n-2)

reduce(func, iterable, initial)   # 累积计算，如reduce(lambda a,b:a+b, [1,2,3]) = 6

partial(func, *args, **kwargs)    # 偏函数：fix部分参数

# 用于旧式比较函数的转换（刷题较少用，但遇到需要自定义比较时可用）
def cmp(a, b): return a - b       # 负值表示a<b
sorted(lst, key=cmp_to_key(cmp))

21. 二分查找（bisect）

import bisect
arr = [1,2,3,3,5]
bisect.bisect_left(arr, x)     # 最左插入位置
bisect.bisect_right(arr, x)    # 最右插入位置（同bisect.bisect）
bisect.insort_left(arr, x)     # 插入并保持有序
bisect.insort_right(arr, x)    # 插入并保持有序（同bisect.insort）

22. 随机数（random）

import random
random.random()          # [0.0,1.0)浮点数
random.randint(a,b)      # [a,b]整数
random.choice(seq)       # 随机选取一个元素
random.choices(population, weights=None, k=1)  # 可重复选取k个
random.sample(population, k)   # 无放回选取k个不同元素
random.shuffle(lst)      # 原地打乱
random.seed(42)          # 固定随机种子

23. 输入输出（力扣中通常不需要，但有时调试）

import sys
data = sys.stdin.read().strip().split()   # 读取所有输入
for line in sys.stdin:
    # 处理每行
sys.stdout.write(str(x) + "\n")
print(*objects, sep=' ', end='\n', file=sys.stdout)
# 格式化输出
print(f"{value:.2f}")
print("{0:04d}".format(42))   # 输出0042

24. 系统相关

import sys
sys.setrecursionlimit(1000000)   # 提高递归深度限制，力扣通常需要
sys.getrecursionlimit()
sys.maxsize                       # 平台最大整数
sys.version

25. 高阶函数与lambda

lambda x, y: x+y
# 常用内置高阶函数
map(lambda x: x*2, [1,2,3])
filter(lambda x: x>0, [-1,2,-3])
sorted(lst, key=lambda x: x[1])
max(d.items(), key=lambda kv: kv[1])
min(lst, key=lambda x: abs(x))

26. 类型转换与进制

int(x, base=10)           # 从字符串/数字转换
float(x)
str(x)
list(iterable)
tuple(iterable)
set(iterable)
dict(iterable_of_pairs)
bin(x)                    # '0b101'
oct(x)
hex(x)
ord(ch) / chr(num)
bytes(string, encoding)
bytearray(iterable)

27. 字符串与列表互转

list("hello")    # ['h','e','l','l','o']
"".join(['a','b'])  # 'ab'
", ".join(["a","b"]) # 'a, b'
s.split() / s.split(',')

28. 异常处理（刷题少用，但可防御）

try:
    risky()
except ValueError as e:
    print(e)
except KeyError:
    pass
else:
    # 无异常时执行
finally:
    # 总是执行

29. 海象运算符（Python3.8+）

# 在表达式内赋值
if (n := len(lst)) > 10:
    print(f"List too long ({n})")

while (ch := input()) != 'quit':
    print(ch)

# 列表推导中使用
[(x, y) for x in range(5) if (y := x**2) > 5]

30. 解包（Unpacking）

a, b = 1, 2
a, *rest = [1,2,3,4]   # a=1, rest=[2,3,4]
*head, tail = [1,2,3,4] # head=[1,2,3], tail=4

# 函数调用
def f(a,b,c): pass
args = (1,2,3); f(*args)
kwargs = {'a':1,'b':2,'c':3}; f(**kwargs)

# 字典合并
d = {**d1, **d2}

31. 常用常量与特殊值

float('inf'), float('-inf')
math.inf, -math.inf
float('nan')
True, False, None
Ellipsis                  # ... 在切片中表示全选，如 a[..., 0]
__name__                  # 模块名

32. 正则表达式（re）偶尔用于字符串模式匹配

import re
re.match(pattern, string)      # 从开头匹配
re.search(pattern, string)     # 搜索任意位置
re.findall(pattern, string)    # 返回所有匹配字符串列表
re.finditer(pattern, string)   # 返回迭代器
re.sub(pattern, repl, string)  # 替换
re.split(pattern, string)      # 分割
# 常用模式
r'\d+'  # 数字
r'\w+'  # 字母数字下划线
r'[a-z]'

33. 日期时间（datetime，偶尔处理时间戳）

from datetime import datetime, timedelta
now = datetime.now()
dt = datetime(2025,1,1)
delta = timedelta(days=1)
dt + delta
dt.strftime("%Y-%m-%d")
datetime.strptime("2025-01-01", "%Y-%m-%d")

34. 内存视图与字节操作（位运算相关）

memoryview(bytes_object)
int.from_bytes(b'abc', 'big')   # 字节转整数
(12345).to_bytes(2, 'big')       # 整数转字节

35. 一些内置函数的补充

id(obj)                # 对象标识
hash(obj)              # 哈希值
isinstance(obj, type)
issubclass(cls, parent)
type(obj)
callable(obj)
globals(), locals()
eval("1+2")            # 动态执行表达式（刷题不推荐）
exec("print(3)")       # 执行语句

36. 常见技巧汇总

# 交换变量
a, b = b, a

# 反转序列
reversed_seq = seq[::-1]
reversed_list = list(reversed(seq))

# 同时遍历索引和值
for i, v in enumerate(lst, start=1):
    pass

# 两个列表成对遍历
for a,b in zip(lst1, lst2):
    pass

# 扁平化列表
flat = [item for sublist in nested for item in sublist]

# 判断回文
s == s[::-1]

# 计数频率（不用Counter）
freq = {}
for x in lst:
    freq[x] = freq.get(x, 0) + 1

# 矩阵转置
transposed = list(zip(*matrix))

# 列表分组（按大小）
def chunk(lst, size):
    for i in range(0, len(lst), size):
        yield lst[i:i+size]

# 快速幂
def pow_mod(a, b, mod):
    res = 1
    while b:
        if b & 1: res = res * a % mod
        a = a * a % mod
        b >>= 1
    return res

---