Python 闭包：函数嵌套的 “状态捕获” 机制

闭包（Closure）是嵌套函数的一种特殊表现函数，其核心特性是内部函数能记住并访问外部函数的变量，即使外部函数已经执行完毕。闭包本质上是函数与环境变量的绑定。

闭包的构成条件

**1.嵌套函数：**在函数A内部定义了函数B；

**2.引用外部变量：**函数B引用了函数A的变量；

**3.返回内部函数：**函数A返回函数B。

python 复制代码

def outer():
    x = 10  # 外部函数的变量
    
    def inner():
        print(x)  # 内部函数引用外部变量
    
    return inner  # 返回内部函数

# 创建闭包实例
closure = outer()
closure()  # 输出：10（闭包记住了x=10）

闭包的典型应用场景

1.计算器

python 复制代码

def make_counter():
    count = 0
    
    def counter():
        nonlocal count  # 声明修改外部变量
        count += 1
        return count
    
    return counter

# 使用闭包计数器
counter1 = make_counter()
print(counter1())  # 输出：1
print(counter1())  # 输出：2

counter2 = make_counter()
print(counter2())  # 输出：1（独立的计数器）

2.装饰器

闭包是装饰器的实现基础：

python 复制代码

def decorator(func):
    def wrapper():
        print("执行前")
        func()
        print("执行后")
    return wrapper  # 返回闭包

@decorator
def greet():
    print("Hello!")

greet()  # 输出：
         # 执行前
         # Hello!
         # 执行后

3.回调函数

python 复制代码

def make_callback(message):
    def callback():
        print(f"回调消息：{message}")
    return callback

# 创建闭包回调
callback1 = make_callback("数据已加载")
callback2 = make_callback("操作完成")

callback1()  # 输出：回调消息：数据已加载
callback2()  # 输出：回调消息：操作完成

闭包的核心特性

1.数据封装与隐藏

闭包允许将变量"隐藏"在外部函数中，通过内部函数间接访问：

python 复制代码

def calculator(initial_value):
    value = initial_value
    
    def add(n):
        nonlocal value
        value += n
    
    def get_value():
        return value
    
    return add, get_value

# 使用闭包计算器
add, get = calculator(0)
add(5)
add(3)
print(get())  # 输出：8（外部无法直接访问value）

2.延迟计算

闭包可以在需要时动态计算结果：

python 复制代码

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

# 创建闭包乘法器
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # 输出：10
print(triple(4))  # 输出：12

闭包与普通函数的区别

应用场景	计数器，装饰器，回调函数	通用功能函数

闭包的常见问题

1.变量作用域问题

默认情况下，内部函数无法修改外部函数的变量：

python 复制代码

def outer():
    x = 10
    def inner():
        x += 1  # 错误：x被视为局部变量
    return inner

**解决：**使用 nonlocal 声明（Python 3+）：

python 复制代码

def outer():
    x = 10
    def inner():
        nonlocal x  # 声明使用外部变量
        x += 1
        print(x)
    return inner

closure = outer()
closure()  # 输出：11

2.循环变量的闭包陷阱

python 复制代码

def make_callbacks():
    callbacks = []
    for i in range(3):
        callbacks.append(lambda: print(i))  # 闭包捕获的是循环变量i的最终值
    return callbacks

callbacks = make_callbacks()
for cb in callbacks:
    cb()  # 全部输出：2

**解决：**用默认参数绑定当前值：

python 复制代码

def make_callbacks():
    callbacks = []
    for i in range(3):
        callbacks.append(lambda i=i: print(i))  # 默认参数保存当前i的值
    return callbacks

callbacks = make_callbacks()
for cb in callbacks:
    cb()  # 输出：0, 1, 2

3.内存占用

闭包会延迟外部变量的生命周期，可能导致内存泄漏：

python 复制代码

def outer():
    large_data = [1] * 1000000  # 大内存对象
    def inner():
        return sum(large_data)
    return inner

closure = outer()
# 即使outer()执行完毕，large_data仍被闭包引用，无法释放