Python闭包|你应该知道的常见用例（下）
## 引言
在 Python 编程语言中，闭包通常指的是一个嵌套函数，即在一个函数内部定义的另一个函数。这个嵌套的函数能够访问并保留其外部函数作用域中的变量。这种结构就构成了一个闭包。
闭包在函数式编程语言中非常普遍。在 Python 中，闭包特别有用，因为它使得你可以创建基于函数的装饰器，这是一种非常强大的功能。
通过[本教程](https://realpython.com/python-closure/ "Source")，你将：
- 了解闭包的概念以及它们在 Python 中的运作方式
- 掌握闭包的典型应用场景
- 探索闭包的替代方法 为了更好地理解本教程，你需要对 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 函数的行为：
```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()` 时，你不仅得到了它的基本功能，还额外获得了装饰器提供的功能。
## 利用闭包实现记忆化
缓存能够通过减少不必要的重复计算来提升算法的效率。记忆化是一种防止函数对相同输入多次执行的常用缓存技术。
记忆化的工作原理是将特定输入参数集的结果存储在内存中，之后在需要时直接引用这些结果。你可以利用闭包来实现记忆化。
在下面的示例中，你使用了一个装饰器——它本身也是一个闭包——来缓存一个假设的、计算成本高昂的函数的结果值：
```python
>>> def memoize(function):
... cache = {}
... def closure(number):
... if number not in cache:
... cache = function(number)
... return cache
... return closure
...
```
在这个例子中，`memoize()` 函数接收一个函数对象作为参数，并返回一个新的闭包对象。这个内部函数仅对尚未处理的数字执行输入函数。已处理的数字及其输入函数的结果被存储在 `cache` 字典中，以供后续使用。
现在，假设你有一个如下的示例函数，它模拟了一个计算成本较高的操作：
```python
>>> from time import sleep
>>> def slow_operation(number):
... sleep(0.5)
...
```
该函数将代码的执行仅保留半秒，以模仿昂贵的操作。为此，您可以使用时间模块中的 sleep() 函数。
您可以使用以下代码测量函数的执行时间：
```python
>>> from timeit import timeit
>>> timeit(
... "]",
... globals=globals(),
... number=1,
... )
3.02610950000053
```
在这个代码片段中，你利用了 `timeit` 模块的 `timeit()` 函数来测量执行 `slow_operation()` 函数时，使用一系列值作为输入的耗时。处理六个输入值时，代码耗时略超过三秒。你可以通过跳过重复的输入值，并使用记忆化技术来提高这个计算过程的效率。
接下来，按照下面的例子使用 `@memoize` 装饰器来装饰 `slow_operation()` 函数。然后，执行计时代码：
```python
>>> @memoize
... def slow_operation(number):
... sleep(0.5)
...
>>> timeit(
... "]",
... globals=globals(),
... number=1,
... )
1.5151869590008573
```
现在，由于采用了记忆化技术，相同代码的执行时间缩短了一半。这是因为 `slow_operation()` 函数不会对重复的输入值再次执行。
## 利用闭包实现封装
在面向对象编程（OOP）中，类提供了一种将数据和行为整合到单个实体中的机制。OOP 中的一个核心需求是数据封装，这一原则建议保护对象的数据不受外部干扰，并阻止直接访问。
在 Python 中，实现严格的数据封装可能比较困难，因为 Python 中并没有私有和公共属性的区分。相反，Python 通过命名约定来表明某个类成员是公开的还是非公开的。
你可以利用 Python 闭包来实现更严格的数据封装。闭包能够为数据创建一个私有的作用域，阻止用户直接访问这些数据，从而有助于保持数据的完整性并防止意外修改。
例如，假设你有一个如下的 Stack 类：
```python
class Stack:
def __init__(self):
self._items = []
def push(self, item):
self._items.append(item)
def pop(self):
return self._items.pop()
```
该 Stack 类将其数据存储在名为 ._items 的列表对象中，并实现常见的堆栈操作，例如入栈和出栈。
以下是如何使用此类：
```python
>>> from stack_v1 import Stack
>>> stack = Stack()
>>> stack.push(1)
>>> stack.push(2)
>>> stack.push(3)
>>> stack.pop()
3
>>> stack._items
```
你的类的基本功能已经实现了。但是，尽管 `_items` 属性被设计为非公开的，你依然可以通过点表示法来访问它的值，就像访问普通属性一样。这种做法使得数据封装变得困难，无法有效保护数据免受直接访问。
再次强调，闭包提供了一种实现更严格数据封装的方法。请看以下代码示例：
```python
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` 属性：
```python
>>> 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` 属性的内容：
```python
>>> stack.push.__closure__.cell_contents
```
`.__closure__` 属性会返回一个元组，其中包含了闭包中变量绑定的单元格。每个单元格对象都有一个名为 `cell_contents` 的属性，你可以通过它来获取单元格中的值。
即便有这种技巧可以访问闭包中的变量，但在 Python 代码中通常不会使用它。毕竟，如果你的目标是实现封装，为什么要去破坏它呢？
## 探索闭包的替代方案
到目前为止，你已经了解到 Python 闭包可以帮助解决一些问题。然而，理解闭包的内部工作原理可能比较困难，因此使用其他工具可能会让你的代码更容易理解。
你可以用一个实现了 `.__call__()` 特殊方法的类来替代闭包，这样的类可以创建出可调用的实例。所谓可调用实例，就是你可以像调用函数一样去调用的对象。
以 `make_root_calculator()` 工厂函数为例：
```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
```
该函数返回在其扩展范围内保留 root_ Degree 和 precision 参数的闭包。您可以用以下类替换该工厂函数：
```python
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__()` 方法，你将你的类实例转变为可调用的对象，这意味着你可以像调用普通函数一样调用这些实例。以下展示了如何利用这个类来创建类似于根计算函数的对象：
```python
>>> 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]