Python-07-进阶特性
这篇讲什么
基础语法能让你写出能跑的 Python,而这一篇讲的是让代码好用、好读、好维护、跑得快的机制:
迭代器与生成器(惰性求值)、装饰器(不改原函数就增强行为)、类型注解(让静态工具帮你找 bug)、GIL 与并发模型(决定你该用线程、进程还是协程)、内存管理与性能优化。
这些概念互相咬合:生成器是迭代器协议的语法糖,
asyncio建立在生成器思想上,装饰器依赖闭包。读完这篇,你应该能自己手写一个生成器和装饰器,而不是只会调用别人写好的。
一、是什么:从「能跑」到「好用」的六个机制
| 机制 | 一句话定义 | 解决的问题 |
|---|---|---|
| 迭代器协议 | 让对象能被 for 遍历的统一接口 | 遍历方式千差万别,如何统一 |
| 生成器 | 用 yield 手写的惰性序列 | 序列太长或无法一次算完 |
| 装饰器 | 接收函数、返回新函数的可调用对象 | 横向功能(日志/计时/权限)侵入业务代码 |
| 类型注解 | 写在代码里的类型声明,运行时不强制 | 动态类型的大项目重构困难 |
| GIL | 同一进程同一时刻只有一个线程执行字节码 | 内存管理与执行安全的取舍 |
| 垃圾回收 | 引用计数 + 分代标记清除 | 自动释放不再使用的内存 |
一个贯穿全篇的观点
这六个机制都在做同一件事:把「重复的、可以自动化的东西」从业务代码里剥离出来。
遍历逻辑剥到迭代器,求值时机剥到生成器,横切逻辑剥到装饰器,类型约定剥到注解,并行策略剥到并发模型,内存回收剥到 GC。
二、为什么需要它们
先看一段「没有生成器」的代码,感受一下问题:
# 需求:处理一个 1000 万行的日志文件,找出所有 ERROR 行
def read_all_errors(path: str) -> list[str]:
lines = open(path, encoding="utf-8").readlines() # 一次性把整个文件读进内存
return [line for line in lines if "ERROR" in line]
# 问题:10 GB 的文件直接撑爆内存,而调用方往往只关心前几行
再看「没有装饰器」的代码:
# 需求:给 5 个函数都加计时。没有装饰器时只能复制粘贴
import time
def fetch_user(uid):
start = time.perf_counter()
result = {"id": uid}
print(f"fetch_user 耗时 {time.perf_counter() - start:.3f}s")
return result
def fetch_order(oid):
start = time.perf_counter() # 复制粘贴第 1 次
result = {"id": oid}
print(f"fetch_order 耗时 {time.perf_counter() - start:.3f}s")
return result
结论:这两类重复(求值时机的重复、横切逻辑的重复)用普通函数无法消除,必须引入新的抽象机制。这就是迭代器、生成器与装饰器存在的理由。
用空间复杂度可以精确描述这个差别。设序列长度为 、单个元素占用 字节:
前者与数据规模成正比,后者与数据规模无关——这正是流式处理大文件、大结果集的理论依据。
三、核心内容概览
| 对比项 | 可迭代对象 Iterable | 迭代器 Iterator |
|---|---|---|
| 必须实现 | __iter__ | __iter__ 与 __next__ |
iter(x) 的结果 | 返回一个迭代器 | 返回自身(return self) |
能否被 for 遍历 | 能 | 能 |
| 能否被遍历两次 | 可以(每次 iter() 产生新迭代器) | 不能,耗尽后永远 StopIteration |
| 典型例子 | list、dict、str、文件对象 | list_iterator、生成器、map 对象 |
| 是否记录遍历状态 | 不记录 | 记录(游标位置) |
一句话区分
可迭代对象是「数据」,迭代器是「游标」。
list是可迭代对象,iter(my_list)才是迭代器。判断一个对象是不是迭代器,看它是否同时有
__iter__和__next__;只看有没有__iter__只能判断它可迭代。
四、迭代器协议与 for 循环的真面目
4.1 手写一个迭代器
class CountDown:
"""从 start 倒数到 1 的迭代器。
为什么 __iter__ 要返回 self:迭代器自身就携带遍历状态(self.current),
如果再返回一个新对象,状态就丢了,for 循环也就无从「接着上次继续」。
"""
def __init__(self, start: int) -> None:
self.current = start
def __iter__(self):
return self # 迭代器必须返回自身,否则 for 循环拿不到状态
def __next__(self) -> int:
if self.current <= 0:
# 用异常而不是返回 None 表示「结束」:
# 因为 None 可能是序列中的合法元素,异常才能无歧义地表达终止
raise StopIteration
value = self.current
self.current -= 1
return value
print(list(CountDown(3))) # [3, 2, 1]
print(sum(CountDown(4))) # 10,任何接受可迭代对象的函数都能用
4.2 for 循环的展开过程
for x in obj: 在 CPython 中等价于下面这段代码——这是理解迭代器的关键:
it = iter(CountDown(3)) # 第一步:调用 obj.__iter__() 拿到迭代器
while True:
try:
x = next(it) # 第二步:反复调用 it.__next__()
except StopIteration: # 第三步:捕获 StopIteration 才退出循环
break
print(x)
为什么用异常表示结束
返回值方案需要一个「保留值」当哨兵,而 Python 不允许保留任何值(
None也可能是数据)。异常是唯一的无歧义方案。代价是每次循环结束都抛一次异常,但 CPython 内部对
FOR_ITER字节码做了优化,正常迭代路径并不昂贵。
4.3 耗尽与两个易错现象
data = [1, 2, 3]
it = iter(data)
print(list(it)) # [1, 2, 3]
print(list(it)) # [] ← 迭代器是一次的,已经耗尽
# 因此,需要多次遍历时必须使用可迭代对象,而不是迭代器
gen = (x for x in data)
print(list(gen), list(gen)) # [1, 2, 3] []
print(list(data), list(data)) # [1, 2, 3] [1, 2, 3] ← 列表可以反复遍历
五、生成器:从零手写并理解暂停恢复
5.1 生成器函数与 yield 的执行流程
def count_down_gen(start: int):
"""与 CountDown 类功能完全等价,但代码短得多,也不用自己维护状态。"""
while start > 0:
yield start # 产出一个值并「冻结」在此处,下次 next() 从下一行继续
start -= 1
# 函数自然结束 → 生成器自动抛出 StopIteration
g = count_down_gen(3)
print(next(g), next(g), next(g)) # 3 2 1
try:
next(g)
except StopIteration as e:
print("迭代结束,return 值 =", e.value) # None(没有显式 return)
yield到底做了什么1.
yield x先求值x,把它作为next()的返回值交给调用方;2. 然后挂起当前栈帧并保存局部变量(不是销毁,也不是复制);
3. 下次
next()时从挂起点的下一行恢复。所以生成器本质是「自带暂停按钮的函数」,它天然记住
start的当前值——你不再需要像CountDown那样手动把状态写成属性。
用摊还分析描述这个优势:设生成器总共产出 个元素、创建与销毁的开销为常数 ,则
总时间仍是 ,但任意一次 next() 只花 ——调用方可以随时停止,未产出的部分永不计算。
手工复现生成器的关键点,就是理解它替你做掉了三件事:维护状态字段、实现 __iter__ 返回自身、在结尾抛 StopIteration。
5.2 send:把值传回生成器
yield 是表达式而不是语句,它有返回值,send() 送出的值就成了 yield 的结果:
def accumulator():
"""累加器:外部每 send 一个数字,就返回当前累计值。"""
total = 0
while True:
received = yield total # 注意:yield 的返回值就是 send 进来的值
if received is None: # 用 None 作为「收工」信号,避免无限循环
break
total += received
return total # 挂在 StopIteration.value 上
acc = accumulator()
next(acc) # 0:必须先用 next() 把生成器「推进到第一个 yield」,否则 send 会报错
print(acc.send(10)) # 10
print(acc.send(5)) # 15
acc.close() # 通知生成器释放资源,内部会触发 GeneratorExit
启动陷阱
刚创建的生成器停在函数开头,还没走到任何
yield,此时send(非 None 值)会抛
TypeError: can't send non-None value to a just-started generator。必须先
next(gen)(或gen.send(None))启动它,这一步俗称「预热」。
5.3 yield from:委托给子生成器
def chain(*iterables):
"""把多个可迭代对象串成一个序列。"""
for it in iterables:
yield from it # 等价于 for x in it: yield x,但还额外转发 send/throw/return
# yield from 比手写循环多做的事:把 send 的值转发给子生成器、
# 把子生成器的 return 值作为整个 yield from 表达式的值、
# 把异常透传进去。手写循环无法覆盖这些语义。
print(list(chain([1, 2], (3, 4), "56"))) # [1, 2, 3, 4, '5', '6']
def sub_gen():
received = yield 1
yield f"子生成器收到: {received}"
def delegating():
result = yield from sub_gen() # result 拿到 sub_gen 的 return 值(此处为 None)
yield f"子生成器返回值: {result}"
d = delegating()
print(next(d)) # 1 ← 由 sub_gen 产出
print(d.send("hello")) # 子生成器收到: hello ← send 被转发进 sub_gen
print(next(d)) # 子生成器返回值: None
5.4 惰性求值的内存优势(实测)
import sys
N = 1_000_000
list_way = [i * i for i in range(N)] # 立刻构造全部 100 万个整数
gen_way = (i * i for i in range(N)) # 只创建一个生成器对象
print(sys.getsizeof(list_way)) # 8448728 字节 ≈ 8.06 MB
print(sys.getsizeof(gen_way)) # 200 字节
print(f"{sys.getsizeof(list_way) / sys.getsizeof(gen_way):.0f}x") # 42244x
怎么选
- 数据要被多次遍历、随机索引、求长度 → 用列表。
- 数据只被顺序处理一遍、数据量大或来源是流 → 用生成器。
- 生成器表达式把
[]换成()就行,是成本最低的内存优化之一。- 注意:
sys.getsizeof只统计容器对象自身的开销,列表里每个int对象另有 28 字节,实际差距比 8 MB 还大。
六、装饰器:函数是一等对象 → 闭包 → 装饰器
6.1 铺垫:函数是一等对象
def add(a, b):
return a + b
alias = add # 函数可以赋给变量
print(alias(1, 2)) # 3
print(add.__name__, add.__doc__) # 函数有属性,可以被检查
def apply(func, x, y):
return func(x, y) # 函数可以作为参数传入
print(apply(add, 3, 4)) # 7
6.2 铺垫:闭包
def make_multiplier(n):
"""返回一个「记住了 n」的函数。"""
def mul(x):
return x * n # n 不是 mul 的局部变量,而是来自外层作用域
return mul # 外层已返回,但 n 依然被 mul 持有 → 这就是闭包
triple = make_multiplier(3)
print(triple(5)) # 15
print(triple.__closure__[0].cell_contents) # 3
print(triple.__code__.co_freevars) # ('n',)
闭包为什么是装饰器的前提
装饰器需要「记住」被装饰的原函数和被传入的参数,然后在将来调用它们。
能跨越外层函数返回而存活的作用域,只有闭包。
6.3 手写一个最简单的装饰器
import functools
import time
def timer(func):
"""装饰器:打印被装饰函数的执行耗时。"""
@functools.wraps(func) # 见 6.5 节,先照抄,理由在后面
def wrapper(*args, **kwargs): # *args/**kwargs 保证能装饰任意签名的函数
start = time.perf_counter()
result = func(*args, **kwargs) # 真正的业务逻辑在这里执行
elapsed = time.perf_counter() - start
print(f"[timer] {func.__name__} 耗时 {elapsed * 1000:.3f} ms")
return result # 必须把返回值透传出去,否则调用方拿到 None
return wrapper
@timer
def slow_sum(n):
return sum(range(n))
print(slow_sum(100_000)) # [timer] slow_sum 耗时 0.8xx ms → 4999950000
@timer 只是语法糖,完全等价于:
def slow_sum(n):
return sum(range(n))
slow_sum = timer(slow_sum) # 名字被重新绑定到 wrapper 上
6.4 带参数的装饰器:多包一层
def retry(times: int = 3, delay: float = 0.1, exceptions=(Exception,)):
"""带参数的装饰器工厂:失败时最多重试 times 次。
为什么要三层嵌套:装饰器本身要接收 (@retry(times=5) 先于函数求值) 参数,
所以最外层拿参数,中间层拿函数,最内层拿调用参数。
"""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
last_error = None
for attempt in range(1, times + 1):
try:
return func(*args, **kwargs)
except exceptions as exc: # 只重试指定异常,避免吞掉真正的 bug
last_error = exc
print(f"[retry] 第 {attempt} 次失败: {exc!r}")
if attempt < times:
time.sleep(delay) # 生产环境应换成指数退避
raise last_error # 重试耗尽,把最后一次异常抛出去
return wrapper
return decorator
calls = {"n": 0}
@retry(times=5, delay=0.01, exceptions=(ValueError,))
def flaky():
calls["n"] += 1
if calls["n"] < 3:
raise ValueError(f"第 {calls['n']} 次调用模拟失败")
return "成功"
print(flaky()) # 打印两次失败后输出 成功
6.5 functools.wraps 为什么必要
不用 wraps 时,被装饰函数的元数据会被 wrapper 覆盖,实测结果如下:
import functools
import inspect
def plain(func):
def wrapper(*a, **k):
return func(*a, **k)
return wrapper
def good(func):
@functools.wraps(func) # 把 __name__/__doc__/__module__/__qualname__/__dict__
def wrapper(*a, **k): # 复制到 wrapper 上,并设置 __wrapped__ 指向原函数
return func(*a, **k)
return wrapper
@plain
def f1(x):
"""f1 的文档字符串"""
return x
@good
def f2(x):
"""f2 的文档字符串"""
return x
print(f1.__name__, repr(f1.__doc__), inspect.signature(f1))
# wrapper None (*a, **k) ← 函数名变成了 wrapper,文档丢失,签名成了 (*a, **k)
print(f2.__name__, repr(f2.__doc__), inspect.signature(f2))
# f2 'f2 的文档字符串' (x) ← 元数据与签名都保住了
print(hasattr(f2, "__wrapped__")) # True
不写
functools.wraps的真实后果1.
help()、Sphinx 文档、docstring 测试全部错乱;2. Flask/FastAPI 等框架按
__name__注册路由,同名端点会互相覆盖;3.
inspect.signature失效,参数校验、依赖注入、IDE 补全拿不到真实签名。结论:手写装饰器时
@functools.wraps(func)是必写项,不是可选项。
6.6 类装饰器与装饰类的区别
装饰类(用一个函数改类,注册/补充方法时很有用):
def add_repr(cls):
"""为类自动生成 __repr__,免去每个数据类手写。"""
def __repr__(self):
attrs = ", ".join(f"{k}={v!r}" for k, v in vars(self).items())
return f"{type(self).__name__}({attrs})"
cls.__repr__ = __repr__
return cls # 注意:装饰类时返回的仍是类,调用方感受不到差别
@add_repr
class Point:
def __init__(self, x, y):
self.x, self.y = x, y
print(Point(1, 2)) # Point(x=1, y=2)
用类写装饰器(需要保存状态时比闭包直观):
class CountCalls:
"""统计函数被调用了多少次;用实例属性保存状态,比闭包变量更好读写。"""
def __init__(self, func):
functools.update_wrapper(self, func) # 类版本同样要处理元数据
self.func = func
self.count = 0
def __call__(self, *args, **kwargs):
self.count += 1
return self.func(*args, **kwargs)
@CountCalls
def ping():
return "pong"
ping(); ping()
print(ping.count) # 2
6.7 实际应用四连
import functools
import logging
import time
# ① 缓存:functools.lru_cache 就是标准库给的装饰器,用它可以秒算斐波那契
@functools.lru_cache(maxsize=None) # 记忆化:相同参数直接命中缓存,不重复计算
def fib(n: int) -> int:
return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(60)) # 1548008755920,没有缓存时这个调用几乎跑不完
print(fib.cache_info()) # CacheInfo(hits=58, misses=61, ...)
# ② 日志:记录调用参数,排查线上问题非常有效
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
def log_call(func):
logger = logging.getLogger(func.__module__) # 用被装饰模块的 logger,日志级别可独立配置
@functools.wraps(func)
def wrapper(*args, **kwargs):
logger.info("调用 %s(args=%r, kwargs=%r)", func.__name__, args, kwargs)
return func(*args, **kwargs)
return wrapper
@log_call
def add(a, b):
return a + b
print(add(1, 2)) # INFO 调用 add(args=(1, 2), kwargs={}) → 3
# ③ 权限校验:把「谁能调用」与「做什么」解耦
CURRENT_ROLES = {"editor"}
def require_role(role: str):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if role not in CURRENT_ROLES:
raise PermissionError(f"需要角色 {role!r}")
return func(*args, **kwargs)
return wrapper
return decorator
@require_role("admin")
def delete_user(user_id: int) -> str:
return f"已删除 {user_id}"
try:
delete_user(1)
except PermissionError as exc:
print("被拦截:", exc) # 被拦截: 需要角色 'admin'
装饰器栈的执行顺序
```python
@tag("A")
@tag("B")
def target(): ...
```
等价于
target = tag("A")(tag("B")(target)),离函数最近的最先包装,因此运行时是「A 先进后出」:
enter-A → enter-B → body → exit-B → exit-A(实测顺序)。这决定了日志、计时、事务等装饰器的嵌套顺序会直接影响输出含义。
七、类型注解
7.1 基本写法
from typing import Callable, Optional
def greet(name: str, times: int = 1) -> str:
return (f"你好,{name}!" * times).strip()
print(greet("世界", 2)) # 你好,世界!你好,世界!
print(greet.__annotations__) # {'name': <class 'str'>, 'times': <class 'int'>, 'return': <class 'str'>}
print(greet(123)) # 照样运行,输出 你好,123!——注解在运行时不被强制
注解不影响运行时
函数注解只是被存进
__annotations__字典,解释器不检查、不转换、不报错。变量注解
count: int = 0连__annotations__的写入时机都只是「执行到该行时」。所以「加了注解就安全了」是错觉——必须有 mypy 之类的静态检查器参与,注解才有约束力。
7.2 typing 常用类型
from typing import Callable, Optional, Protocol, TypeVar, Union
# Optional[X] 是 Union[X, None] 的简写:表示「可能是 X,也可能是 None」
def find_user(user_id: int) -> Optional[dict]:
return {"id": user_id} if user_id > 0 else None
# Callable[[参数类型...], 返回类型]:描述「函数作为参数」
def apply_all(func: Callable[[int], int], data: list[int]) -> list[int]:
return [func(x) for x in data]
print(apply_all(lambda x: x * 2, [1, 2, 3])) # [2, 4, 6]
# Protocol:结构化子类型(鸭子类型的静态版本)。
# 只要对象有 __len__ 就满足 Sized,不需要显式继承 —— 这是 Python 特有的灵活之处
class Sized(Protocol):
def __len__(self) -> int: ...
def is_empty(container: Sized) -> bool:
return len(container) == 0
print(is_empty([]), is_empty([1])) # True False
7.3 泛型 TypeVar
from typing import TypeVar
T = TypeVar("T") # 类型变量:表示「任意类型」,但调用一次内必须保持一致
def first(items: list[T]) -> T:
"""返回第一个元素。有了 TypeVar,first([1,2]) 被推断为 int 而不是 Any。"""
return items[0]
print(first([1, 2, 3]), first(["a"])) # 1 a
| 注解写法 | 含义 | 注意 | |
|---|---|---|---|
list[int] | 元素为 int 的列表 | Python 3.9+ 可用;更早版本写 List[int] | |
Optional[int] | int 或 None | 等价 `int \ | None`(3.10+) |
Union[int, str] | int 或 str | 同上,3.10+ 可用 `int \ | str` |
Callable[[int], str] | 接收 int、返回 str 的函数 | 参数列表写方括号内 | |
Protocol | 结构化类型 | 无需继承即可满足,适合描述第三方对象 | |
TypeVar("T") | 泛型占位符 | 同一次调用中类型必须一致 |
List与list的取舍
typing.List是 3.9 之前的写法,现在list[int]已原生支持。新代码直接用内置泛型;若库需要兼容 3.8,则保留
typing.List。以官方最新文档为准。
7.4 mypy 的作用与局限
pip install mypy
mypy your_module.py # 静态检查,不执行代码
mypy --strict your_module.py # 更严格:不允许隐式 Any
| 方面 | 说明 |
|---|---|
| 能查出 | 参数类型不符、返回值类型不符、Optional 未判空就取属性、拼错的属性名、未定义的变量 |
| 查不出 | 运行期才成立的业务约束、动态 getattr/setattr 的字段、类型注解写错但自洽的情况 |
| 局限根源 | 它只在语法与类型层面推理,不执行代码,因此无法验证真实数据形状 |
渐进式引入
别一上来就
--strict全库扫描。建议先给新代码加注解,用--disallow-untyped-defs局部收紧,老代码通过
# type: ignore或mypy配置里的ignore_missing_imports逐步过渡。
八、GIL(Global Interpreter Lock)
8.1 是什么
GIL 是 CPython 解释器里的一把互斥锁:任何时刻,一个进程内只有一个线程能执行 Python 字节码。
不是 Python 语言的规定,而是 CPython 实现的选择(PyPy 有 GIL,Jython/IronPython 没有)。
8.2 为什么存在
- 简化内存管理:引用计数不是原子的。没有 GIL,
obj.refcount += 1这类操作需要细粒度锁,开销与死锁风险暴涨。 - 简化 C 扩展:大量 C 库假定「拿到的对象不会被其他线程同时修改」。
- 单线程性能更好:细粒度锁的成本远高于 GIL 的粗粒度切换,单线程场景下 GIL 反而更快。
8.3 对不同任务的影响(实测对比)
import asyncio
import multiprocessing
import threading
import time
def cpu_bound(n: int) -> int:
"""纯计算任务:几乎不释放 GIL,因此线程之间只能轮流执行。"""
return sum(i * i for i in range(n))
def io_bound(delay: float) -> str:
time.sleep(delay) # 阻塞 IO 会主动释放 GIL,别的线程可以趁机跑
return "ok"
| 任务类型 | 单线程 | 多线程 | 多进程 | 协程 asyncio |
|---|---|---|---|---|
| CPU 密集(实测 8×10⁶×2 次求和) | 1.05 s | 1.01 s(几乎无加速) | 2.69 s(本机受进程启动开销拖累) | 不适用 |
IO 密集(实测 sleep(0.3) × 8) | 2.40 s | 0.30 s(约 8× 加速) | 可用但更重 | 0.31 s(约 8× 加速) |
别把上表的绝对秒数当成普适结论
数字来自一台 32 核机器上的单次测量,结论只取「趋势」:
- CPU 密集:多线程≈单线程(GIL 使其串行),多进程在任务足够大时才能摊薄启动成本;
- IO 密集:多线程与协程都能把等待时间重叠起来,获得接近线性的加速。
进程方案在 Windows 上因
spawn需要重新导入模块,启动开销明显;任务越重,这个开销占比越小。请在你自己的机器上用同样的脚本测一遍再下结论。
8.4 绕过 GIL 的四条路
| 方式 | 原理 | 适用 | 代价 |
|---|---|---|---|
multiprocessing | 独立进程、独立解释器 | 真正的 CPU 并行 | 进程启动与序列化开销、共享状态需要 IPC |
asyncio | 单线程事件循环,协作式切换 | 高并发 IO(网络、爬虫、网关) | 需要全链路异步库,一个阻塞调用就打乱全局 |
| C 扩展 / 原生库 | numpy、torch 等在计算时释放 GIL | 数值计算 | 依赖第三方,需理解其线程语义 |
| 换实现 / 无 GIL 构建 | 如 free-threaded(PEP 703,3.13 起实验性支持) | 尝鲜与特定负载 | 生态兼容性尚未完全跟上,以官方最新文档为准 |
九、并发模型对比与 asyncio 基本用法
| 维度 | 多线程 threading | 多进程 multiprocessing | 协程 asyncio |
|---|---|---|---|
| 并发单位 | 线程(OS 调度) | 进程(OS 调度) | 协程(事件循环调度) |
| 内存空间 | 共享 | 隔离 | 共享 |
| 切换开销 | 中等(受 GIL 约束) | 大 | 极小 |
| 受 GIL 限制 | 是 | 否 | 是(但单线程,不冲突) |
| CPU 密集加速 | 无 | 有 | 无 |
| IO 密集加速 | 有 | 有(但过重) | 有 |
| 数据共享 | 直接共享,需加锁 | 需 Queue/Pipe/共享内存 | 直接共享,用 await 天然避免竞态 |
| 调试难度 | 中(竞态难复现) | 高(跨进程栈) | 中(需理解事件循环) |
| 典型场景 | 阻塞库的 IO 并发、后台任务 | 图像处理、批量计算、数据管道 | 网络服务、爬虫、网关 |
import asyncio
import time
async def fetch(name: str, delay: float) -> str:
"""async def 定义协程函数;await 处会让出控制权,让事件循环去跑别的协程。"""
await asyncio.sleep(delay) # 用 asyncio.sleep 而不是 time.sleep:
return f"{name} 完成" # time.sleep 会阻塞整个事件循环,并发立刻退化为串行
async def main():
start = time.perf_counter()
# gather 并发调度多个协程,总耗时约等于最慢的那个(0.1s),而不是 5×0.1s
results = await asyncio.gather(*(fetch(f"任务{i}", 0.1) for i in range(5)))
print(f"总耗时 {time.perf_counter() - start:.3f}s", results)
if __name__ == "__main__":
asyncio.run(main()) # 入口:创建事件循环、运行 main、关闭循环
协程最常见的坑
在
async def里调用任何阻塞函数(time.sleep、requests.get、同步数据库驱动)都会卡死整个事件循环,所有并发任务一起停顿。要么换成异步库(
aiohttp、httpx、asyncpg),要么用await asyncio.to_thread(阻塞函数)扔到线程池。
十、内存管理与垃圾回收
10.1 引用计数:主力机制
CPython 给每个对象维护一个引用计数,计数归零立即释放——这是确定性的,也是 CPython 与 Java 最大的差异。
import sys
x = [1, 2, 3]
print(sys.getrefcount(x) - 1) # 1;减 1 是因为 getrefcount 自身的临时引用也被计入了
y = x # 计数变 2
print(sys.getrefcount(x) - 1) # 2
del y # 计数回到 1
print(sys.getrefcount(x) - 1) # 1
10.2 循环引用:引用计数解决不了
import gc
a = []
b = [a] # b 引用 a
a.append(b) # a 引用 b → 形成环,两者计数都不为 0
del a, b # 外部引用消失,但环内计数仍为 1,引用计数无法回收
print("gc.collect() 回收对象数:", gc.collect()) # 实测 2
print("分代回收阈值:", gc.get_threshold()) # (700, 10, 10)
10.3 分代回收:处理环的补充机制
CPython 的循环垃圾回收器把对象分成三代,越年轻越频繁检查(因为大多数对象死得早,这是弱代假设):
| 代 | 含义 | 触发条件 |
|---|---|---|
| 第 0 代 | 新创建的对象 | 分配数 − 释放数 > 700(阈值可调) |
| 第 1 代 | 熬过一轮 0 代回收 | 0 代回收发生 10 次 |
| 第 2 代 | 长期存活对象 | 1 代回收发生 10 次 |
import gc
import weakref
class Node:
__slots__ = ("name", "__weakref__") # 有 __slots__ 时想用弱引用必须显式声明 __weakref__
def __init__(self, name: str) -> None:
self.name = name
parent = Node("parent")
ref = weakref.ref(parent) # 弱引用:不增加引用计数,因此不会阻止对象被回收
del parent
print(ref()) # None,对象已被回收
print(gc.isenabled()) # True;gc.disable() 可关闭,但循环垃圾将无法自动回收
减少 GC 压力的三种手段
1. 用
__slots__减少每个实例的字典开销,实例多时内存与遍历成本都明显下降;2. 用
weakref打破「父 ↔ 子」双向强引用环(缓存、观察者列表尤其常见);3. 长驻服务里,必要时手工
gc.freeze()把启动期对象移出回收范围,减少 GC 停顿(较新版本 API,以官方最新文档为准)。
十一、性能优化的思路:先测量,再优化
优化的铁律
不要凭直觉猜瓶颈。 程序员对热点的直觉几乎总是错的,而且可读性的代价是立刻支付的,性能收益却常常为零。
顺序永远是:测量 → 定位 → 优化最热的一处 → 再测量。
11.1 用 cProfile 定位热点
import cProfile
import io
import pstats
def work():
return sum(i * i for i in range(100_000))
pr = cProfile.Profile()
pr.enable()
work()
pr.disable()
stream = io.StringIO()
pstats.Stats(pr, stream=stream).sort_stats("cumulative").print_stats(5)
print(stream.getvalue())
# 关键看两列:tottime(函数自身耗时,找真正的热点)
# cumtime(含子调用耗时,找耗时链路)
| 工具 | 用途 | 特点 |
|---|---|---|
time.perf_counter() | 粗粒度计时 | 零依赖,精度足够,适合先确认「慢不慢」 |
cProfile + pstats | 函数级剖析 | 标准库自带,开销可接受,能看到调用次数 |
timeit | 微基准测试 | 自动重复取最优,适合比较两种写法 |
tracemalloc | 内存分配追踪 | 定位「哪一行分配了最多内存」 |
line_profiler / py-spy | 行级 / 采样剖析 | 需第三方,适合线上采样,以官方最新文档为准 |
11.2 选对数据结构(收益最大的一步)
import time
needle = 99_999
lst = list(range(200_000))
st = set(lst)
d = {v: v for v in lst}
for name, container in (("list", lst), ("set", st), ("dict", d)):
start = time.perf_counter()
for _ in range(1000):
_ = needle in container
print(f"{name:5s} 1000 次查找 {time.perf_counter() - start:.4f}s")
| 需求 | 应选 | 复杂度 | 反例 |
|---|---|---|---|
| 按下标随机访问 | list | 用 dict 当数组 | |
| 判重 / 成员判断 | set | 平均 | 用 list 做 in() |
| 键值映射 | dict | 平均 | 用两个平行列表手工对齐 |
| 频繁头尾插入删除 | collections.deque | 用 list.insert(0, x)() | |
| 计数 | collections.Counter | 平均 | 手写 dict.get(k, 0) + 1 |
其他高性价比手段
- 把循环内的属性查找提到循环外:
append = result.append(局部变量查找比属性查找快);- 用内置函数与 C 实现的库(
sum、map、numpy)替代纯 Python 循环;- 字符串拼接用
"".join(parts)而不是+=累加;- 真正的瓶颈在 IO 时,优化 CPU 代码毫无意义——先确认瓶颈类型。
十二、注意事项与常见坑
坑 1:把迭代器当可迭代对象反复遍历
```python
gen = (x for x in range(3))
print(list(gen), list(gen)) # [0, 1, 2] []
```
生成器/迭代器只能消费一次。需要多次使用就转成
list,或改成返回可迭代对象的函数(每次调用重新生成)。
坑 2:
send前忘记预热不先
next(gen)就gen.send(1),会抛TypeError: can't send non-None value to a just-started generator。
坑 3:生成器里的
return值被忽略
return x在生成器里不产出值,只挂在StopIteration.value上;普通for循环拿不到它,必须用yield from或手工捕获。
坑 4:装饰器忘了
return result
wrapper不返回原函数结果,调用方全部拿到None,而且不报错——这是最隐蔽的一类 bug。
坑 5:可变默认参数 + 闭包延迟绑定
```python
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs]) # [2, 2, 2],不是 [0, 1, 2]
# 修法:把 i 绑定为默认参数
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs]) # [0, 1, 2]
```
坑 6:以为注解会做运行时校验
def f(x: int)传入字符串照样运行。要运行时校验得靠pydantic、typeguard等第三方库,或手工assert。
坑 7:在异步函数里调用阻塞 API
一个
time.sleep(1)会让事件循环停摆 1 秒,所有协程一起等。用await asyncio.sleep()或asyncio.to_thread()。
坑 8:用多线程做 CPU 密集计算
不仅没有加速,还会因为线程切换与锁竞争略微变慢。CPU 密集请用
multiprocessing或原生数值库。
坑 9:
gc.disable()的后果关闭自动 GC 可以消除 GC 停顿,但循环引用的对象将永不回收,长驻进程会持续泄漏内存。
若确有需要,务必配合定期手工
gc.collect()。
十三、练习题
- 基础题:实现一个迭代器类
Fibonacci(n),产出前 个斐波那契数;再用生成器函数实现同样功能,比较两者代码行数。
提示:用递推式 ,时间 、空间 。
- 基础题:写一个装饰器
@validate_positive,当被装饰函数的任意位置参数小于等于 0 时抛出ValueError,且必须保留原函数的__name__与__doc__(用assert验证)。
- 进阶题:写一个带参数的装饰器
@timeout(seconds=1),用threading.Timer或信号机制在超时后抛出TimeoutError,说明为什么这类装饰器在 Windows 上不能依赖signal.alarm。
- 进阶题:给定一个 10 GB 的日志文件路径,用生成器写一个
tail_lines(path, n)只返回最后 行,要求额外内存为 而不是 ,并解释你的实现策略。
- 思考题:你的服务需要同时处理 1000 个 HTTP 请求,每个请求耗时 50 ms(其中 45 ms 在等数据库)。写出你会选择的并发模型,并从 GIL、内存开销、代码复杂度三个角度说明取舍。若数据库驱动只有同步版本,方案要怎么改?
十四、常见问题(FAQ)
Q1:生成器和迭代器是一回事吗?
A:不是。生成器是创建迭代器的语法糖——调用生成器函数得到的是一个生成器对象,它自动实现了 __iter__ 与 __next__,因此也是迭代器。反过来不成立:CountDown 那样的手写迭代器不是生成器。生成器表达式 (x for x in ...) 同样返回生成器(准确说是 generator 类型)。
Q2:为什么 functools.lru_cache 要求参数可哈希?
A:缓存以参数元组为字典的键,而字典键必须可哈希。传入 list 或 dict 会抛 TypeError: unhashable type。解法是改用元组/字符串,或自定义 __hash__。此外 lru_cache 会持有所有参数与返回值的强引用,缓存大对象时可能反而造成内存增长,此时应设置 maxsize。
Q3:有了 GIL,还需要给共享数据加锁吗?
A:需要。GIL 只保证单条字节码的原子性,counter += 1 实际由「读—加—写」多条字节码组成,线程可能在中间被切换,导致丢失更新。用 threading.Lock、queue.Queue,或改用 multiprocessing/asyncio 规避。
Q4:既然有 GIL,为什么 numpy 还能多线程加速?
A:numpy 的重计算部分由 C/Fortran 完成,这些循环在执行时会主动释放 GIL,因此多个线程可以真正并行。这也是「绕过 GIL」中最省事的一条路。
相关笔记
- Python-04-面向对象:魔术方法(
__iter__、__next__、__call__)与类的行为定制,是理解迭代器协议与类装饰器的基础 - Python-06-常用标准库:
functools、itertools、collections中现成的装饰器与迭代工具 - 操作系统:线程与进程的调度、上下文切换开销,理解 GIL 与并发模型的系统级背景
- 算法-复杂度分析:评估「换数据结构」带来的复杂度收益
参考来源
- Python 官方文档 · 数据模型(迭代器协议、魔术方法):https://docs.python.org/zh-cn/3/reference/datamodel.html
- Python 官方文档 ·
typing类型提示支持:https://docs.python.org/zh-cn/3/library/typing.html - Python 官方文档 ·
functools(wraps、lru_cache):https://docs.python.org/zh-cn/3/library/functools.html - Python 官方文档 ·
asyncio任务与协程:https://docs.python.org/zh-cn/3/library/asyncio-task.html - Python 官方文档 · 垃圾回收器
gc:https://docs.python.org/zh-cn/3/library/gc.html - Python 官方文档 ·
cProfile与pstats:https://docs.python.org/zh-cn/3/library/profile.html - PEP 255 · Simple Generators:https://peps.python.org/pep-0255/
- PEP 342 · Coroutines via Enhanced Generators:https://peps.python.org/pep-0342/
- PEP 380 · Syntax for Delegating to a Subgenerator:https://peps.python.org/pep-0380/
- PEP 484 · Type Hints:https://peps.python.org/pep-0484/
- PEP 703 · Making the Global Interpreter Lock Optional in CPython:https://peps.python.org/pep-0703/
- Real Python · Primer on Python Decorators:https://realpython.com/primer-on-python-decorators/
- Real Python · Introduction to Python Generators:https://realpython.com/introduction-to-python-generators/
版本敏感性说明
本文涉及解释器版本相关的内容(内置泛型写法
list[int]、X | None联合类型写法、free-threaded 构建的成熟度、gc.freeze等 API、asyncio细节)以官方最新文档为准。本文代码在 CPython 3.12 上实测通过;性能对比数字来自单机单次测量,仅用于说明趋势,请在本机复测。