Python中的闭包与变量作用域

描述：
闭包是函数式编程中的一个重要概念，指一个函数（称为外层函数）内部定义了另一个函数（称为内层函数），并且内层函数引用了外层函数的局部变量（称为自由变量）。即使外层函数已经执行完毕，这些被引用的变量也不会被销毁，而是与内层函数形成一个封闭的整体，这就是闭包。理解闭包需要深入掌握Python的变量作用域（LEGB规则）和变量的生命周期。

解题过程/知识点讲解：

第一步：理解变量作用域（LEGB规则）
在Python中，当访问一个变量时，解释器会按照以下顺序查找：

• L（Local）：局部作用域，当前函数内部
• E（Enclosing）：闭包函数的外层函数作用域
• G（Global）：全局作用域，模块级别
• B（Built-in）：内置作用域，Python内置的标识符（如len、range）

示例：

x = "global"  # 全局作用域

def outer():
    y = "enclosing"  # 闭包作用域
    
    def inner():
        z = "local"  # 局部作用域
        print(z)      # 找到局部变量z
        print(y)      # 找到闭包变量y（当前函数没有→向外层查找）
        print(x)      # 找到全局变量x（闭包外层没有→向全局查找）
        print(len)    # 找到内置函数len
    
    inner()

outer()

第二步：认识闭包的基本结构
闭包需要满足三个条件：

1. 函数嵌套（外层函数包含内层函数）
2. 内层函数引用外层函数的变量
3. 外层函数返回内层函数（注意是函数对象本身，不是调用结果）

def outer_func(x):  # 外层函数，x是局部变量
    def inner_func(y):  # 内层函数
        return x + y    # 引用外层函数的变量x
    return inner_func   # 返回内层函数对象

closure = outer_func(10)  # outer_func执行完毕，但变量x(值为10)被保留
result = closure(5)       # 10 + 5 = 15
print(result)  # 输出15

第三步：理解闭包变量的生命周期
普通局部变量在函数执行结束后就会被销毁，但闭包中的自由变量会延长生命周期：

def counter():
    count = 0  # 普通局部变量，但被内层函数引用后成为闭包变量
    
    def increment():
        nonlocal count  # 声明count来自外层作用域
        count += 1
        return count
    
    return increment

# 创建两个独立的计数器
counter1 = counter()
counter2 = counter()

print(counter1())  # 1（counter1的count从0→1）
print(counter1())  # 2（counter1的count从1→2）
print(counter2())  # 1（counter2有自己独立的count变量，从0→1）

第四步：深入理解闭包变量的存储方式
闭包变量实际上存储在内层函数的__closure__属性中：

def make_closure(x):
    def closure_func():
        return x
    return closure_func

closure = make_closure(100)
print(closure())  # 100

# 查看闭包变量
print(closure.__closure__)  # 包含cell对象的元组
print(closure.__closure__[0].cell_contents)  # 100

第五步：闭包的经典应用场景

1. 函数工厂：创建功能相似但配置不同的函数

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

square = power_factory(2)  # 创建平方函数
cube = power_factory(3)    # 创建立方函数

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

2. 装饰器：基于闭包实现（这是之前讲过的装饰器的基础）

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

3. 状态保持：替代全局变量，提供更好的封装性

def bank_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    
    def withdraw(amount):
        nonlocal balance
        if amount <= balance:
            balance -= amount
            return balance
        else:
            return "余额不足"
    
    return deposit, withdraw

deposit, withdraw = bank_account(100)
print(deposit(50))   # 150
print(withdraw(30))  # 120

第六步：常见陷阱与注意事项

1. 延迟绑定问题：在循环中创建闭包时要小心

# 错误示例：所有闭包都引用同一个i
functions = []
for i in range(3):
    def func():
        return i
    functions.append(func)

print([f() for f in functions])  # [2, 2, 2] 不是预期的[0, 1, 2]

# 正确做法：使用默认参数或创建新的作用域
functions = []
for i in range(3):
    def func(x=i):  # 默认参数在定义时求值
        return x
    functions.append(func)

print([f() for f in functions])  # [0, 1, 2]

2. 修改闭包变量：需要使用nonlocal关键字

def counter():
    count = 0
    
    def increment():
        nonlocal count  # 必须声明才能修改
        count += 1
        return count
    
    return increment

闭包是Python中实现装饰器、回调函数、函数工厂等高级功能的基础机制，理解闭包有助于编写更优雅、灵活的代码。