Python 闭包（Closures）与非局部变量（Nonlocal）详解

Python 闭包（Closures）与非局部变量（Nonlocal）：一场关于记忆的奇妙之旅

各位观众，早上好！🌞 今天我们要踏上一段奇妙的旅程，去探索Python中两个让人心驰神往的概念：闭包（Closures）与非局部变量（Nonlocal）。 别担心，这可不是什么枯燥的理论课，而是一场关于函数如何“记住”过去，并把这份记忆带到未来的精彩故事。

想象一下，你是一个魔术师🎩，你有一个秘密盒子，这个盒子可以记住你放进去的任何东西。每次你打开盒子，你都能找到你之前放进去的东西，即使你已经走到了天涯海角，甚至换了个身份。闭包，就是Python函数界的“秘密盒子”，它能记住它出生环境中的一些变量，即使那个环境已经消失了。

准备好了吗？让我们开始这场关于记忆的奇妙之旅！

第一幕：函数的“身世之谜”

要理解闭包，我们首先要回到函数本身。 在Python中，函数是一等公民。 它们可以像变量一样被传递、赋值，甚至可以作为其他函数的返回值。 这点非常重要，因为它为闭包的诞生奠定了基础。

让我们看一个简单的例子：

def outer_function(x):
    def inner_function(y):
        return x + y
    return inner_function

my_func = outer_function(10)  # outer_function 返回 inner_function
print(my_func(5)) # 输出：15

在这个例子中，outer_function 返回了 inner_function。 关键在于，inner_function 引用了 outer_function 的参数 x。 当我们执行 my_func = outer_function(10) 的时候，outer_function 已经执行完毕，它的作用域应该消失了。 但是，inner_function 却“记住”了 x 的值 (10)，并在之后调用 my_func(5) 时，仍然可以使用它。 这就是闭包的魅力所在！

总结一下，要形成闭包，需要满足以下三个条件：

1. 必须有一个嵌套函数（即一个函数定义在另一个函数内部）。
2. 内部函数必须引用外部函数作用域中的变量。
3. 外部函数必须返回内部函数。

你可以把闭包想象成一个函数带着它“出生地”的一些“行李”。 这个“行李”就是它所引用的外部函数作用域中的变量。 即使“出生地”已经不在了，这个函数仍然可以带着它的“行李”到处旅行，并随时使用它们。

第二幕：闭包的“记忆”机制

那么，闭包是如何实现这种“记忆”功能的呢？ 这要归功于Python的作用域规则和函数对象的特性。

当一个函数被定义时，Python会创建一个函数对象，并将函数体、代码、以及一个指向其定义环境的指针一起存储起来。 这个指针指向的就是外部函数的作用域（或者更准确地说，是外部函数的作用域链）。

当内部函数被返回并赋值给 my_func 时，my_func 就变成了一个闭包。 这个闭包不仅包含了 inner_function 的代码，还包含了指向 outer_function 作用域的指针。 当我们调用 my_func(5) 时，Python会沿着这个指针找到 outer_function 的作用域，并从中取出 x 的值 (10)。

可以用下表来总结闭包的存储结构：

闭包对象 (my_func)	内容
函数代码	return x + y
指针	指向 outer_function 的作用域
x	10 (存储在 outer_function 的作用域中)

形象比喻：

你可以把闭包想象成一个寻宝猎人🗺️。 猎人有一个藏宝图（inner_function 的代码），藏宝图上标记着一个宝藏的位置（x 的位置）。 即使猎人离开了藏宝图最初所在的房间 (outer_function 的作用域)，他仍然可以凭借藏宝图找到宝藏。

第三幕：非局部变量（Nonlocal）：打破“只读”的魔咒

到目前为止，我们看到的闭包只能读取外部函数作用域中的变量，而不能修改它们。 这就像一个只能看不能摸的展览品，有点让人遗憾。 但是，Python为我们提供了 nonlocal 关键字，可以打破这个“只读”的魔咒。

nonlocal 关键字允许内部函数修改外部函数作用域中的变量。 让我们看一个例子：

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

my_counter = counter()
print(my_counter()) # 输出：1
print(my_counter()) # 输出：2
print(my_counter()) # 输出：3

在这个例子中，increment 函数使用了 nonlocal count 声明，告诉Python count 变量不是局部变量，而是外部函数 counter 作用域中的变量。 因此，increment 函数可以修改 count 的值，并且每次调用 my_counter()，count 的值都会递增。

注意：

• nonlocal 只能用于嵌套函数中，并且只能引用外部函数的变量，不能引用全局变量。
• 如果没有使用 nonlocal 声明，内部函数只能读取外部函数作用域中的变量，而不能修改它们。 如果尝试修改，Python会创建一个新的局部变量，而不是修改外部函数的变量。

形象比喻：

你可以把 nonlocal 想象成一把钥匙🔑。 只有拥有这把钥匙，你才能打开外部函数的“保险箱”，并修改里面的东西。 如果没有这把钥匙，你只能隔着玻璃看看里面的东西，而不能动手。

第四幕：闭包的应用场景：用记忆创造价值

闭包的应用场景非常广泛，它们可以帮助我们编写更简洁、更灵活的代码。

1. 数据封装和隐藏：

闭包可以用来创建私有变量，防止外部代码直接访问和修改。 这可以提高代码的安全性和可维护性。

def create_bank_account(initial_balance):
    balance = initial_balance
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            return "余额不足"
        balance -= amount
        return balance
    def get_balance():
        return balance

    return {
        'deposit': deposit,
        'withdraw': withdraw,
        'get_balance': get_balance
    }

account = create_bank_account(100)
print(account['deposit'](50))  # 输出：150
print(account['withdraw'](200)) # 输出：余额不足
print(account['get_balance']()) # 输出：150

# 尝试直接访问 balance 变量会报错
# print(account.balance) # AttributeError: 'dict' object has no attribute 'balance'

在这个例子中，balance 变量被封装在 create_bank_account 函数内部，外部代码无法直接访问它。 只能通过 deposit、withdraw 和 get_balance 函数来操作 balance。 这保证了数据的安全性。

2. 延迟计算：

闭包可以用来延迟计算，直到真正需要结果的时候才进行计算。 这可以提高程序的效率。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f = lazy_sum(1, 2, 3, 4, 5)
print(f()) # 输出：15  只有在调用 f() 的时候才会进行求和计算

在这个例子中，lazy_sum 函数返回一个闭包 sum，这个闭包包含了参数 args。 只有在调用 f() 的时候，才会进行求和计算。 如果不需要求和，就永远不会执行计算，从而节省了资源。

3. 函数装饰器：

闭包是实现函数装饰器的基础。 装饰器可以用来在不修改原函数代码的情况下，给函数添加额外的功能。 这是一种非常强大的编程技巧。 (装饰器本身又是一个更大的话题，我们今天就不展开了)

4. 状态保持：

闭包可以用来保持函数的状态。 例如，我们可以使用闭包来实现一个计数器，每次调用计数器函数，计数都会递增。 我们在前面的 counter() 函数已经展示了这一点。

5. 事件处理：

在GUI编程中，闭包可以用于绑定事件处理函数。 例如，我们可以使用闭包来创建一个按钮的点击事件处理函数，该函数可以访问按钮的一些属性。

总之，闭包是一种非常灵活和强大的编程工具，可以帮助我们编写更简洁、更易于维护的代码。

第五幕：闭包的“副作用”：小心甜蜜的陷阱

虽然闭包有很多优点，但也需要注意一些潜在的“副作用”。

1. 内存泄漏：

由于闭包会引用外部函数作用域中的变量，如果这些变量占用了大量的内存，并且闭包长期存在，就可能导致内存泄漏。 因此，在使用闭包时，需要注意避免引用不必要的变量。

2. 作用域陷阱：

在使用 nonlocal 关键字时，需要注意作用域的规则。 如果使用不当，可能会导致意想不到的结果。 例如，如果内部函数中定义了一个与外部函数同名的变量，并且没有使用 nonlocal 声明，那么内部函数会创建一个新的局部变量，而不是修改外部函数的变量。

3. 代码可读性：

过度使用闭包可能会降低代码的可读性。 因此，在使用闭包时，需要权衡其带来的好处和可读性的损失。 应该尽量使代码简洁明了，易于理解。

形象比喻：

闭包就像一种美味的甜点🍰。 它很诱人，但吃多了也会腻。 我们需要适量食用，才能享受到它的美味，而不会带来负面影响。

结语：掌握闭包，打开编程新世界的大门

恭喜各位！ 🎉 我们已经完成了这场关于闭包与非局部变量的奇妙之旅。 希望通过今天的讲解，大家对闭包有了更深入的理解。

闭包是Python中一个非常重要的概念，掌握它可以帮助我们编写更优雅、更高效的代码。 但是，在使用闭包时，也需要注意一些潜在的风险。 只有在充分理解其原理和适用场景的情况下，才能真正发挥闭包的威力。

现在，你已经拥有了开启Python高级编程世界的钥匙🔑之一。 去探索更广阔的编程天地吧！ 祝大家编程愉快！ 😊