闭包

是什么，为什么存在

闭包是一个函数对象，以及它对定义位置中所需外层绑定的访问能力。在 Python 中，最常见的形式是外层函数创建并返回一个内层函数。外层调用已经返回，内层函数仍可使用那次调用留下的绑定。

内层函数使用、但不在自身代码块中绑定的名称叫作 自由变量（free variable） 。提供该绑定的词法作用域叫作 外层作用域（enclosing scope） 。函数的代码与这些绑定合在一起，才有调用时所需的完整上下文。

闭包让函数在作为值传递时仍遵守词法作用域。它适合把少量配置附在回调上，或者通过一个很窄的函数接口保存状态，而无需模块全局变量。函数工厂、装饰器、验证器、事件处理器，以及传给 sorted() 的键函数中都能见到它。

返回内层函数不是形成闭包的语义条件，只是让闭包的生命周期最容易观察。只要嵌套函数引用了外层函数的绑定，它在外层调用期间执行时也仍是闭包。反过来，嵌套函数若只使用参数、局部名称和全局名称，__closure__ 就是 None。

闭包适合一种主要操作和少量容易命名的状态。如果调用方需要多个公开操作、验证规则、可序列化表示或继承关系，类通常能更直接地表达契约。选择依据是接口与所有权，而不是笼统的速度或内存说法。

工作原理

Python 按源码中的嵌套关系解析名称，而不是查看谁调用了当前函数。编译器发现内层代码引用了外层函数绑定的名称时，会把该名称归类为自由变量，并安排共享存储。调用栈上另一个同名局部变量不会改变这种选择。

每次执行外层函数，都会创建属于本次调用的局部绑定。创建内层函数时，函数对象取得访问所需绑定的路径；返回函数不会把对象值复制成快照。后续调用读取的是绑定当时指向的对象，所以重新绑定会改变闭包之后看到的结果。

一次闭包创建和调用可以按下面的顺序理解：

1. 调用外层函数，为这次调用创建局部绑定。
2. 执行内层函数定义，识别并连接它实际使用的外层绑定。
3. 把内层函数传出外层调用，或者在外层调用中直接使用它。
4. 外层调用结束后，仍被闭包引用的绑定继续存活。
5. 调用闭包时，名称查找读取或更新同一个绑定。

闭包不会自动保留外层函数的整个局部命名空间。只有内层代码实际作为自由变量使用的绑定需要留下。不过，一个绑定可能指向很大的可变对象或对象图，所以「只捕获一个名称」并不等于保留的数据一定很少。

读取、修改与重新绑定

读取自由变量不需要声明。修改自由变量所指向的可变对象也不需要声明，因为绑定本身没有变化。只有内层函数要让名称指向另一个对象时，才需要 nonlocal。

count += 1 容易让人误判。整数不能原地修改，因此该语句先读取旧整数，再计算新整数，最后给 count 赋值。只要函数体中存在这种赋值，count 默认就被归类为该函数的局部名称；没有 nonlocal count 时，读取尚未赋值的局部名称会抛出 UnboundLocalError。

nonlocal 的目标

nonlocal name 指向最近一个已经绑定该名称的外层函数作用域。它不会创建外层绑定，也不能指向模块全局作用域。编译器找不到合适绑定时，会在代码执行前抛出 SyntaxError。

global 与 nonlocal 解决的不是同一个问题。global 把赋值指向模块命名空间；把生成代码中的 nonlocal 机械替换为 global，会把本应属于某次工厂调用的状态变成整个模块共享的状态。

同一次外层调用创建的多个函数可以共享绑定；不同外层调用通常取得不同绑定。因此，「函数来自同一个工厂」不表示它们共享状态，真正决定共享关系的是它们来自哪一次工厂调用，以及引用了哪个绑定。

示例

下面四个示例从只读配置开始，再加入可变状态、共享操作和循环回调。所有输出都由本地 python3 实际执行对应文件得到。

携带只读配置

标签工厂把前缀配置一次，返回只接收订单编号的函数。prefix 只被读取，因此不需要 nonlocal。

两次 make_labeler() 调用各自创建一个 prefix 绑定，所以两个标签函数互不影响。co_freevars 给出自由变量名称，__closure__ 中相同位置的 cell 保存对应绑定；这种按位置检查适合诊断，不适合作为业务接口。

字符串对象恰好不可变，但这不是闭包复制了字符串。函数仍通过自己的绑定访问 "INV"。如果外层代码后来通过另一个闭包重新绑定同一个名称，读取函数就会看到新对象。

用 nonlocal 保存状态

计数器需要让 count 指向一个新整数，所以 record() 明确声明 nonlocal count。每次工厂调用都产生独立计数。

def make_attempt_counter(start=0):
    count = start

    def record():
        nonlocal count
        count += 1
        return count

    return record


email_attempt = make_attempt_counter()
sms_attempt = make_attempt_counter(10)

print(f"email: {email_attempt()}, {email_attempt()}")
print(f"sms: {sms_attempt()}")
print(f"email: {email_attempt()}")

email: 1, 2
sms: 11
email: 3

交错调用表明两个计数器没有泄漏状态。把 email_attempt 赋给另一个名称不会创建新计数器，因为两个名称仍指向同一个函数对象；需要独立状态时，必须再次调用工厂。

这个接口只允许调用方推进计数，不能直接把 count 设成任意值。它提供的是作用域形成的封装约定，不是安全边界；检查函数对象的代码仍能看到 cell 内容。

让多个操作共享一个 cell

一次 make_quota() 调用返回两个函数。reserve() 重新绑定 remaining，available() 读取它；两者连接到同一个 cell。

def make_quota(limit):
    remaining = limit

    def reserve(units):
        nonlocal remaining
        if units <= 0:
            raise ValueError("units must be positive")
        if units > remaining:
            return False
        remaining -= units
        return True

    def available():
        return remaining

    return reserve, available


reserve, available = make_quota(5)
print(reserve(2), available())
print(reserve(4), available())
print(reserve(3), available())

True 3
False 3
True 0

第二次预留失败后，remaining 没有变化。两个函数共享状态使这个结果可以从 available() 观察到。若操作继续增多，返回一组匿名位置上的函数会变得难读，此时带有 reserve() 和 available() 方法的类通常更合适。

共享 cell 不提供同步。若多个线程或异步任务可以交错执行检查与扣减，if units > remaining 和 remaining -= units 不是一个业务原子操作；需要根据执行模型增加锁或把状态交给单一所有者。

对比延迟绑定与创建时绑定

循环中的两个列表都生成三个 lambda。第一组直接引用循环变量，第二组把当轮对象保存为默认参数。

def make_handlers(queue_names):
    late_handlers = []
    bound_handlers = []

    for queue_name in queue_names:
        # 这一组函数共享循环变量的 cell。
        late_handlers.append(lambda: queue_name)
        # 默认参数在创建函数时保存当前对象。
        bound_handlers.append(lambda queue_name=queue_name: queue_name)

    return late_handlers, bound_handlers


late, bound = make_handlers(["fast", "bulk", "slow"])

print([handler() for handler in late])
print([handler() for handler in bound])
print(late[0].__closure__[0] is late[1].__closure__[0])
print(bound[0].__closure__)

['slow', 'slow', 'slow']
['fast', 'bulk', 'slow']
True
None

第一组函数在循环结束后才读取 queue_name，此时共享 cell 指向 "slow"。这就是 延迟绑定（late binding） 陷阱。列表推导式有自己的作用域，但在同一次推导中创建并稍后调用的闭包仍会共享那个推导变量。

第二组的左侧 queue_name 是 lambda 的局部形参，右侧名称在执行 lambda 定义时求值。保存后的对象位于函数默认值中，而不是闭包 cell 中，所以 __closure__ 是 None。如果调用方不应覆盖这个参数，调用一次辅助工厂通常比暴露默认参数更清楚。

陷阱

把闭包说成值快照

修复方法： 画出每个自由名称对应的绑定，并标明函数创建与函数调用发生的时间。需要快照时，用默认参数、辅助工厂或显式复制表达这个决定，同时说明复制是浅层还是深层。

遗漏或误用 nonlocal

修复方法： 确实要重新绑定外层函数状态时，靠近函数开头写出 nonlocal。只读或原地修改可变对象时不要机械添加它；目标属于模块时才使用 global。遇到 UnboundLocalError，先检查函数中所有赋值位置，而不只是报错行。

错误放置工厂调用

修复方法： 先写清状态属于应用、队列、请求还是单个回调，再把工厂调用放在对应生命周期的边界。测试时交错调用两个应该独立的实例，也连续调用一个应该保留状态的实例。

在循环中隐藏延迟绑定

修复方法： 在循环结束后再调用所有生成函数，并断言每个结果。只需要固定一个值时可用默认参数；每个回调还需要独立可变状态时，应为每次迭代调用一次命名工厂。

捕获生命周期过长的对象

修复方法： 提取回调真正需要的小型值，不要为了一个字段捕获整个上下文对象。所有者结束时解除注册；文件、套接字和事务等资源应由上下文管理器明确管理，而不是等待闭包被回收。

依赖 __closure__ 的位置

修复方法： 诊断时把 function.__code__.co_freevars 与 function.__closure__ 按位置配对，或者使用 inspect.getclosurevars() 分类查看绑定。生产代码应通过公开函数接口读取或改变状态，不要把 cell 布局当作协议。

延伸阅读

• Python 语言参考：名称与绑定
• Python 语言参考：nonlocal 语句
• Python 数据模型：用户定义函数
• Python inspect.getclosurevars()
• Python 编程常见问题：循环中的 lambda
• PEP 3104：访问外层作用域中的名称