Python中闭包Closure的5个层次

理解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 "", line 1, in 
# 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))
# 
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__)  # (,)

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__)  # (,)

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

f()  # Zhang San

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

Python 没有像 public 或 private 这样的内置关键字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相对应的技术。在完全理解它之后，我们可以用它来编写更优雅的函数式风格的程序。