Python 闭包详解

1. 什么是闭包？

闭包（Closure）是指在一个外部函数中定义的一个内部函数，该内部函数引用了外部函数的局部变量，并且外部函数将这个内部函数作为返回值返回。此时，这个内部函数连同它所引用的外部变量环境一起，就构成了一个闭包。

简单理解：闭包 = 内部函数 + 外部函数中变量的引用环境。

python 复制代码

def outer(x):
    def inner(y):
        return x + y   # 引用了外部函数的变量 x
    return inner       # 返回内部函数

closure = outer(10)    # closure 就是一个闭包
print(closure(5))      # 输出 15

2. 闭包形成的条件

要形成闭包，必须同时满足以下三个条件：

函数嵌套：在一个外部函数内部定义了另一个内部函数。
内部函数引用外部函数的变量：内部函数使用了外部函数作用域中的变量（非全局变量）。
外部函数返回内部函数：外部函数将内部函数作为返回值返回（或者通过其他方式将内部函数的引用传递出去）。

如果内部函数没有引用外部变量，那么它只是一个普通的嵌套函数，不是闭包。

python 复制代码

# 反例1：没有返回内部函数
def outer(x):
    def inner(y):
        return x + y
    # 没有返回 inner，inner 只是局部函数，无法形成闭包

# 反例2：内部函数没有引用外部变量
def outer(x):
    def inner(y):
        return y + 1   # 只用了自己的参数和常量，没有用 x
    return inner       # 这不是闭包，只是一个普通嵌套函数

3. `closure` 属性

每个 Python 函数对象都有一个 __closure__ 属性。

如果函数是一个闭包，那么 __closure__ 返回一个元组，元组中包含若干个 cell 对象。每个 cell 对象对应一个被内部函数捕获的外部变量，可以通过 cell.cell_contents 访问该变量的当前值。
如果不是闭包，则 __closure__ 为 None。

python 复制代码

def outer(x, y):
    def inner(z):
        return x + y + z   # 引用了 x 和 y
    return inner

closure_func = outer(1, 2)
print(closure_func.__closure__)  
# (<cell at 0x...: int object at 0x...>, <cell at 0x...: int object at 0x...>)
print(closure_func.__closure__[0].cell_contents)  # 1
print(closure_func.__closure__[1].cell_contents)  # 2

# 非闭包函数
def normal_func(a):
    return a + 1
print(normal_func.__closure__)  # None

4. 闭包的优点

避免全局变量：可以封装状态，避免污染全局命名空间。
保持状态：闭包中的外部变量会"记住"它们上次被修改的值（每次调用外部函数会生成一个新的闭包实例，独立保存状态）。
轻量级：相比定义一个类，闭包更简洁，适合需要少量状态和单一行为的场景。
实现装饰器、延迟计算、回调函数：闭包是这些高级特性的基础。
数据隐藏：外部无法直接访问闭包捕获的变量，只能通过返回的内部函数间接操作，实现一定程度的封装。

python 复制代码

# 计数器示例：每次调用返回递增的值
def counter(start=0):
    count = start
    def increment():
        nonlocal count   # 注意：修改不可变变量需要 nonlocal
        count += 1
        return count
    return increment

c1 = counter(10)
print(c1())  # 11
print(c1())  # 12

c2 = counter(100)
print(c2())  # 101
# c1 和 c2 的状态互不影响

5. 闭包的缺点

修改外部变量需用 nonlocal ：对于整数、字符串等不可变类型，如果要在内部函数中修改外部变量，必须使用 nonlocal 声明，否则会被当作新建局部变量。这增加了代码复杂度。
可能造成内存泄漏：闭包会长期持有外部函数的变量，如果这些变量引用大对象（如大列表、文件句柄等），且闭包实例长时间存活（例如注册为回调函数未被注销），可能导致这些大对象无法被及时回收。
调试相对困难 ：闭包中的变量隐藏在 __closure__ 中，不像类的属性那样直观，在复杂逻辑中可能增加调试难度。
功能单一：一个闭包只能提供一个行为（即内部函数）。如果需要多个相关操作（如增删改查），类会是更好的选择。

python 复制代码

# nonlocal 示例
def make_accumulator():
    total = 0
    def add(x):
        nonlocal total   # 如果不加这一行，total 会被当作局部变量，报错
        total += x
        return total
    return add

acc = make_accumulator()
print(acc(5))  # 5
print(acc(3))  # 8

6. 闭包与类的可替换性及使用场景区别

6.1 可替换性

闭包和类都可以用来封装状态和行为。

一个闭包可以看作是一个只有单个方法 （即 __call__）的轻量级类，该方法捕获并操作外部变量。
反之，一个只实现了 __call__ 方法的类也可以完全模拟闭包的行为。

python 复制代码

# 使用类实现计数器
class Counter:
    def __init__(self, start=0):
        self.count = start
    def __call__(self):
        self.count += 1
        return self.count

c_class = Counter(10)
print(c_class())  # 11

# 使用闭包实现相同功能
def counter_closure(start=0):
    count = start
    def inner():
        nonlocal count
        count += 1
        return count
    return inner

c_closure = counter_closure(10)
print(c_closure())  # 11

在简单场景下，两者可以互相替换。但选择哪一种，取决于具体需求。

6.2 使用场景的区别

维度	闭包	类
状态复杂度	适合少量（通常1~3个）状态变量	适合多个、关系复杂的状态
行为数量	单一行为（一个内部函数）	多个方法（增、删、改、查等）
代码量	简洁，几行代码即可	相对冗长，需要定义 `__init__` 等方法
可读性	简单场景很直观；复杂逻辑可能晦涩	结构清晰，属性和方法明确
扩展性	难以扩展新行为	易于扩展新方法、支持继承、多态
生命周期管理	变量跟随闭包实例，无法单独重置某个状态	可以显式提供重置、清理等方法
典型应用	装饰器、函数工厂、回调、延迟计算、简单迭代器	GUI组件、复杂业务逻辑、数据模型、需要多操作的模块

具体建议：

用闭包：当只需要一个函数，且需要记住少量状态（如计数器、配置参数、缓存值）时。装饰器是最佳示例。
用类：当需要多个相关方法（如队列的 put/get）、需要继承体系、或者状态本身很复杂（多个属性且相互关联）时。

7. 总结

闭包是 Python 中一种优雅的编程范式，利用嵌套函数和变量捕获来实现状态保持。
__closure__ 属性可以帮助我们检查一个函数是否是闭包，并访问捕获的变量。
闭包简洁、轻量，适合单一行为的小型状态机；但修改外部不可变变量需要 nonlocal，且存在潜在的内存泄漏风险。
闭包与类在封装状态方面可以互相替换，但类更适合多行为、复杂逻辑和面向对象设计。
根据实际需求选择合适的方式，写出既清晰又高效的代码。

Python 闭包详解

1. 什么是闭包？

2. 闭包形成的条件

3. __closure__ 属性

4. 闭包的优点

5. 闭包的缺点

6. 闭包与类的可替换性及使用场景区别

6.1 可替换性

6.2 使用场景的区别

7. 总结

3. `closure` 属性