引言

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

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

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

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

用闭包编写装饰器

装饰器是 Python 中一个非常强大的功能，它允许你动态地修改函数的行为。在 Python 中，有两种类型的装饰器：

• 基于函数的装饰器
• 基于类的装饰器

基于函数的装饰器是一个函数，它接受一个函数对象作为参数，并返回另一个增加了额外功能的函数对象。这个返回的函数对象也是一个闭包。因此，在创建基于函数的装饰器时，你会用到闭包。

如你所知，装饰器可以在不修改函数内部代码的情况下改变函数的行为。实际上，基于函数的装饰器就是闭包。它们的特点是主要用来修改你传递给装饰器函数的函数行为。

这里有一个简单的装饰器示例，它在原有函数功能的基础上增加了额外的消息输出：

>>> def decorator(function):
...     def closure():
...         print("Doing something before calling the function.")
...         function()
...         print("Doing something after calling the function.")
...     return closure
...

在这个示例中，外层函数充当装饰器的角色。这个函数返回一个闭包对象，它通过增加额外的功能来改变被装饰的输入函数对象的原有行为。即便是在 decorator() 函数执行完毕后，闭包仍然能够对输入函数产生影响。

以下是你如何利用装饰器语法来动态地改变一个普通 Python 函数的行为：

>>> @decorator
... def greet():
...     print("Hi, Pythonista!")
...

>>> greet()
Doing something before calling the function.
Hi, Pythonista!
Doing something after calling the function.

在这个示例中，你通过 @decorator 来调整 greet() 函数的行为。请注意，现在调用 greet() 时，你不仅得到了它的基本功能，还额外获得了装饰器提供的功能。

利用闭包实现记忆化

缓存能够通过减少不必要的重复计算来提升算法的效率。记忆化是一种防止函数对相同输入多次执行的常用缓存技术。

记忆化的工作原理是将特定输入参数集的结果存储在内存中，之后在需要时直接引用这些结果。你可以利用闭包来实现记忆化。

在下面的示例中，你使用了一个装饰器——它本身也是一个闭包——来缓存一个假设的、计算成本高昂的函数的结果值：

>>> def memoize(function):
...     cache = {}
...     def closure(number):
...         if number not in cache:
...             cache[number] = function(number)
...         return cache[number]
...     return closure
...

在这个例子中，memoize() 函数接收一个函数对象作为参数，并返回一个新的闭包对象。这个内部函数仅对尚未处理的数字执行输入函数。已处理的数字及其输入函数的结果被存储在 cache 字典中，以供后续使用。

现在，假设你有一个如下的示例函数，它模拟了一个计算成本较高的操作：

>>> from time import sleep

>>> def slow_operation(number):
...     sleep(0.5)
...

该函数将代码的执行仅保留半秒，以模仿昂贵的操作。为此，您可以使用时间模块中的 sleep() 函数。 您可以使用以下代码测量函数的执行时间：

>>> from timeit import timeit

>>> timeit(
...     "[slow_operation(number) for number in [2, 3, 4, 2, 3, 4]]",
...     globals=globals(),
...     number=1,
... )
3.02610950000053

在这个代码片段中，你利用了 timeit 模块的 timeit() 函数来测量执行 slow_operation() 函数时，使用一系列值作为输入的耗时。处理六个输入值时，代码耗时略超过三秒。你可以通过跳过重复的输入值，并使用记忆化技术来提高这个计算过程的效率。

接下来，按照下面的例子使用 @memoize 装饰器来装饰 slow_operation() 函数。然后，执行计时代码：

>>> @memoize
... def slow_operation(number):
...     sleep(0.5)
...

>>> timeit(
...     "[slow_operation(number) for number in [2, 3, 4, 2, 3, 4]]",
...     globals=globals(),
...     number=1,
... )
1.5151869590008573

现在，由于采用了记忆化技术，相同代码的执行时间缩短了一半。这是因为 slow_operation() 函数不会对重复的输入值再次执行。

利用闭包实现封装

在面向对象编程（OOP）中，类提供了一种将数据和行为整合到单个实体中的机制。OOP 中的一个核心需求是数据封装，这一原则建议保护对象的数据不受外部干扰，并阻止直接访问。

在 Python 中，实现严格的数据封装可能比较困难，因为 Python 中并没有私有和公共属性的区分。相反，Python 通过命名约定来表明某个类成员是公开的还是非公开的。

你可以利用 Python 闭包来实现更严格的数据封装。闭包能够为数据创建一个私有的作用域，阻止用户直接访问这些数据，从而有助于保持数据的完整性并防止意外修改。

例如，假设你有一个如下的 Stack 类：

class Stack:
    def __init__(self):
        self._items = []

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

该 Stack 类将其数据存储在名为 ._items 的列表对象中，并实现常见的堆栈操作，例如入栈和出栈。 以下是如何使用此类：

>>> from stack_v1 import Stack

>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)

>>> stack.pop()
3

>>> stack._items
[1, 2]

你的类的基本功能已经实现了。但是，尽管 _items 属性被设计为非公开的，你依然可以通过点表示法来访问它的值，就像访问普通属性一样。这种做法使得数据封装变得困难，无法有效保护数据免受直接访问。

再次强调，闭包提供了一种实现更严格数据封装的方法。请看以下代码示例：

def Stack():
    _items = []

    def push(item):
        _items.append(item)

    def pop():
        return _items.pop()

    def closure():
        pass

    closure.push = push
    closure.pop = pop
    return closure

在这个示例中，你通过编写一个函数来创建一个闭包对象，而不是定义一个类。在这个函数内部，你定义了一个局部变量 _items，它将是你闭包对象的一部分。你将使用这个变量来保存栈的数据。接着，你定义了两个内部函数来执行栈的操作。

closure() 内部函数作为闭包的载体。在这个函数的基础上，你添加了 push() 和 pop() 函数。最终，你返回了最终的闭包对象。

你可以像使用 Stack 类一样使用 Stack() 函数。一个重要的不同点是，现在你无法访问 _items 属性：

>>> from stack_v2 import Stack

>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)

>>> stack.pop()
3

>>> stack._items
Traceback (most recent call last):
    ...
AttributeError: 'function' object has no attribute '_items'

Stack() 函数使你能够创建闭包，这些闭包的功能类似于 Stack 类的实例。但是，你无法直接访问 _items 属性，这增强了数据的封装性。

如果你非常讲究，可以使用一种高级技巧来访问 _items 属性的内容：

>>> stack.push.__closure__[0].cell_contents
[1, 2]

.__closure__ 属性会返回一个元组，其中包含了闭包中变量绑定的单元格。每个单元格对象都有一个名为 cell_contents 的属性，你可以通过它来获取单元格中的值。

即便有这种技巧可以访问闭包中的变量，但在 Python 代码中通常不会使用它。毕竟，如果你的目标是实现封装，为什么要去破坏它呢？

探索闭包的替代方案

到目前为止，你已经了解到 Python 闭包可以帮助解决一些问题。然而，理解闭包的内部工作原理可能比较困难，因此使用其他工具可能会让你的代码更容易理解。

你可以用一个实现了 .__call__() 特殊方法的类来替代闭包，这样的类可以创建出可调用的实例。所谓可调用实例，就是你可以像调用函数一样去调用的对象。

以 make_root_calculator() 工厂函数为例：

>>> 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

该函数返回在其扩展范围内保留 root_ Degree 和 precision 参数的闭包。您可以用以下类替换该工厂函数：

class RootCalculator:
    def __init__(self, root_degree, precision=2):
        self.root_degree = root_degree
        self.precision = precision

    def __call__(self, number):
        return round(pow(number, 1 / self.root_degree), self.precision)

这个类接收与 make_root_calculator() 相同的两个参数，并将它们设置为实例属性。

通过实现 .__call__() 方法，你将你的类实例转变为可调用的对象，这意味着你可以像调用普通函数一样调用这些实例。以下展示了如何利用这个类来创建类似于根计算函数的对象：

>>> from roots import RootCalculator

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

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

>>> cubic_root.root_degree
3

如你所看到的，RootCalculator 类的功能与 make_root_calculator() 函数大致相同。此外，你现在还能够访问如 root_degree 这样的配置参数。

总结

现在你已经了解到，闭包通常是在 Python 中定义在另一个函数内部的函数对象。闭包会捕获它们封闭作用域内定义的对象，并将这些对象与内部函数对象结合起来，形成一个具有扩展作用域的可调用对象。

你可以在多种情况下使用闭包，尤其是当你需要在连续函数调用间保持状态或编写装饰器时。因此，掌握如何使用闭包对 Python 开发者来说是一项宝贵的技能。

在本教程中，你学习了：

• 闭包是什么以及它们在 Python 中的工作原理
• 实际中何时可以运用闭包
• 可调用实例如何替代闭包 掌握了这些知识后，你可以开始在你的代码中创建和使用 Python 闭包，特别是如果你对函数式编程工具感兴趣的话。

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