代码收藏家技术教程 2025-05-13

Python闭包（Closure）深度解析

文章目录

深入理解 Python 闭包（Closure）🔍

1. 什么是闭包？💡

1.1 闭包的特点

1.2 闭包的基本结构

2. 如何创建闭包？🛠️

2.1 代码解析

3. 为什么使用闭包？🎯

3.1 让变量持久化（模拟静态变量）

3.2 避免全局变量污染 🌎

3.3 用于回调函数

4. nonlocal 关键字 🔑

5. 闭包 vs. 全局变量 vs. 类 🆚

6. 结论 📝

深入理解 Python 闭包（Closure）🔍

闭包（Closure）是 Python 函数式编程中的一个重要概念，它允许内部函数访问外部函数的变量，即使外部函数已经执行完毕。这种特性可以用来保持状态、延迟计算等，在编写高阶函数、装饰器等场景中非常有用。

在本文中，我们将详细探讨闭包的概念、工作原理、应用场景，并结合代码示例加深理解。

1. 什么是闭包？💡

闭包是指 一个嵌套函数（内部函数），它可以访问外部函数的变量，即使外部函数已经执行完毕，这些变量仍然能被内部函数引用。

1.1 闭包的特点

嵌套函数：必须有一个内部函数（函数嵌套）。

访问外部变量：内部函数可以访问外部函数的变量，即使外部函数已经返回。

变量持久化：外部函数执行完毕后，变量不会被销毁，而是被内部函数“记住”。

1.2 闭包的基本结构

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function  # 返回内部函数

在这个例子中，inner_function() 是 outer_function() 内部定义的函数，并且 inner_function() 使用了 outer_function() 的变量 x。

2. 如何创建闭包？🛠️

我们可以通过一个示例来演示闭包的基本用法：

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function  # 返回内部函数

closure_func = outer_function(10)  # 创建闭包，x=10
print(closure_func(5))  # 10 + 5 = 15
print(closure_func(20)) # 10 + 20 = 30

2.1 代码解析

outer_function(10) 调用时，x 取值 10，返回 inner_function（但并未执行）。
closure_func(5) 这时 y 取值 5，计算 10 + 5 = 15。
closure_func(20) 这时 y 取值 20，计算 10 + 20 = 30。

核心点：即使 outer_function() 已经执行完毕，但 x=10 仍然被 closure_func() 记住，这就是闭包的特性。

3. 为什么使用闭包？🎯

3.1 让变量持久化（模拟静态变量）

闭包可以保持某些数据，即使外部函数已经执行完毕。

def counter():
    count = 0  # 变量保存在闭包中

    def increment():
        nonlocal count  # 使用 nonlocal 修改外部函数变量
        count += 1
        return count

    return increment

# 创建一个计数器
counter1 = counter()
print(counter1())  # 输出 1
print(counter1())  # 输出 2
print(counter1())  # 输出 3

# 创建另一个计数器，不受前一个影响
counter2 = counter()
print(counter2())  # 输出 1

关键点：

counter1() 调用后，count 变量仍然存储在闭包中，连续调用 counter1() 时，它的值会累加。

counter2() 是一个新的闭包，count 变量不会受到 counter1() 的影响。

3.2 避免全局变量污染 🌎

闭包提供了一种替代全局变量的方式，使得变量作用域局限于函数内部，避免了全局变量被意外修改的问题。

def multiplier(factor):
    def multiply(num):
        return num * factor
    return multiply

times2 = multiplier(2)  # 创建一个乘以2的闭包
times3 = multiplier(3)  # 创建一个乘以3的闭包

print(times2(5))  # 10
print(times3(5))  # 15

优势：

factor 变量仅存在于 multiplier() 的作用域内，不会影响其他代码。

times2() 和 times3() 各自保存了 factor 的不同值（2 和 3），互不影响。

3.3 用于回调函数

闭包在回调函数（Callback Function）中非常有用。例如，在事件处理、异步编程等场景下，我们可以通过闭包来保持状态。

def create_callback(message):
    def callback():
        print(f"Callback message: {message}")
    return callback

cb1 = create_callback("Hello")
cb2 = create_callback("Python")

cb1()  # 输出：Callback message: Hello
cb2()  # 输出：Callback message: Python

4. nonlocal 关键字 🔑

默认情况下，Python 内部函数不能直接修改外部函数的变量。如果要修改外部变量，需要使用 nonlocal 关键字。

def counter():
    count = 0

    def increment():
        nonlocal count  # 允许修改外部函数的变量
        count += 1
        return count

    return increment

count_func = counter()
print(count_func())  # 输出 1
print(count_func())  # 输出 2
print(count_func())  # 输出 3

作用：

nonlocal 允许 increment() 修改 count 变量。

如果不使用 nonlocal，count += 1 会导致 UnboundLocalError（因为 Python 认为 count 是 increment() 内部的局部变量）。

5. 闭包 vs. 全局变量 vs. 类 🆚

方法	特点	适用场景
全局变量	所有地方都可以访问，容易被意外修改	适合存储全局配置或共享数据
闭包	变量私有，避免污染，数据持久化	适合小型状态管理、回调函数
类（对象）	更复杂的状态管理，可扩展	适合更复杂的结构，如游戏、数据建模

示例：用类替代闭包

class Counter:
    def __init__(self):
        self.count = 0

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

counter1 = Counter()
print(counter1.increment())  # 输出 1
print(counter1.increment())  # 输出 2

什么时候用闭包？

只需要存储少量状态，不需要额外的方法时，闭包更简洁。

需要更强的扩展性、多个方法时，类更合适。