引言
在 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 闭包,特别是如果你对函数式编程工具感兴趣的话。
Source: https://realpython.com/python-closure/
本文由 mdnice 多平台发布