闭包的本质：Python 如何捕获自由变量

文章目录

• • 一、从一个计数器开始
  • [二、LEGB 规则：名字查找的顺序](#二、LEGB 规则：名字查找的顺序)
  • [三、`global` 关键字：打破 E 层](#三、global 关键字：打破 E 层)
  • [四、`nonlocal` 关键字：访问 E 层变量](#四、nonlocal 关键字：访问 E 层变量)
  • 五、闭包的完整执行流程
  • 六、闭包变量的生命周期
  • 七、闭包的典型应用场景
  • • 场景一：函数工厂（最常见用法）
    • 场景二：带记忆的递归函数
    • 场景三：装饰器（闭包的直接应用）
  • 八、闭包的常见错误：迟绑定
  • [九、`closure` 与自由变量的深度解析](#九、__closure__ 与自由变量的深度解析)
  • 十、知识点总结

一、从一个计数器开始

学作用域的时候，通常会遇到这样的代码：

def make_counter():
    count = 0
    def counter():
        count += 1   # 这里会报错
        return count
    return counter

c = make_counter()
print(c())  # UnboundLocalError: local variable 'count' referenced before assignment

这不是 bug------这是 Python 作用域规则在说话。报错的原因和 count += 1 这行代码里发生了什么有关，也在某种程度上揭示了闭包的本质。

要彻底理解这段代码，得先搞清楚 Python 的作用域规则，以及闭包是怎么工作的。

---

二、LEGB 规则：名字查找的顺序

Python 查找变量名时，按 LEGB 的顺序逐层搜索：

• L（Local）：当前函数内部定义的变量
• E（Enclosing）：外层嵌套函数中的变量
• G（Global）：模块级全局变量
• B（Built-in） ：Python 内置名字，比如 len、print

用代码验证这个顺序：

x = "global"  # G 层

def outer():
    x = "enclosing"  # E 层

    def inner():
        x = "local"  # L 层
        print(x)  # -> local（找到了就停）

    inner()

outer()

每层可以定义和上层同名的变量，彼此互不干扰。Python 之所以这样做，是因为名字查找发生在运行时而非编译时------解释器执行到哪一行，才去相应的作用域里找变量。

LEGB 规则可视化：
B 层：内置作用域

Python 预定义
L 层：本地作用域

当前函数内部
E 层：嵌套作用域

外层函数作用域
G 层：全局作用域

模块级别，用 import/global 访问
找不到时
找不到时
找不到时
len, print, 自定义全局变量
外层函数的局部变量
当前函数的局部变量
print, len, range, ...

查找时从内向外逐层搜索，找到即停。

---

三、global 关键字：打破 E 层

回到开头的计数器报错。count += 1 等价于：

count = count + 1

Python 看到这行代码时，发现等号左边有 count，就认为 count 应该是当前作用域的局部变量。但 count 在 outer() 的作用域里（E 层），不在 counter() 的作用域里（L 层）------Python 拒绝在 E 层创建同名 L 层变量，所以报了 UnboundLocalError。

解决方式一：把 count 提升到全局作用域：

count = 0

def make_counter():
    global count  # 声明接下来访问全局的 count
    count += 1
    return count

print(make_counter())  # 1
print(make_counter())  # 2

但 global 有个严重问题：它让 count 变成模块级全局变量 。多个 make_counter() 实例会共享同一个 count，完全破坏了隔离性。

---

四、nonlocal 关键字：访问 E 层变量

nonlocal 是 global 的近亲，但作用域不同。它允许在 L 层函数中修改 E 层（嵌套外层）的变量：

def make_counter():
    count = 0

    def counter():
        nonlocal count  # 声明：接下来对 count 的赋值操作，作用于外层的 count
        count += 1
        return count

    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

nonlocal 不会在 L 层创建新变量，也不涉及 G 层------它直接作用于最近一层外层函数的变量。

global vs nonlocal 的区别：

关键字	作用层	行为
global	模块级 G 层	读写全局变量，多个函数共享
nonlocal	嵌套外层 E 层	读写外层函数变量，多个闭包独立

---

五、闭包的完整执行流程

理解 nonlocal 后，再看闭包的完整执行流程。回到最初报错的代码，但这次不加任何关键字：

def make_counter():
    count = 0  # <- E 层变量

    def counter():
        print("count 当前值:", count)  # 读 E 层变量 - 没问题
        return count  # 读 E 层变量 - 没问题

    return counter

读操作（不加 nonlocal）不会报错------Python 允许读取外层变量。只有写操作（count = something 或 count += something）才会触发 UnboundLocalError，因为等号左边让 Python 认为这是一个新的 L 层变量。

当 Python 看到 nonlocal count 时，在编译期（生成字节码时）就已经把这件事记下来了：

import dis

def make_counter():
    count = 0

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

    return counter

# counter 函数的字节码
dis.dis(counter := make_counter())

关键字节码：

  5           2 LOAD_GLOBAL          0 (count)
              4 LOAD_CONST           1 (1)
              6 BINARY_OP            0 (+)
              8 STORE_FAST           0 (count)
              10 LOAD_FAST           0 (count)
             12 RETURN_VALUE

LOAD_GLOBAL 0 (count) 是 nonlocal 的实现方式------如果不用 nonlocal，这行会变成 LOAD_FAST（读 L 层变量），然后 STORE_FAST 会触发 UnboundLocalError。

---

六、闭包变量的生命周期

闭包有一个经常被忽视的特性：闭包变量的生命周期和闭包本身一样长。

def make_multiplier(factor):
    # factor 绑定在 make_multiplier 的局部作用域里
    def multiply(value):
        return value * factor
    return multiply

doubler = make_multiplier(2)

# make_multiplier() 已经执行完毕退出了
# 但 doubler 仍然持有 factor=2
print(doubler(5))   # 10
print(doubler(100)) # 200

factor 原本在 make_multiplier() 的局部作用域里。函数退出后，局部变量通常应该被销毁------但 doubler 还在使用它，所以 Python 的垃圾回收机制检测到 factor 仍有外部引用，就把它保留下来，通过 cell 对象包装后存入 doubler.__closure__。

这就是为什么 doubler.__closure__[0].cell_contents 能读取到 2------cell 对象就是闭包变量在内存中的载体。

>>> doubler.__closure__
(<cell at 0x...: int object at 0x...>,)
>>> doubler.__closure__[0].cell_contents
2

一个更复杂的例子，验证多个闭包共享同一个外层变量：

def processor(initial=0):
    total = initial

    def add(x):
        nonlocal total
        total += x
        return total

    def subtract(x):
        nonlocal total
        total -= x
        return total

    return add, subtract

add, subtract = processor(100)

print(add(30))     # 130，total = 100 + 30
print(subtract(20)) # 110，total = 130 - 20
print(add(10))     # 120，total = 110 + 10

add 和 subtract 指向同一个 cell 对象------修改 total 对两个函数都生效。这是闭包的"共享状态"特性，常用于事件处理器、回调函数等场景。

---

七、闭包的典型应用场景

场景一：函数工厂（最常见用法）

根据不同参数生成专用函数：

def power_factory(exp):
    def power(base):
        return base ** exp
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(5))  # 25
print(cube(5))    # 125

exp 被捕获在闭包里，square 和 cube 各有独立的 exp 值，互不干扰。相比写死参数，函数工厂更灵活，避免了为每种指数写专门的函数。

场景二：带记忆的递归函数

def memoized_fibonacci():
    cache = {}  # E 层变量

    def fib(n):
        if n in cache:
            return cache[n]
        if n <= 1:
            result = n
        else:
            result = fib(n-1) + fib(n-2)
        cache[n] = result
        return result

    return fib

fib = memoized_fibonacci()
print(fib(100))  # 354224848179261915075
print(fib(200))  # 280571172992510140037611908417314019

cache 字典在闭包里持久化，每次递归调用都能访问同一个缓存------避免了普通递归中子问题被重复计算的问题。

场景三：装饰器（闭包的直接应用）

装饰器本质上就是闭包：

import functools
import time

def timing_decorator(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        # fn 和 elapsed_time 都是闭包变量
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{fn.__name__} 耗时 {elapsed:.4f}s")
        return result
    return wrapper

wrapper 捕获了 fn（被装饰的函数）和 elapsed_time（计时变量）两个自由变量。timing_decorator 返回的 wrapper 闭包里装着被装饰函数的引用，调用时真正执行的是 wrapper，而非原函数。

---

八、闭包的常见错误：迟绑定

这是闭包里最隐蔽的错误。当闭包在循环中创建时，所有闭包实例捕获的是同一个变量，而变量的值以闭包被调用时的值为准------而不是创建时的值：

def create_multipliers():
    multipliers = []
    for i in range(5):
        multipliers.append(lambda x: x * i)  # i 是自由变量
    return multipliers

fns = create_multipliers()

# 全部返回 4*4=16，而不是 0*4, 1*4, 2*4, 3*4, 4*4
print([fn(4) for fn in fns])  # [16, 16, 16, 16, 16]

循环结束时 i = 4，所有闭包引用的是同一个 i，所以调用时都得到 4 * 4 = 16。

解决方式：用默认参数在闭包创建时立即捕获当前值：

def create_multipliers_fixed():
    multipliers = []
    for i in range(5):
        multipliers.append(lambda x, i=i: x * i)  # i=i 把当前值绑定为默认值
    return multipliers

fns = create_multipliers_fixed()
print([fn(4) for fn in fns])  # [0, 4, 8, 12, 16]

lambda x, i=i: ... 里，i=i 的右边 i 是自由变量，在定义时取值为当前的循环变量；左边 i 是默认参数，绑定到 lambda 的 L 层作用域。每次循环迭代时，i 的当前值被"拍"进默认参数，之后循环继续，i 变化也不影响已经绑定好的默认参数。

用 functools.partial 也能解决：

import functools

def create_multipliers_partial():
    multipliers = []
    for i in range(5):
        multipliers.append(functools.partial(lambda x, i: x * i, i=i))
    return multipliers

---

九、__closure__ 与自由变量的深度解析

可以用 __code__.co_freevars 直接看到函数捕获了哪些自由变量：

def outer(x):
    def inner(y):
        # z 从更外层捕获
        def deeper(z):
            return x + y + z
        return deeper
    return inner

# 查看各层函数的自由变量
outer_fn = outer(10)
inner_fn = outer_fn(20)
deeper_fn = inner_fn(30)

>>> outer_fn.__code__.co_freevars
('x',)
>>> inner_fn.__code__.co_freevars
('x', 'y')
>>> deeper_fn.__code__.co_freevars
('x', 'y', 'z')

# __closure__ 的顺序和 co_freevars 一一对应
>>> deeper_fn.__closure__
(<cell at ...: int object at ...>, <cell at ...: int object at ...>, <cell at ...: int object at ...>)
>>> deeper_fn.__closure__[0].cell_contents, \
     deeper_fn.__closure__[1].cell_contents, \
     deeper_fn.__closure__[2].cell_contents
(10, 20, 30)

co_freevars 是字节码层面的元信息，告诉解释器哪些名字是自由变量；__closure__ 是这些自由变量对应的 cell 对象序列，两者顺序一致。

---

十、知识点总结

LEGB 作用域规则
L: 本地作用域
E: 嵌套外层作用域
G: 模块全局作用域
B: 内置作用域
nonlocal 关键字

修改 E 层变量
global 关键字

修改 G 层变量
闭包：函数 + 捕获的环境
closure

存储自由变量的 cell 元组
code.co_freevars

自由变量名字列表
迟绑定陷阱

循环中创建闭包时用默认参数捕获
闭包变量生命周期 = 闭包生命周期
函数工厂

记忆化递归

装饰器

---

如果觉得有帮助，欢迎收藏、关注本专栏。