装饰器在 import 时就跑完了,生成器却一行都还没执行

装饰器是接收函数、返回替代品的可调用对象,@ 只是把 f = deco(f) 提到定义处执行;生成器是含 yield 的函数被调用后得到的对象,函数体要等第一次迭代才推进。两者看似无关,却共同改写了“这段代码什么时候执行”,也共同制造了面试里最常见的时序误判:把装饰器当成每次调用都重跑,把生成器当成可以反复遍历的列表。本文用定义、调用、迭代三个时间轴拆开机制,讲清闭包捕获、functools.wraps、帧的挂起与恢复、StopIteration 与单次消费的边界,并给出流式管道与热点路径上的取舍。

是什么

装饰器是一个“接收函数、返回替代品”的可调用对象。@deco 只是语法糖:解释器执行完 def f() 之后,立刻做一次 f = deco(f),名字 f 从此可能指向一个完全不同的对象。生成器则是含 yield 的函数被调用后得到的对象,它把函数体、局部变量和“下一条要执行的指令”一起封在帧里,等到被迭代才继续。

一句直觉:装饰器把包装提前到定义那一刻,生成器把执行推迟到迭代那一刻,两者改的都是“什么时候跑”,而不是“跑什么”。典型场景里,前者负责路由注册、鉴权、重试、计时与缓存,后者负责逐行读日志、分页拉数据、组装流式管道和表达无限序列。

核心原理

先分清三个时刻。 定义时(模块被 import、函数语句执行)、调用时(写上 ())、迭代时(next() 或 for 推进)。装饰器工作在定义时,生成器工作在迭代时,而两者最容易被混为一谈的地方,恰恰是“调用时”。

装饰器只在定义时执行一次。 下面这段代码把三个时刻的打印分开,运行顺序会比只看语法时的直觉更清楚:

import functools

def traced(fn):
    print("1 装饰器本体:", fn.__name__)   # 定义时执行一次
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print("3 调用时:", fn.__name__)   # 每次调用都执行
        return fn(*args, **kwargs)
    return wrapper

@traced
def add(a, b):
    print("4 原函数体")
    return a + b

print("2 定义完成")
print(add(1, 2))

1 会排在 2 前面,3、4 要等最后一行才出现。wrapper 之所以在定义结束后仍能叫出 fn,靠的是闭包:fn 是 traced 调用时的局部变量,被内层函数引用后随单元格一起存活,所以即使 traced 早已返回,包装层依然握着原函数。

由此可以推出三个工程后果:装饰器闭包里建的缓存、连接、读到的配置,全在 import 阶段定型;带参数的 @retry(times=3) 是三层结构,先算 retry(3) 得到真正的装饰器,再拿它包函数;多个装饰器从下往上包裹、从上往下执行,@a 写在 @b 上方等价于 f = a(b(f)),请求先经过 a 再到 b。

生成器函数调用时不执行。 g = gen() 只构造对象,参数在这一刻已经求值并绑定,但函数体一行都没跑;第一次 next(g) 才从函数开头执行到第一个 yield,把值交出去并挂起整个帧。此后每次 next 都从上次停下的位置继续,局部变量原样保留。yield 还是表达式:send(v) 除了推进,还会把 v 作为 yield 的返回值送回去,所以生成器能同时“产出”和“接收”。

def running_total():
    total = 0
    while True:
        n = yield total          # 交出当前值,挂起等待
        if n is None:            # 哨兵:让生成器体面结束
            return
        total += n

g = running_total()
print(next(g))        # 0:执行到第一个 yield
print(g.send(3))      # 3:send 的值成为 yield 表达式的结果
print(g.send(4))      # 7
g.close()             # 在挂起点抛 GeneratorExit
print(g.gi_frame)     # None:帧已释放

close() 会在挂起点抛入 GeneratorExit,finally 因此有机会释放文件、锁或事务;但若在 finally 里再 yield,解释器会报 RuntimeError: generator ignored GeneratorExit。函数正常结束或 return 时抛 StopIteration,返回值挂在异常的 value 上,for 循环会把它吞掉,所以想拿返回值得手动 next 或交给 yield from。生成器内部意外抛出的 StopIteration 从 Python 3.7 起会被转成 RuntimeError,原因写在 PEP 479 里:否则内层迭代器耗尽时抛出的 StopIteration,会被外层循环误当成自己已经结束。

两者共用同一个函数对象模型。 装饰器拿到的是函数对象,返回的也是函数对象;生成器函数被调用后拿到的是迭代器。于是给生成器函数加装饰器时,包装层必须原样返回生成器,否则调用方拿到的就不是迭代器;用 lru_cache 直接缓存生成器函数更是典型事故——缓存里存的是那个只能走一遍的对象,第二次命中直接得到空迭代。

生成器表达式也有同样的时序细节:(x 2 for x in load()) 在创建时会立刻求值最外层的 load(),但循环体、条件过滤和 x 2 都要等迭代才发生;而且这个表达式对象同样只能消费一次。把“创建”和“求值”分开看,才能解释为什么某些生成器表达式写出来就触发了一次昂贵查询,另一些却一行都没跑。

常见考点与误区

  • “@ 在调用时生效”:错。装饰器本体在定义时执行一次,缓存、连接、配置读取都发生在 import 阶段;每次调用只重跑 wrapper。把可变状态放在装饰器闭包里,会被所有被装饰函数共享。
  • “生成器函数一调用就会跑”:错。g = gen() 不执行函数体,参数已绑定但第一行都没跑;首个 next 才推进到 yield。面试常让判断打印顺序,答错基本都栽在这里。
  • “生成器能反复遍历”:错。生成器是一次性迭代器,耗尽后永远抛 StopIteration,第二次 for 直接是空循环;它也没有 len() 和下标,itertools.tee 能分流但会替你缓存,内存照样涨。
  • “return 的值丢了是 bug”:不是。值在 StopIteration.value 里,for 按协议吞掉异常,所以看不见;要拿就用 yield from 或手动捕获。反过来,在生成器里把 StopIteration 往外抛,会被转成 RuntimeError。
  • “装饰器不写 wraps 也没关系”:有代价。__name__、__doc__、__module__ 会变成包装层的,日志、路由注册、文档生成和 inspect.signature 都可能读错;functools.wraps 还会写入 __wrapped__,让自省工具顺着找到原函数。
  • “生成器天然线程安全”:错。同一个生成器被两个线程同时 next,后到的会收到 ValueError: generator already executing;它也不是调度器,不会让同步代码自动并发。
  • “给生成器套缓存能提速”:错。lru_cache 缓存的是生成器对象而非元素序列,第一次遍历完,后续命中全是空的;要缓存就返回 tuple 或 list。

实践建议

  • 装饰器只做进入/退出的薄层:计时、日志、鉴权、重试。重活放到参数或独立函数里;一律加 functools.wraps,带参数的装饰器老老实实写三层,异步函数则用 async def wrapper 并 await 原函数。
  • 热点路径数一数包装层数。每层装饰器都会多一次 Python 调用和一次栈帧,几十微秒级的函数套三层,开销可能超过函数本身;用基准测过再决定是否合并。
  • 生成器优先用于“流式、分批、管道”:读大文件按行处理、分页游标、多个 yield from 串成处理链,内存只与单批大小相关。生成器里用 with 或 try/finally 管资源,并在消费端尽早 close(),不要指望垃圾回收替你释放。
  • 需要多次遍历、随机访问或求长度时,直接物化成 list 并估算内存;不要为了“看起来省内存”把已经确定要全量加载的数据塞进生成器,来回转换反而更慢。
  • 想用 send 做双向通信,先 next(g) 预热到第一个 yield,再发送非 None 值,并约定清晰的结束哨兵;逻辑一复杂就改用显式类或 asyncio,可读性比炫技重要。

一句话总结:装饰器改写的是定义时的名字绑定,生成器改写的是迭代时的执行进度,把三个时刻分清,大半坑就没了。

相关阅读

← 返回文章志