一个日志清洗脚本在测试环境跑了半年,数据量一直不大。上线第一周,进程被系统杀掉,监控显示内存从 200MB 一路涨到 4GB。代码大概是这样:

with open(path, encoding="utf-8") as f:
    lines = [line.strip() for line in f if "ERROR" in line]
    report = build_report(lines)

问题不在 open,而在方括号。列表推导会把每一行都装进内存,日志文件多大,列表就多大;文件 4GB,列表至少 4GB,还要加上每行一个字符串对象的额外开销。改成圆括号之后,内存立刻降下来:

with open(path, encoding="utf-8") as f:
    lines = (line.strip() for line in f if "ERROR" in line)
    report = build_report(lines)

差别只有一个符号,但行为完全不同。这篇就讲这类「看着像语法糖,其实是运行时机制」的东西:生成器、装饰器、上下文管理器,以及 Python 里那个常被误解的鸭子类型。目标不是背定义,而是知道每个特性在什么场景下省了什么、又付出了什么。

生成器:一个能暂停的函数

普通函数调用一次,从头执行到尾,返回一个值就结束。生成器函数里有 yield,调用它不会立刻执行函数体,而是返回一个生成器对象;每次向它要下一个值,它才从上次暂停的地方继续,yield 一次交出一个值,然后停在原地。

def countdown(n):
    while n > 0:
        yield n
        n -= 1

g = countdown(3)
print(next(g), next(g), next(g))

输出是 3 2 1。再调一次 next,函数体已经走完,抛出 StopIteration,这是 for 循环用来判断「没有更多值」的信号,不需要你自己捕获。生成器对象同时实现了迭代器协议:有 __next__,也能被 for 消费。

它省内存的原因很直接:任意时刻只有一个值活着,函数调用栈停在 yield 上,局部变量保留,但不需要把所有结果都存下来。我用 tracemalloc 对比过 range(10_000_000) 的生成器表达式和列表推导:生成器只占 384 字节,列表占到 409MB。这里的差距不是「优化一点」,是数量级。

列表推导

立刻计算全部结果,可以反复遍历、可以取下标、可以 len()。代价是内存和首次计算时间都按数据量线性增长。

生成器表达式

惰性计算,拿到一个值算一个,内存几乎恒定。只能遍历一次,也不能取下标。适合「读一遍就处理掉」的管道式任务。

生成器还有两个容易被忽略的能力:send 和 close。send(value) 把值送进生成器,作为当前 yield 表达式的返回值;close() 会在暂停处抛入 GeneratorExit,让生成器有机会清理资源。

def echo():
    received = []
    try:
        while True:
            x = yield
            received.append(x)
    except GeneratorExit:
        print("closed, received", received)

e = echo()
next(e)          # 先推进到第一个 yield
e.send("a")
e.send("b")
e.close()

输出 closed, received ['a', 'b']。注意第一次必须先 next 或 send(None),因为生成器还没走到 yield,不能直接接收值。这套机制是早期协程的基础,现在写异步更常用 async def 和 await,但理解「暂停与恢复」对看懂 asyncio 仍然有用。

最常踩的坑是「生成器只能消费一次」。下面的代码第二次循环什么都不打印:

g = (x for x in range(3))
print(list(g))
print(list(g))

第一次 list(g) 已经把生成器耗尽,第二次拿到空列表。需要多次遍历时,要么改成列表,要么重新创建生成器。另一个坑是在生成器里 return 值:这个值不会成为序列的一项,只会挂到 StopIteration.value 上,普通 for 循环看不到它。想返回结果就用普通函数,别指望生成器的返回值。

生成器还有一个容易忽略的责任:它可能一直持有资源。下面这种写法在文件句柄上很常见:

def read_rows(path):
    f = open(path, encoding="utf-8")
    for line in f:
        yield line.strip()

for row in read_rows(path):
    if row.startswith("ERROR"):
        break

循环提前 break,生成器没有被完全消费,文件什么时候关?生成器对象被垃圾回收时会触发 close,进而执行 finally,但这依赖回收时机,不是确定行为。正确写法是在生成器内部用 with open(...) as f,或者调用方显式 gen.close()。写生成器的一条实用规则:生成器里打开的资源,生成器里负责关。

yield from 用来把另一个可迭代对象的值逐个转出来,省掉一层 for 循环,也能把 send 和异常透传下去。它适合「组合多个数据源」的场景,比如先读文件、再读数据库结果,合成一个流。理解它的关键是「委托」:当前生成器把控制权交给子迭代器,子迭代器结束时再把结果交回来。

顺带区分两个常被混用的词:可迭代对象和迭代器。列表、字典、字符串是「可迭代对象」,它们能反复产生新的迭代器;生成器是「迭代器」,自身就带 __next__,走到头就停。所以 for x in [1, 2, 3] 可以写很多次,for x in gen 只能消费一次。判断一个对象是不是迭代器,看它有没有 __next__;只实现 __iter__ 的通常只是可迭代对象。

生成器处理大文件的推荐结构
逐行读取同一时刻只有一行在内存里
过滤清洗每行生成一个结果,不累积
聚合统计只保留计数或少量汇总
写出结果边算边写,峰值内存可控

装饰器:接收函数的函数

Python 里函数是一等对象,可以赋值给变量、作为参数传递、从函数返回。装饰器就是利用这一点:它接收一个函数,返回另一个函数,@deco 只是 func = deco(func) 的语法糖。没有任何神秘机制。

def timer(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        print(f"{fn.__name__} took {time.perf_counter() - start:.4f}s")
        return result
    return wrapper

@timer
def work():
    time.sleep(0.2)
    return 1

调用 work() 时,实际执行的是 wrapper,它先记时间,再调用原函数,最后打印耗时。原函数被闭包捕获,外面的名字 work 指向 wrapper。functools.wraps 的作用是把原函数的 __name__、__doc__、__module__ 等属性复制到包装函数上,否则调试时看到的所有函数都叫 wrapper,日志和文档全废。我实测不写 wraps 时,hello.__name__ 是 wrapper,hello.__doc__ 是 None。

需要给装饰器传参数时,结构会多一层:最外层接收参数,返回真正的装饰器,再返回包装函数。@retry(times=3) 这种写法背后是三层函数嵌套,第一次见容易看晕,按「谁接收什么、谁返回什么」逐层读就不乱。

用同步装饰器包异步函数,会把协程函数变成普通函数。async def 被包之后,调用包装函数得到的是协程对象而不是执行结果,await 的位置会报「object coroutine can't be used in await expression」之类的问题。给异步函数写装饰器,包装函数本身也要 async def,并在里面 await fn(...)。

装饰器最常见的用途是横切逻辑:计时、重试、缓存、权限检查、日志。判断该不该用装饰器,看这件事是不是「和业务无关、多个函数都要做、顺序固定」。如果是,装饰器合适;如果逻辑依赖具体参数或返回值结构,写成普通函数调用更清楚,别为了优雅把控制流藏进装饰器。

多个装饰器叠在一起时,执行顺序是从下往上的。写法这样:

@timer
@retry(times=3)
def fetch(url):
    ...

等价于 fetch = timer(retry(times=3)(fetch))。调用时先进入 timer 的包装函数,再进入 retry 的包装函数,最后才到真正的 fetch。所以「计时」统计到的是包含重试的总耗时,而不是单次请求耗时。想让计时只算单次,就把 timer 放在 retry 下面。这个顺序没有对错,但必须是有意选的,不能靠猜。

上下文管理器:with 靠两个方法工作

with 不是语法糖,它是一个协议:对象实现 __enter__ 和 __exit__,进入块时调用前者,离开块时调用后者,不管块里是正常结束、return、break 还是抛异常。__exit__ 收到异常类型、异常值、回溯三个参数,返回真表示「异常已处理」,返回假或不返回则继续向外抛。

@contextlib.contextmanager
def tag(name):
    print(f"<{name}>")
    try:
        yield name
    finally:
        print(f"</{name}>")

with tag("div") as t:
    print("body", t)

输出三行:开标签、body div、闭标签。contextlib.contextmanager 把一个生成器函数变成上下文管理器:yield 之前是 __enter__,yield 之后是 __exit__。注意 yield 必须包在 try/finally 里,否则块内抛异常时清理代码不会执行。

用 with 管理文件、锁、数据库连接、临时目录,核心都是同一个保证:无论中间怎么退出,释放动作都会执行。手写 try/finally 也能做到,但嵌套三层之后很容易漏。ExitStack 可以动态管理数量不定的资源,适合「打开一批文件再统一关闭」这种场景。

异常发生时 with 的行为值得单独看一眼。块里抛出异常后,解释器先调用 __exit__,把异常信息传进去;如果 __exit__ 返回假值,异常继续向外抛,原来的栈信息保留;返回真值,异常就此结束,外层看不到。用生成器写法时,异常会在 yield 那一行重新抛出,所以 try/finally 里的 finally 一定会跑,而 except 要不要写取决于你想不想处理它。一个常见的错误是只在 yield 后写清理语句、不包 try,正常退出时看不出问题,一旦块内抛异常,清理就被跳过了。

__exit__ 返回 True 会吞掉异常。这是有意的能力,不是默认行为。只在确实要「把异常转成正常流程」时使用,比如「文件不存在就创建」,并且要在里面明确记录发生了什么,否则排查时会发现异常凭空消失。

鸭子类型:只看会做什么,不看是什么

「鸭子类型」这句话的完整意思是:如果一个对象走路像鸭子、叫起来像鸭子,那就把它当鸭子。在 Python 里,函数不检查参数的类型,只检查它用到的属性和方法在不在。一个对象只要支持 len() 和下标访问,就能被 for 循环遍历,不需要继承某个特定基类。

class Bag:
    def __init__(self, items):
        self.items = items
    def __len__(self):
        return len(self.items)
    def __getitem__(self, i):
        return self.items[i]

b = Bag([10, 20, 30])
print(len(b), [x for x in b], b[0])

输出 3 [10, 20, 30] 10。Bag 没有继承 list,也没有注册成任何抽象基类,但 len、迭代、下标全都工作。这就是协议:Python 用「方法名和签名」约定行为,不用继承关系约定身份。

鸭子类型带来的直接好处是灵活:你可以把「日志写入器」换成「写文件」「写内存」「写网络」三种实现,只要它们都有 write 方法,调用方一行不用改。测试里也常用假对象替代真实依赖,不需要 mock 框架,写个带同样方法的类就行。

代价是错误暴露得晚。传错对象时,报错发生在「第一次调用那个方法」的时刻,可能离传参的地方很远,错误信息是 'X' object has no attribute 'write',不告诉你期望什么。缓解手段有三个:在边界处做少量显式检查(比如参数是路径还是文件对象)、写清类型注解让静态检查工具兜底、给关键协议定义抽象基类或 Protocol。这不是回到「什么都查类型」,而是在容易传错的地方加一道便宜的护栏。

Protocol 是给鸭子类型补一份「说明书」的写法:

from typing import Protocol

class Writer(Protocol):
    def write(self, text: str) -> int: ...

def save(w: Writer, content: str) -> None:
    w.write(content)

Writer 不要求任何类继承它,只要方法签名对得上,静态检查工具就认为兼容,运行时也不做 isinstance 检查。这样既保留了「不靠继承」的灵活,又把契约写在了类型里。项目里需要传「任何能写的东西」时,用 Protocol 比在文档里写一句「要有 write 方法」可靠。

但契约写得太细也会限制鸭子类型的好处。只需要 write 的场景,不要把整个文件对象的十几个方法都列进 Protocol,否则一个简单的内存缓冲就满足不了。按「调用方真正用到什么」来定义协议,是这类抽象唯一正确的粒度。

另一种相关思路是 EAFP 与 LBYL。EAFP 是「先做,出错再处理」,对应 try/except;LBYL 是「先检查,再行动」,对应 if os.path.exists(...)。文件这类资源,检查和使用的间隙里状态可能变化,EAFP 通常更可靠:直接打开,捕获 FileNotFoundError。但异常不能当普通控制流用,预期内的分支还是用条件判断更清楚。

现象对照

现象真实原因第一步查什么
处理大文件时内存线性上涨列表推导或 read() 一次性把数据装进内存看数据是不是被存进了列表,改成生成器或逐行处理
第二次遍历生成器什么都没拿到迭代器只能消费一次,已经耗尽确认对象是生成器还是列表,需要重复遍历就重新创建
next() 报 StopIteration生成器已经结束,没有更多值用 for 循环消费,或给 next 传默认值
装饰器包完后函数名全变成 wrapper没有用 functools.wraps 复制元数据给包装函数加 @functools.wraps(fn)
异步函数加装饰器后 await 报错同步包装函数把协程对象直接返回,没有 await把包装函数也写成 async def
with 块里抛异常后清理没执行生成器式上下文管理器没写 try/finally检查 yield 是否被 try/finally 包住
异常在 with 里消失__exit__ 返回了真值,把异常吞了检查 __exit__ 的返回值,确认是否故意抑制
传错对象后报 no attribute鸭子类型只在调用方法时才检查看报错指向哪个方法,确认调用方期望的协议

边界与代价

生成器省内存,但它把「计算」推迟到了消费端。调试时看不到中间结果,异常栈里会出现 generator 帧,定位问题比普通函数绕。另一个代价是生命周期变长:生成器对象被谁持有、什么时候关闭,需要想清楚。长时间不消费的生成器会一直占着局部变量,文件句柄也可能迟迟不释放。

装饰器让代码看起来干净,但把调用链藏起来了。一个函数叠了五个装饰器,实际执行顺序从下往上传,任何一层都可能改参数、改返回值、吞异常。排查时不能只看被装饰的函数,要顺着装饰器一层层看。装饰器越多,栈越深,性能开销也越明显,热点函数上叠计时和日志要谨慎。

上下文管理器的代价主要是「协议实现要正确」。手写 __exit__ 时,异常参数的处理、返回值语义、资源释放顺序都容易写错,能用 contextmanager 或 ExitStack 就别手写。还要注意 with 只保证「退出时执行」,不保证「一定成功」,清理代码自己抛异常会覆盖原始异常,必要时记录两份。

鸭子类型的代价前面说过:错误发现晚、契约不显式。项目小的时候靠自觉够了,项目大了必须有类型注解和测试。别把「Python 不需要类型」当成信条,它只是「不强制」,不是「不需要」。团队越大,显式契约越值钱。

小结

生成器是能暂停的函数,用 yield 一次交出一个值,适合流式处理大数据,但只能消费一次;装饰器是接收函数并返回新函数的普通函数,靠闭包工作,记得加 functools.wraps,异步函数要用异步装饰器;上下文管理器靠 __enter__ 和 __exit__ 保证清理,生成器写法要把 yield 放进 try/finally;鸭子类型只看对象能做什么,灵活但错误发现晚,需要注解和测试兜底。

这四样东西的共同点是:它们都没有改变 Python 的基本规则,只是把「函数是一等对象」「协议靠方法名」「资源释放要保证」这几条基础用到了极致。看懂背后的机制,比记住用法重要。

当天可以自己验证的练习:

  1. 用 tracemalloc 对比列表推导和生成器表达式处理一百万个整数的内存峰值,记下两个数字。
  2. 写一个生成器,用 send 往里传三个值,再用 close() 触发清理,观察 GeneratorExit。
  3. 写一个计时装饰器,分别加和不加 functools.wraps,打印 __name__ 和 __doc__ 对比。
  4. 用 @contextmanager 写一个临时切换工作目录的上下文管理器,故意在块里抛异常,确认目录被恢复。
  5. 写一个只有 __len__ 和 __getitem__ 的类,验证 len、for、切片分别能不能用,记录哪些能、哪些不能。

下一篇讲字符串、集合、datetime、json 与 pathlib。语言特性解决「怎么写」,标准库解决「日常活怎么干」:文本怎么切、时间怎么算、JSON 怎么转、路径怎么拼。这些 API 用错的地方都很具体,也都能在几分钟内复现。