w wyl123ly 的博客
MD

Python-07-进阶特性

40 KB 2026.10.11 原文件

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 为什么存在

  1. 简化内存管理:引用计数不是原子的。没有 GIL,obj.refcount += 1 这类操作需要细粒度锁,开销与死锁风险暴涨。
  2. 简化 C 扩展:大量 C 库假定「拿到的对象不会被其他线程同时修改」。
  3. 单线程性能更好:细粒度锁的成本远高于 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 s1.01 s(几乎无加速)2.69 s(本机受进程启动开销拖累)不适用
IO 密集(实测 sleep(0.3) × 8)2.40 s0.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()。


十三、练习题

  1. 基础题:实现一个迭代器类 Fibonacci(n),产出前 个斐波那契数;再用生成器函数实现同样功能,比较两者代码行数。

提示:用递推式 ,时间 、空间 。

  1. 基础题:写一个装饰器 @validate_positive,当被装饰函数的任意位置参数小于等于 0 时抛出 ValueError,且必须保留原函数的 __name__ 与 __doc__(用 assert 验证)。
  1. 进阶题:写一个带参数的装饰器 @timeout(seconds=1),用 threading.Timer 或信号机制在超时后抛出 TimeoutError,说明为什么这类装饰器在 Windows 上不能依赖 signal.alarm。
  1. 进阶题:给定一个 10 GB 的日志文件路径,用生成器写一个 tail_lines(path, n) 只返回最后 行,要求额外内存为 而不是 ,并解释你的实现策略。
  1. 思考题:你的服务需要同时处理 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 上实测通过;性能对比数字来自单机单次测量,仅用于说明趋势,请在本机复测。