Python中的闭包指的是什么？

在 Python 中，闭包（Closure） 是指一个函数（称为 嵌套函数）可以访问并记住其外层函数（称为 封闭函数）的变量，即使外层函数已经执行完毕。闭包的核心特点是：

嵌套函数：一个函数内部定义了另一个函数。

引用外部变量：内部函数引用了外层函数的变量。

外层函数返回内层函数：外层函数将内层函数作为返回值返回，使得内层函数可以在外层函数执行结束后继续访问外层函数的变量。

闭包的示例
示例 1：简单的计数器

def make_counter():
    count = 0  # 外层函数的变量

    def counter():  # 嵌套函数（闭包）
        nonlocal count  # 声明 count 不是局部变量
        count += 1
        return count

    return counter  # 返回闭包函数

# 创建闭包
counter = make_counter()

# 调用闭包函数
print(counter())  # 输出 1
print(counter())  # 输出 2
print(counter())  # 输出 3

说明：

make_counter() 返回 counter 函数，counter 记住了 count 变量。

每次调用 counter() 都会修改并返回 count，即使 make_counter() 已经执行完毕。

示例 2：定制化的乘法器

def multiplier(factor):
    def multiply(number):  # 闭包函数
        return number * factor
    return multiply

# 创建不同的乘法器
double = multiplier(2)
triple = multiplier(3)

print(double(5))  # 输出 10 (5 * 2)
print(triple(5))  # 输出 15 (5 * 3)

说明：

multiplier(factor) 返回 multiply 函数，multiply 记住了 factor。

double 和 triple 是不同的闭包，各自保持自己的 factor。

示例 3：函数工厂（动态生成函数）

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

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

print(square(4))  # 输出 16 (4^2)
print(cube(4))    # 输出 64 (4^3)

说明：

power_factory 根据 exponent 动态生成不同的 power 函数。

闭包的应用场景
状态保持：替代全局变量，避免污染全局命名空间（如计数器）。

函数工厂：动态生成不同行为的函数（如 multiplier、power_factory）。

装饰器（Decorator）：Python 装饰器本质上就是闭包的应用。

回调函数：在事件驱动编程中，闭包可以记住上下文状态。

闭包 vs 类
闭包可以实现类似类的功能（封装数据和行为），但更轻量：

# 用类实现计数器
class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

counter = Counter()
print(counter())  # 1
print(counter())  # 2

对比：

闭包更简洁，适用于简单逻辑。

类更灵活，适用于复杂场景（如继承、魔术方法）。

注意事项
nonlocal 关键字：

如果闭包需要修改外层变量（如 count += 1），必须用 nonlocal 声明。

Python 3 引入 nonlocal，Python 2 中只能通过可变对象（如列表）间接修改。

变量查找规则（LEGB）：

Python 查找变量的顺序：Local → Enclosing（闭包）→ Global → Built-in。

总结
闭包是 Python 中强大的特性，它允许函数“记住”其定义时的上下文环境，常用于：

状态保持（替代全局变量）

动态生成函数（函数工厂）

实现装饰器

回调函数封装

理解闭包有助于写出更灵活、更模块化的代码！