彻底理解Python中的闭包和装饰器（上）
什么是闭包
闭包（Closure）其实并不是Python独有的特性，很多语言都有对闭包的支持。（当然，因为Python是笔者除C/C++之外学习的第二门语言，所以也是第一次遇到闭包。）简而言之，闭包实际上就是——函数中定义的函数。
这种程序结构的主要作用是：使得函数中的局部变量可以常驻内存，即使在函数返回之后（函数生命期结束后）。在这个意义上它的作用与C++中的static静态变量类似，当然不完全相同。
Python中闭包的定义和使用
在Python中，一个典型的闭包可以这样定义：
def outer(arg):
temp = 10
def inner():
_sum = temp + arg # 内函数引用了外函数的局部变量
print('_sum =', _sum)
return _sum
return inner # 外函数返回了内函数的引用
在这里有两个嵌套的函数，不妨叫他们外函数和内函数。可以看到闭包有两个显著的特点：
- 内函数引用了外函数的局部变量。
- 外函数返回了内函数的引用（函数名）。
符合以上两点，Python解释器会认为这是一个闭包。这时如果外函数的生命期结束了，在外函数中创建的局部变量并不会像通常一样被销毁，而是会留在内存中。这样当下次调用内函数时，就能够继续使用这些局部变量。
通过下面的分析可以看到，调用内函数正是通过外函数返回的函数指针（Python中没有指针变量，出于C++习惯笔者认为把它称作指针比较易于理解，没有学过C/C++的读者理解成返回了内函数的地址即可）。
闭包代码分析
我们来仔细分析上面的代码。
如果读者有C/C++经验，那么理解起来将会轻松许多。C++严格的语法要求函数必须先定义再调用，在Python并没有不同。因此需要牢记一点：在代码段中，函数的定义是不会被执行的，在理解代码时def下的所有内容都先跳过，到调用函数时再回来看它。
按照这种阅读顺序，在外函数outer()中实际上只做了三件事情：
- 定义局部变量temp
- 定义内函数inner()
- 返回内函数inner，实际上是返回了内函数的指针。
调用这个闭包时，首先用一个变量保存函数对象（的指针）：
f = outer(2)
执行这句话时，就完成了上面所说的1~3条，f实际上是outer()返回的inner()的指针。注意，第2条只做了函数的定义，第3条只返回了函数的引用。完成这两件事的时候，实际上都还没有执行内函数inner()。所以执行这句代码后的输出为：
>
对，啥都没有。因为任何shell中进行输出的语句还没有被执行。这是透彻理解闭包非常重要的一点。忽略这一点很容易造成所谓的“闭包陷阱”。
那么如何调用内函数呢？就要用刚刚用来保存函数指针的变量f：
x = f()
print('x = ', x)
上面的两句代码，实际上通过函数指针f执行了内函数inner()。执行上面的所有代码，输出为：
_sum = 12
x = 12
再次强调：
直到使用函数指针调用内函数，内函数才会被执行。
需要说明，虽然在闭包中定义的局部变量常驻内存中，但在闭包外这些变量仍然是不可访问的。如上面的temp变量，只有通过函数指针f才可以访问，在函数外引用该变量会报错变量不存在。这与C++中的静态变量相同，即生命期比局部变量长，但可见性与局部变量相同。
修改闭包的局部变量
外函数中的局部变量虽然在内函数中可以引用（使用），但不能够重新赋值。
执行如下闭包函数：
def outer(arg):
temp = 10
def inner():
_sum = temp + arg
temp += 1 #在内函数中尝试改变temp的值
print('_sum = ', _sum)
return _sum
return inner
会报如下错误：
UnboundLocalError: local variable 'temp' referenced before assignment
这意味着对于内函数来说，外函数中的局部变量只是一个可以使用的常量，它不能被修改。如果在内函数中重新定义一个同名变量，那么它会屏蔽掉外函数中的变量，即优先使用“更局部”的变量。
这实际上是由Python本身的语法特性造成的。在Python中，一个函数可以任意读取全局数据，但要修改时必须符合如下条件之一：
- 全局变量使用global声明
- 全局变量是可变类型数据
在闭包中这一点是类似的。如果想要修改外函数中的变量，可以使用以下两种方法之一：
- 使用nonlocal声明变量
def outer(arg):
temp = 10
def inner():
nonlocal temp #用nonlocal声明变量，表示要到上一层变量空间寻找该变量
_sum = temp + arg
temp += 1 #此处修改temp的值，不会报错
print('_sum = ', _sum)
return _sum
return inner
f = outer(2)
x = f()
print('x = ', x)
x = f()
print('x = ', x)
代码执行输出为：
_sum = 12
x = 12
_sum = 13
x = 13
- 将变量改为可变类型数据，如list
def outer(arg):
temp = [10]
def inner():
# nonlocal temp
_sum = temp[0] + arg
temp[0] += 1
print('_sum = ', _sum)
return _sum
return inner
f = outer(2)
x = f()
print('x = ', x)
x = f()
print('x = ', x)
输出结果相同。
从以上代码也可以看出，闭包中常驻内存的局部变量只有一份。当重复调用内函数时，访问的是同一处变量。
闭包的参数
闭包的外函数和内函数都是函数，因此都可以接受参数，区别只在于参数是创建函数指针时传入，还是实际调用内函数时传入。
如果在创建函数指针时传入，那么该参数在之后的调用中都会保持原值。以本文最开始的闭包代码为例，传给外函数的参数arg，与在外函数中定义的局部变量temp地位是完全相同的。
相应地，传给内函数的参数则可以在每次调用的时候都不一样。执行如下代码：
def outer():
temp = 10
def inner(arg):
_sum = temp + arg
print('_sum = ', _sum)
return _sum
return inner
f = outer()
x = f(2)
print('x = ', x)
x = f(5)
print('x = ', x)
输出为：
_sum = 12
x = 12
_sum = 15
x = 15
闭包陷阱
引用廖雪峰教程中的例子：
def count():
fs = []
for i in range(1, 4):
def func():
return i*i
fs.append(func)
return fs
f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())
上面的闭包创建了一个函数的list，并将这个list返回。这样会造成闭包陷阱，编写者也许原来希望返回的是1、2、3的平方值，但实际上执行的结果是：
9
9
9
原因就是之前强调的，内函数的指针被创建时，它实际上还没有被执行。
在上面内函数的循环中，每次循环只做了一件事，创建一个函数func()的指针并放入list。当真正调用三个内函数时，局部变量i已经变成3了，因此三个函数的返回值都是3。
使用闭包时必须牢记：
不要返回任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量怎么办？这时候只能再嵌套一个函数并立即执行它，将函数参数绑定到循环变量的当前值。代码如下：
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
return fs
上面的代码实际上是两层嵌套的闭包。每次循环里，都使用当前的循环变量i立即调用了函数f(i)，它的意义是创建了函数指针并放入list。具体来说，是调用内层闭包的外函数，返回内层闭包的内函数指针。
当各个函数指针被创建时，已经将当前循环变量传入闭包。对于后续的操作来说，每一个内层闭包拥有独立且不变的局部变量。当外层闭包返回函数list时，也就避免了闭包陷阱。
小结
- 闭包的两个特征：内函数引用外函数的局部变量，外函数返回内函数的指针。
- 外函数指针被创建时，内函数未被执行，直到使用函数指针调用内函数才会被执行。
- 使用闭包时，不要返回任何循环变量或后续会发生变化的变量。
