约 7 分钟5 张卡

Python 闭包与装饰器

闭包让一个函数在外层函数调用结束后，仍能访问它用到的外层绑定。装饰器在对象定义完成时接收这个对象，并返回用于替换它的对象；在函数场景中，常用包装函数加入日志、计时或检查。

两者经常一起使用：包装函数通过闭包记住被包装函数，再在每次调用时转发参数。但闭包不等于装饰器，装饰器也不一定必须由嵌套函数实现。参数绑定的前置规则见 Python 函数参数与作用域。

1. 面试核心

先记住这几条，再读正文

闭包保存对外层绑定的访问能力，默认不是把每个值冻结成定义时的快照。循环中创建的多个函数可能共享同一个最终绑定。卡 · 循环中的延迟查找
@decorate 在函数定义时应用，函数场景可以理解为 func = decorate(func)。包装函数体则通常在后续调用时才执行。卡 · 函数装饰器
通用包装需要正确转发位置和关键字实参，保留返回值并让异常按原约定传播，否则会改变调用方能观察到的行为。卡 · 函数装饰器
functools.wraps 复制名称、文档等元数据并设置 __wrapped__；它不替包装器完成参数校验、重试或错误处理。卡 · 元数据与包装边界
多个装饰器按从下到上应用，调用时先进入最外层包装。带参数装饰器通常先调用工厂，再把返回的装饰器用于原函数。卡 · 带参数装饰器与顺序

2. 闭包中的状态

卡 · 为什么循环里创建的多个闭包可能都读到最后一个值？

内部函数引用外层函数的局部名称时，这些绑定可以随返回的函数继续存在。

def make_prefixer(prefix):
    def format_name(name):
        return prefix + name
    return format_name

format_api = make_prefixer("api:")
format_ui = make_prefixer("ui:")
print(format_api("login"))  # api:login
print(format_ui("login"))   # ui:login

两次 make_prefixer 调用分别建立自己的 prefix 绑定。外层调用结束后，两个内部函数仍能访问各自的前缀，不需要把状态放到模块全局变量里。

如果要在内部函数中重新绑定外层变量，需要 nonlocal。如果只是修改外层列表里的内容，则是修改对象，是否需要声明仍按名称绑定规则判断。

2.1 循环中的延迟查找

闭包访问的是绑定，调用时才读取当前值。下面三个函数共享一次外层调用里的 index：

def make_readers():
    readers = []
    for index in range(3):
        readers.append(lambda: index)
    return readers

print([read() for read in make_readers()])  # [2, 2, 2]

循环结束后 index 是 2，三个函数此时才执行读取，所以得到相同结果。需要每个函数保存当前索引，可以利用默认参数在函数创建时求值：

def make_readers():
    return [lambda index=index: index for index in range(3)]

print([read() for read in make_readers()])  # [0, 1, 2]

右侧 index 在创建每个函数时求值，成为各自的默认实参。它不是改变闭包的查找规则，而是让函数使用自己的参数绑定。另一种方式是额外调用一个工厂函数，为每个值创建独立的外层作用域。

3. 函数装饰器

卡 · Python 装饰器怎样增加函数行为，什么时候执行装饰过程？卡 · 包装函数怎样接收不同参数，并保留原函数返回值？

函数装饰器在不改动原函数主体的前提下，为它增加一层调用行为。

from functools import wraps

def trace(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("before")
        try:
            return func(*args, **kwargs)
        finally:
            print("after")
    return wrapper

@trace
def add(left, right):
    return left + right

print(add(2, right=3))
# before
# after
# 5

trace 接收原来的 add，返回 wrapper；名称 add 随后引用包装函数。包装函数通过闭包保留对原函数的引用，所以 func(*args, **kwargs) 可以继续调用原实现。

不使用 @ 时，这段定义可以写成先定义 add，再执行 add = trace(add)。装饰器应用发生在定义阶段，并非每次调用 add 都重新执行一遍 trace。

finally 让收尾日志也覆盖原函数抛异常的情况，但没有捕获或替换原异常。return func(...) 则确保正常调用仍返回原结果。如果漏掉 return，包装器默认返回 None，调用方就观察不到原来的和。

4. 元数据与包装边界

卡 · 包装函数怎样接收不同参数，并保留原函数返回值？卡 · functools.wraps 解决什么问题，不能代替什么？

包装函数默认有自己的名称和文档。只返回一个名叫 wrapper 的函数，日志或测试报告可能把所有被包装函数都显示成相同名字。

functools.wraps(func) 为包装器保留原函数的常用元数据，并通过 __wrapped__ 指向被包装函数，便于检查和解包。

from functools import wraps

def preserve(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@preserve
def check_status(code):
    """Check a response code."""
    return code == 200

print(check_status.__name__)                 # check_status
print(check_status.__doc__)                  # Check a response code.
print(check_status.__wrapped__(200))         # True

元数据被保留，不表示包装器已经自动复制全部调用行为。比如同步包装器返回协程对象，与真正的 async def 包装器在执行时机上不同；生成器函数、方法绑定与上下文管理器也有相应协议。先保证当前函数类型的语义，再扩展包装范围。

也不能因为装饰器容易统一入口，就默认给所有请求添加重试。重复执行可能产生重复写入，是否可以重试取决于被包装操作的幂等性和错误类型。

5. 带参数装饰器与顺序

卡 · 多个装饰器如何应用，调用时谁先执行？

带参数装饰器通常有三层：工厂接收配置，装饰器接收函数，包装函数接收实际调用参数。

from functools import wraps

def labeled(label):
    def decorate(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            print(label)
            return func(*args, **kwargs)
        return wrapper
    return decorate

@labeled("api-check")
def check_status(code):
    return code == 200

print(check_status(200))
# api-check
# True

定义阶段先执行 labeled("api-check") 得到 decorate，再执行 decorate(check_status) 得到包装函数。之后调用 check_status(200) 才进入 wrapper。

多个装饰器的关系可以直接展开：

events = []

def layer(name):
    def decorate(func):
        def wrapper():
            events.append(name)
            return func()
        return wrapper
    return decorate

outer = layer("outer")
inner = layer("inner")

@outer
@inner
def task():
    events.append("task")

task()
print(events)  # ['outer', 'inner', 'task']