引言

在 Python 编程语言中，闭包通常指的是一个嵌套函数，即在一个函数内部定义的另一个函数。这个嵌套的函数能够访问并保留其外部函数作用域中的变量。这种结构就构成了一个闭包。

闭包在函数式编程语言中非常普遍。在 Python 中，闭包特别有用，因为它使得你可以创建基于函数的装饰器，这是一种非常强大的功能。

通过本教程[1]，你将：

• 了解闭包的概念以及它们在 Python 中的运作方式
• 掌握闭包的典型应用场景
• 探索闭包的替代方法 为了更好地理解本教程，你需要对 Python 的一些基本概念有所了解，比如函数、嵌套函数、装饰器、类和可调用对象。

了解 Python 中的闭包

闭包是一种函数，它能够保持对其词法环境的访问，即使该函数在该环境之外被执行。当外部函数返回内部函数时，你将获得一个具有扩展作用域的函数对象。

换言之，闭包是能够捕获它们所处环境（即封闭作用域）中定义的对象的函数，这使得你可以在函数体内使用这些对象。这个特性让你在需要在连续调用之间保持状态信息时，可以利用闭包。

在那些以函数式编程为主的编程语言中，闭包是一种常见的特性，而 Python 也支持闭包，作为其众多特性之一。

在 Python 中，闭包是你在另一个函数内部定义并返回的函数。这个内部函数能够保留在它定义之前非局部作用域中定义的对象。

为了更深入地理解 Python 中的闭包，你首先需要了解内部函数，因为闭包本质上也是内部函数的一种。

内部函数

在 Python 中，内部函数是指在另一个函数内部定义的函数。这类函数可以访问和修改它们所处外部函数（即非局部作用域）中的变量名。

这里有一个简单的例子：

>>> def outer_func():
...     name = "Pythonista"
...     def inner_func():
...         print(f"Hello, {name}!")
...     inner_func()
...

>>> outer_func()
Hello, Pythonista!

>>> greeter = outer_func()
>>> print(greeter)
None

在这个示例中，你在全局范围内定义了 outer_func() 函数。在这个函数内部，你声明了一个名为 local 的局部变量。接着，你定义了另一个名为 inner_func() 的函数。由于这个函数定义在 outer_func() 函数体内，因此它是一个嵌套函数。最终，你调用了这个嵌套函数，它使用了在外部函数中定义的 name 变量。

当你执行 outer_func() 函数时，inner_func() 函数将 name 变量的值嵌入到问候语字符串中，并将其显示在你的屏幕上。

在上述示例中，你定义了一个能够访问封闭作用域中变量的嵌套函数。但是，当你调用外部函数时，你并没有获得对嵌套函数的引用。嵌套函数和局部变量在外部函数之外是不可见的。

在接下来的部分，你将学习如何将嵌套函数转变为闭包，这样你就可以访问嵌套函数和它保留的变量了。

函数闭包

并非所有的嵌套函数都是闭包，但所有的闭包都是嵌套函数。要将一个嵌套函数转变为闭包，你需要从外部函数返回这个嵌套函数的对象。这听起来可能有些拗口，但以下是如何让 outer_func() 函数返回一个闭包对象的方法：

>>> def outer_func():
...     name = "Pythonista"
...     def inner_func():
...         print(f"Hello, {name}!")
...     return inner_func
...

>>> outer_func()
<function outer_func.<locals>.inner_func at 0x1066d16c0>

>>> greeter = outer_func()

>>> greeter()
Hello, Pythonista!

在 outer_func() 函数的这个新版本中，你返回的是 inner_func 函数对象本身，而不是执行它。这样，当你执行 outer_func() 函数时，你将得到一个闭包对象，而不是一条问候信息。这个闭包对象能够记住 name 变量的值，即使 outer_func() 函数执行完毕后，你依然可以通过闭包访问这个值。这就是为什么当你调用 greeter() 函数时能够看到问候信息的原因。

• 创建一个 Python 闭包需要以下元素：

1. 一个外部或封闭函数：这个函数包含了另一个函数，通常称为内部函数。外部函数可以接收参数，并定义一些内部函数可以访问和修改的变量。
2. 仅在外部函数中有效的局部变量：这些变量定义在外部函数的作用域内。Python 会保留这些变量，使得即使在外部函数执行完毕后，你仍然可以在闭包中使用它们。
3. 一个内部或嵌套函数：这个函数定义在外部函数内部，它能够访问并修改外部函数中的变量，哪怕外部函数已经执行完毕。

在这个部分的例子中，你有一个外部函数、一个局部变量（name）和一个内部函数。要得到一个闭包对象，最后一步是从外部函数返回内部函数对象。

另外值得一提的是，你也可以使用 lambda 表达式来创建闭包：

>>> def outer_func():
...     name = "Pythonista"
...     return lambda: print(f"Hello, {name}!")
...

>>> greeter = outer_func()
>>> greeter()
Hello, Pythonista!

在 outer_func() 函数的这个修改版中，你通过使用 lambda 函数来创建闭包，其功能与原始版本相同。

捕获的变量

如你所了解的，闭包会保留其封闭作用域内的变量。以下是一个简单的示例：

>>> def outer_func(outer_arg):
...     local_var = "Outer local variable"
...     def closure():
...         print(outer_arg)
...         print(local_var)
...         print(another_local_var)
...     another_local_var = "Another outer local variable"
...     return closure
...

>>> closure = outer_func("Outer argument")

>>> closure()
Outer argument
Outer local variable
Another outer local variable

在这个示例中，当你执行 outer_func() 函数时，outer_arg、local_var 和 another_local_var 这些变量都会被绑定到闭包上，哪怕它们原来所在的环境已经不存在了。不过，closure() 函数能够访问这些变量，因为它们现在成为了闭包的一部分。这就是为什么我们说闭包是一个拥有扩展作用域的函数。

闭包同样可以修改这些变量的值，这会导致两种不同的情况：变量可能指向一个不可变对象或者一个可变对象。

如果你想修改指向不可变对象的变量的值，你需要使用 nonlocal 声明。以下是一个示例：

>>> def make_counter():
...     count = 0
...     def counter():
...         nonlocal count
...         count += 1
...         return count
...     return counter
...

>>> counter = make_counter()

>>> counter()
1
>>> counter()
2
>>> counter()
3

在这个示例中，count 变量保存了一个整数值的引用，而整数值是不可变的。如果你想更新 count 的值，就需要使用 nonlocal 声明，这告诉 Python 你希望在非局部作用域中重用这个变量。

当你的变量指向一个可变对象时，你可以直接修改这个变量的值：

>>> def make_appender():
...     items = []
...     def appender(new_item):
...         items.append(new_item)
...         return items
...     return appender
...

>>> appender = make_appender()

>>> appender("First item")
['First item']
>>> appender("Second item")
['First item', 'Second item']
>>> appender("Third item")
['First item', 'Second item', 'Third item']

在这个示例中，变量 items 指向一个列表对象，列表是可变的。因此，你无需使用 nonlocal 关键字，可以直接在原地修改这个列表。

利用闭包保持状态

在实际应用中，你可以在多种不同场合使用 Python 闭包。在本节中，你将了解如何利用闭包来创建工厂函数，跨函数调用保持状态，以及实现回调机制，这将使你的代码更加动态、灵活和高效。

创建工厂函数

你可以编写一些函数来生成带有初始配置或参数的闭包。这在你想要创建多个具有不同设置的相似函数时非常有用。

例如，假设你需要计算不同度数和结果精度的数值根。在这种情况下，你可以编写一个工厂函数，该函数返回预设了度数和精度的闭包，如下所示：

>>> def make_root_calculator(root_degree, precision=2):
...     def root_calculator(number):
...         return round(pow(number, 1 / root_degree), precision)
...     return root_calculator
...

>>> square_root = make_root_calculator(2, 4)
>>> square_root(42)
6.4807

>>> cubic_root = make_root_calculator(3)
>>> cubic_root(42)
3.48

make_root_calculator() 是一个工厂函数，用于生成计算不同数值根的函数。在这个函数中，你传入根的度数和期望的精度作为配置参数。

接着，你定义了一个内部函数，该函数接受一个数字作为输入，并计算出具有所需精度的特定根。最终，你返回这个内部函数，从而创建了一个闭包。

你可以利用这个函数来创建闭包，以便计算不同度数的数值根，例如平方根和立方根。需要注意的是，你还可以调整计算结果的精度。

构建有状态的函数

闭包可以用来在函数调用之间保持状态，这些函数被称为有状态函数，而闭包是实现它们的一种方法。

例如，假设你想编写一个函数，它从数据流中连续获取数值，并计算它们的累积平均值。在函数的多次调用之间，必须保留之前传递的值。在这种情况下，你可以使用如下所示的函数：

>>> def cumulative_average():
...     data = []
...     def average(value):
...         data.append(value)
...         return sum(data) / len(data)
...     return average
...

>>> stream_average = cumulative_average()

>>> stream_average(12)
12.0
>>> stream_average(13)
12.5
>>> stream_average(11)
12.0
>>> stream_average(10)
11.5

在 cumulative_average() 函数中，data 这个局部变量使得你能够在连续调用这个函数返回的闭包对象时保持状态。

然后，你创建了一个名为 stream_average() 的闭包，并用不同的数值来调用它。注意这个闭包是如何记住之前传入的值，并通过累加新提供的价值来计算平均值的。

提供回调函数

闭包在事件驱动编程中非常常见，当你需要创建携带额外上下文或状态信息的回调函数时就会用到。图形用户界面（GUI）编程是这类回调函数的一个典型应用场景。

例如，假设你想使用 Tkinter（Python 的标准 GUI 编程库）来创建一个显示 "Hello, World!" 的应用程序。这个应用程序需要一个标签来展示问候语，以及一个按钮来触发显示。以下是这个小程序的代码：

import tkinter as tk

app = tk.Tk()
app.title("GUI App")
app.geometry("320x240")

label = tk.Label(
    app,
    font=("Helvetica", 16, "bold"),
)
label.pack()

def callback(text):
    def closure():
        label.config(text=text)

    return closure

button = tk.Button(
    app,
    text="Greet",
    command=callback("Hello, World!"),
)
button.pack()

app.mainloop()

这段代码创建了一个简单的 Tkinter 应用，包含一个窗口，窗口里有一个标签和一个按钮。点击 "Greet" 按钮后，标签会展示 "Hello, World!" 的信息。

callback() 函数会返回一个闭包对象，这个对象可以用来设置按钮的命令参数。这个参数需要一个不接受任何参数的可调用对象。如果你需要像示例那样传递参数，那么可以使用闭包。

[1]Source: https://realpython.com/python-closure/