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 "<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:
- 有嵌套函数。There are nested functions.
- 内部函数必须使用其外部函数中定义的变量。The inner function must use variables defined in its outer function.
- 外部函数必须返回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 没有像 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相对应的技术。在完全理解它之后,我们可以用它来编写更优雅的函数式风格的程序。
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!