Python中闭包Closure的5个层次

2023-12-29 14:32:53

理解Python中闭包的5个层次 (5 Levels of Understanding Closures in Python)


Python 中的函数Functions是 一等公民first-class citizens。这意味着我们可以像操作其他对象一样操作函数:

  • 将函数作为参数进行传递 Pass functions as arguments
  • 将函数赋值给变量 Assign a function to a variable
  • 从另一个函数返回一个函数(嵌套函数)Return a function from another function (nested functions)

在此基础上,Python 支持一种强大的技术:闭包closure

我们大多数人都听说过闭包,但要完全理解并很好地使用它并不容易。

幸运的是,这篇文章将逐层layer by layer揭开闭包closures的神秘面纱uncover the mystery。是时候泡一杯咖啡,好好享受这项技术了。

Level 0: 了解什么是闭包Closure

闭包closure是嵌套函数nested functions中的一个概念concept。让我们通过一个有趣的例子an interesting example来了解它:

def outer_func():
    leader = "Zhang San"

    def print_leader():
        print(leader)

    return print_leader

f = outer_func()
del outer_func

f()  # Zhang San

outer_func()
# Traceback (most recent call last):
#   File "<input>", line 1, in <module>
# NameError: name 'outer_func' is not defined

如果你还不了解闭包closures,上面的例子可能会让你很头疼。我们已经删除了 outer_func 函数function。但是, f() 仍然可以打印 “Zhang San”,它是 outer_func 函数function的局部变量local variable。为什么删除outer_func 函数后它的局部变量local variable仍然存在?

显然,这不是因为"Zhang San"是魔术师。这就是闭包技术 closure technique 的效果。

从操作上讲,闭包closure是将函数function与环境environment一起存储的记录record。(Wikipedia)

至于我们的例子,内部函数inner function print_leader 可以 “记住remember” 外部函数outer function中的变量variables。

简而言之,Python 中的闭包closure是一个能记住其外层作用域(封闭范围enclosing scope)内的值的函数function。

Level 1: 区分闭包Closures和嵌套函数Nested Functions

虽然闭包closures是嵌套函数nested functions的一部分,但嵌套函数nested functions并不一定是闭包closures。闭包closures的出现必须满足三个条件must meet three conditions:

  1. 有嵌套函数。There are nested functions.
  2. 内部函数必须使用其外部函数中定义的变量。The inner function must use variables defined in its outer function.
  3. 外部函数必须返回return内部函数。The outer function must return the inner function.

让我们稍微改变一下前面的例子:

def outer_func():
    leader = "Zhang San"

    def print_leader():
        print(leader)

    return print_leader() # Return The Result!

f = outer_func()
# Zhang San
print(type(f))
# <class 'NoneType'>
f()
# TypeError: 'NoneType' object is not callable

如上所示,如果我们返回内部函数的结果。不会发生闭包。 f 是一个 NoneType ,因为它没有接收到 print_leader 函数,而 print_leader 函数已经执行了。

Level 2: 了解如何获取封闭值

事实上,Python 中的每个函数function都有一个名为 __closure__ 的特殊属性special attribute,它存储了所有 “记住remembered” 的值。

def outer_func():
    leader = "Zhang San"

    def print_leader():
        print(leader)

    return print_leader

f = outer_func()
print(outer_func.__closure__)  # None

print(f.__closure__)  # (<cell at 0x7f6465878070: str object at 0x7f64657afd70>,)

print(f.__closure__[0].cell_contents)  # Zhang San

如上例所示, outer_func 不是闭包closure,其 __closure__ 属性attribute为 None 。另一方面, f__closure__ 包含一个单元格对象Cell Objects,用于保存 “记忆remembered” 的值。

Level 3: 实现无bug的闭包Closure

闭包并不容易实现,我们应该谨慎使用。

一个反面例子 A negative example

让我们看一个示例程序,它将在列表中保存三个函数并逐一运行它们以打印三个不同的偶数,预期打印的结果为 0 2 4:

def funcs_generator():
    funcs = []
    for i in range(3):
        def f():
            return i * 2
        funcs.append(f)
    return funcs

f1, f2, f3 = funcs_generator()
print(f1(), f2(), f3())  # 4 4 4

然而,我们发现无论我们调用哪个函数,它们都返回相同的结果4。上述示例的结果与预期不符。为什么三个函数打印的值都一样?

再次查看代码,我们可以看到,当我们真正在 print() 方法中运行 f1()f2()f3() 时,封闭的变量 enclosed variable i 已经等于 2。如果我们打印它们的 __closure__ 属性,结果如下:

def funcs_generator():
    funcs = []
    for i in range(3):
        def f():
            return i * 2
        funcs.append(f)
    return funcs

f1, f2, f3 = funcs_generator()
print(f1(), f2(), f3())  # 4 4 4

print(f1.__closure__[0].cell_contents)
# 2
print(f2.__closure__[0].cell_contents)
# 2
print(f3.__closure__[0].cell_contents)
# 2

我们通过访问函数对象的__closure__属性,可以查看它们所引用的闭包变量。我们发现,所有的函数都引用了同一个闭包变量,它的值为2。这是因为在for循环中,每个函数都引用了变量i,而i在循环结束后的值是2。因此,所有的函数都引用了同一个值为2的闭包变量。

根据上面的例子,我们可以提出一个很好的面试问题:如何修改代码,通过不同的函数打印三个不同的值?

解决方案如下:

def funcs_generator():
    funcs = []
    for i in range(3):
        def f(j = i):
            return j * 2
        funcs.append(f)
    return funcs

f1, f2, f3 = funcs_generator()
print(f1(), f2(), f3())
# 0 2 4
print(f1.__closure__)
# None
print(f2.__closure__)
# None
print(f3.__closure__)
# None

如上所示,我们使用变量 j 来接收参数 i ,结果与预期的一样!不过,这次这三个函数并不是闭包closures,因为它们不需要 “记住remember” 其外层作用域enclosing scope中的任何变量variables。

即,我们使用了一个默认参数j来保存变量i的值,这样,每个函数都有自己独立的变量j,从而避免了共享变量的问题。

回想一下 level 1 中提到的建立闭包closure的 3 个条件中的第二个条件:

内部函数必须使用外部函数中定义的变量。

在上例中,内部函数inner function中没有使用变量 variable i 。它只是将一个值作为参数argument传递给内部函数的参数parameter j 。因此,没有创建闭包closure。

从上述例子中吸取的教训

如果内部函数inner function引用了一些外层变量enclosing variables,而这些变量稍后会被修改,那么我们就要小心了。

Level 4: 巧妙地使用闭包

闭包closure是 Python 的高级武器advanced weapon。对于初学者来说,它可能有点难。但是,如果我们能完全理解它并熟练地使用它,它将会给我们带来很大的帮助。实际上,Python 中的装饰器decorators就是闭包的广泛应用。

在最后一关中,我们将介绍两个重要的技巧,帮助您掌握闭包。

使用 lambda 函数来简化代码

通过 lambda 函数,我们可以使前面的示例代码更加优雅:

"""example6.py"""
def outer_func():
    leader = "Zhang San"
    return lambda : print(leader)

f = outer_func()
print(outer_func.__closure__)  # None

print(f.__closure__)  # (<cell at 0x7f6465878070: str object at 0x7f64657afd70>,)

print(f.__closure__[0].cell_contents)  # Zhang San

f()  # Zhang San

闭包更有效地隐藏私有变量

Python 没有像 publicprivate 这样的内置关键字built-in keywords来控制变量的可访问性control the accessibility of variables。按照惯例By convention,我们使用双下划线double underscores来定义类的私有成员private member of a class。但 “私有private” 变量variable仍然可以被访问accessed。

有时,我们需要加强对隐藏变量hidden variable的保护。闭包Closures就能帮上忙!

example6.py 所示,在函数 f 中获取和更改 leader 变量的值比较困难。而 leader 变量variable则更加 “私有private”。

结论

Python 支持闭包closure,这是一种与函数式编程functional programming相对应的技术。在完全理解它之后,我们可以用它来编写更优雅的函数式风格的程序。

文章来源:https://blog.csdn.net/JENREY/article/details/135289533
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。