共计 2994 个字符，预计需要花费 8 分钟才能阅读完成。
本文首发于：行者 AI
python中什么是闭包？闭包有什么用？为什么要用闭包？明天咱们就带着这 3 个问题来一步一步意识闭包。
闭包和函数紧密联系在一起，介绍闭包前有必要先介绍一些背景常识，诸如嵌套函数、变量的作用域等概念。
1. 作用域
作用域是程序运行时变量可被拜访的范畴，定义在函数内的变量是局部变量，局部变量的作用范畴只能是函数外部范畴内，它不能在函数外援用。
定义在模块最外层的变量是全局变量，它是全局范畴内可见的，当然在函数外面也能够读取到全局变量的。而在函数内部则不能够拜访局部变量。例如：
a = 1
def foo():
print(a) # 1 def foo():
print(a) # NameError: name 'num' is not defined 2. 嵌套函数
函数不仅能够定义在模块的最外层，还能够定义在另外一个函数的外部，像这种定义在函数外面的函数称之为嵌套函数 （nested function）。对于嵌套函数，它能够拜访到其外层作用域中申明的非部分（non-local） 变量，比方代码示例中的变量 a 能够被嵌套函数 printer 失常拜访。
def foo():
#foo 是外围函数
a = 1
# printer 是嵌套函数
def printer():
print(a)
printer()
foo() # 1那么有没有一种可能即便脱离了函数自身的作用范畴，局部变量还能够被拜访失去呢？
答案就是闭包！
咱们将上述函数改成高阶函数（承受函数为参数，或者把函数作为后果返回的函数是高阶函数）的写法。
def foo():
#foo 是外围函数
a = 1
# printer 是嵌套函数
def printer():
print(a)
return printer
x = foo()
x() # 1这段代码和后面例子的成果齐全一样，同样输入 1。不同的中央在于外部函数 printer 间接作为返回值返回了。
个别状况下，函数中的局部变量仅在函数的执行期间可用，一旦 foo() 执行过后，咱们会认为变量 a 将不再可用。然而，在这里咱们发现 foo 执行完之后，在调用 x 的时候a 变量的值失常输入了，这就是闭包的作用，闭包使得局部变量在函数外被拜访成为可能。
3. 闭包
人们有时会把闭包和匿名函数弄混。这是有历史起因的: 在函数外部定义函数 不常见，直到开始应用匿名函数才会这样做。而且，只有波及嵌套函数时才有闭包问题。因而，很多人是同时晓得这两个概念的。
其实，闭包指延长了作用域的函数，其中蕴含函数定义体中援用、然而不在定义体中定义的 非全局变量。函数是不是匿名的没有关系，要害是它能拜访定义体之外定义的非全局变量。
艰深来讲闭包，顾名思义，就是一个关闭的包裹，外面包裹着自在变量，就像在类外面定义的属性值一样，自在变量的可见范畴伴随包裹，哪里能够拜访到这个包裹，哪里就能够拜访到这个自在变量。那这个包裹是绑定在哪的呢？在上文代码追加一句打印：
def foo():
# foo 是外围函数
a = 1
# printer 是嵌套函数
def printer():
print(a)
return printer
x = foo()
print(x.__closure__[0].cell_contents) # 1 能够发现是在函数对象的 __closure__ 属性中，__closure__是一个元祖对象函数负责闭包绑定，即自在变量的绑定。该属性值通常是 None，如果这个函数是一个闭包的话，那么它返回的是一个由 cell 对象组成的元组对象。cell 对象的cell_contents 属性就是闭包中的自在变量。这解释了为什么局部变量脱离函数之后，还能够在函数之外被拜访的起因的，因为它存储在了闭包的 cell_contents 中了。
4. 闭包的益处
闭包防止了应用全局变量，此外，闭包容许将函数与其所操作的某些数据（环境）关连起来。这一点与面向对象编程是十分相似的，在面对象编程中，对象容许咱们将某些数据（对象的属性）与一个或者多个办法相关联。
一般来说，当对象中只有一个办法时，这时应用闭包是更好的抉择。来看一个计算均值的例子，如果有个名为 avg 的函数，它的作用是计算一直减少的系列值的均值; 例如，整个历史中 某个商品的均匀收盘价。每天都会减少新价格，因而平均值要思考至目前为止所有的价格，如下所示：
>>> avg(10) #10.0
>>> avg(11) #10.5
>>> avg(12) #11.0 在以往，咱们能够设计一个类：
class Averager():
def __init__(self):
self.series = []
def __call__(self, new_value):
self.series.append(new_value)
total = sum(self.series)
return total/len(self.series)
avg = Averager()
avg(10) #10.0
avg(11) #10.5
avg(12) #11.0这时候咱们应用闭包来实现。
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
avg(10) #10.0
avg(11) #10.5
avg(12) #11.0调用 make_averager 时，返回一个 averager 函数对象。每次调用 averager 时，它会把参数增加到列表中，而后计算以后平均值。这比用类来实现更优雅，此外装璜器也是基于闭包的一中利用场景。
5. 闭包的坑
看了上述闭包的解释你认为闭包也不过如此？理论应用中往往在不经意间就会掉入陷阱，看看上面的例子：
def create_multipliers():
return [lambda x: x * i for i in range(5)]
for multiplier in create_multipliers():
print(multiplier(2))
# 冀望输入 0, 2, 4, 6, 8
# 后果是 8, 8, 8, 8, 8咱们冀望是输入0, 2, 4, 6, 8。后果却是 8, 8, 8, 8, 8。为什么会呈现这问题呢？让咱们改下代码：
def create_multipliers():
multipliers = [lambda x: x * i for i in range(5)]
print([m.__closure__[0].cell_contents for m in multipliers])
create_multipliers() # [4, 4, 4, 4, 4] 能够看到函数绑定的 i 值都成了 4 即循环后最终 i 的取值，这是因为 Python 的闭包是提早绑定，这意味着闭包中用到的变量的值，是在外部函数被调用时查问失去的。
正确的应用形式是将 i 的值利用参数的形式进行传递：
def create_multipliers():
return [lambda x,i=i: x * i for i in range(5)]
s = create_multipliers()
for multiplier in s:
print(multiplier(2)) # 0, 2, 4, 6, 8
咱们利用默认参数来传递 i，同闭包一样默认参数是绑定在__defaults__ 属性上。
print([f.__defaults__ for f in s]) # [(0,), (1,), (2,), (3,), (4,)]