python 闭包理解与应用

一、概念介绍

闭包并不只是一个python中的概念，在函数式编程语言中应用较为广泛。理解python中的闭包一方面是能够正确的使用闭包，另一方面可以好好体会和思考闭包的设计思想。

首先看一下维基上对闭包的解释：

在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）或函数闭包（function closures），是引用了自由变量
的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其
相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

另一种更容易理解的解释：

在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包

函数在内存中运行的理解：

程序被加载到内存执行时，函数定义的代码被存放在代码段中。函数被调用时，会在栈上创建其执行环境，也就是初始化其中定义的变量和外部
传入的形参以便函数进行下一步的执行操作。当函数执行完成并返回函数结果后，函数栈帧便会被销毁掉。函数中的临时变量以及存储的中间计算
结果都不会保留。下次调用时唯一发生变化的就是函数传入的形参可能会不一样。函数栈帧会重新初始化函数的执行环境。C++中有static关键字，函数中的 static 关键字定义的变量独立于函数之外，而且会保留函数中值的变化。函数中使用的全局变量也有类似的
性质。

二、代码认识闭包

2.1、参数在内函数中

def outer_func():loc_list = []def inner_func(name):loc_list.append(len(loc_list) + 1)print '%s loc_list = %s' %(name, loc_list)return inner_func# 闭包函数的调用需要首先实例化
clo_func_0 = outer_func()
clo_func_0('clo_func_0')
clo_func_0('clo_func_0')
clo_func_0('clo_func_0')
clo_func_1 = outer_func()
clo_func_1('clo_func_1')
clo_func_0('clo_func_0')
clo_func_1('clo_func_1')# 运行结果
clo_func_0 loc_list = [1]
clo_func_0 loc_list = [1, 2]
clo_func_0 loc_list = [1, 2, 3]
clo_func_1 loc_list = [1]
clo_func_0 loc_list = [1, 2, 3, 4]
clo_func_1 loc_list = [1, 2]

从上面这个简单的例子应该对闭包有一个直观的理解了。运行的结果也说明了闭包函数中引用的父函数中local variable既不具有C++中的全局变量的性质也没有static变量的行为。

在python中我们称上面的这个loc_list为闭包函数inner_func的一个自由变量(free variable)。

在这个例子中我们至少可以对闭包中引用的自由变量有如下的认识：

闭包中的引用的自由变量只和具体的闭包有关联，闭包的每个实例引用的自由变量互不干扰。
一个闭包实例对其自由变量的修改会被传递到下一次该闭包实例的调用。

2.2、参数在外函数中

#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):b = 10# inner是内函数def inner():#在内函数中 用到了外函数的临时变量print(a+b)# 外函数的返回值是内函数的引用return innerif __name__ == '__main__':# 在这里我们调用外函数传入参数5# 此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo# 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数demo = outer(5)# 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量# demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数demo() # 15demo2 = outer(7)demo2()#17

外函数返回了内函数的引用：

引用是什么？在python中一切都是对象，包括整型数据1，函数，其实是对象。

当我们进行a=1的时候，实际上在内存当中有一个地方存了值1，然后用a这个变量名存了1所在内存位置的引用。引用就好像c语言里的指针，大家可以把引用理解成地址。a只不过是一个变量名字，a里面存的是1这个数值所在的地址，就是a里面存了数值1的引用。

相同的道理，当我们在python中定义一个函数def demo(): 的时候，内存当中会开辟一些空间，存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字，它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo， y = demo，这样的操作就相当于，把demo里存的东西赋值给x和y，这样x 和y 都指向了demo函数所在的引用，在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ，调用的实际上根本就是一个函数，x、y和demo三个变量名存了同一个函数的引用。

返回内函数的引用：对于闭包，在外函数outer中最后return inner，我们在调用外函数 demo = outer() 的时候，outer返回了inner，inner是一个函数的引用，这个引用被存入了demo中。所以接下来我们再进行demo() 的时候，相当于运行了inner函数。

同时我们发现，一个函数，如果函数名后紧跟一对括号，相当于现在我就要调用这个函数，如果不跟括号，相当于只是一个函数的名字，里面存了函数所在位置的引用。

外函数把临时变量绑定给内函数：

按照我们正常的认知，一个函数结束的时候，会把自己的临时变量都释放还给内存，之后变量都不存在了。一般情况下，确实是这样的。但是闭包是一个特别的情况。外部函数发现，自己的临时变量会在将来的内部函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了，调用内函数的时候仍然能够使用外函数的临时变量。

在我编写的实例中，我两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次，我们发现调用的时候，内部函数是能识别外函数的临时变量是不一样的。python中一切都是对象，虽然函数我们只定义了一次，但是外函数在运行的时候，实际上是按照里面代码执行的，外函数里创建了一个函数，我们每次调用外函数，它都创建一个内函数，虽然代码一样，但是却创建了不同的对象，并且把每次传入的临时变量数值绑定给内函数，再把内函数引用返回。虽然内函数代码是一样的，但其实，我们每次调用外函数，都返回不同的实例对象的引用，他们的功能是一样的，但是它们实际上不是同一个函数对象。

2.3、闭包中内函数修改外函数局部变量

在闭包内函数中，我们可以随意使用外函数绑定来的临时变量，但是如果我们想修改外函数临时变量数值的时候发现出问题了！

在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:

1 global 声明全局变量

2 全局变量是可变类型数据的时候可以修改

在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候：

1、在python3中，可以用 nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。
2、在python2中，没有 nonlocal 这个关键字，我们可以把闭包变量改成可变类型数据进行修改，比如列表。

#修改闭包变量的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):b = 10  # a和b都是闭包变量c = [a] #这里对应修改闭包变量的方法2# inner是内函数def inner():#内函数中想修改闭包变量# 方法1 nonlocal关键字声明nonlocal  bb+=1# 方法二，把闭包变量修改成可变数据类型 比如列表c[0] += 1print(c[0])print(b)# 外函数的返回值是内函数的引用return innerif __name__ == '__main__':demo = outer(5)demo() # 6  11

还有一点需要注意：使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用，虽然每次调用内函数，是开启一个函数执行过后消亡，但是闭包变量实际上只有一份，每次开启内函数都在使用同一份闭包变量

#coding:utf8
def outer(x):def inner(y):nonlocal xx+=yreturn xreturn innera = outer(10)
print(a(1)) //11
print(a(3)) //14

两次分别打印出11和14，由此可见，每次调用inner的时候，使用的闭包变量x实际上是同一个。

三、闭包的陷阱

错误例子：

def my_func(*args):fs = []for i in xrange(3):def func():return i * ifs.append(func)return fsfs1, fs2, fs3 = my_func()
print fs1()
print fs2()
print fs3()

上面这段代码可谓是典型的错误使用闭包的例子。程序的结果并不是我们想象的结果0，1，4。实际结果全部是4。

这个例子中，my_func返回的并不是一个闭包函数，而是一个包含三个闭包函数的一个list。这个例子中比较特殊的地方就是返回的所有闭包函数均引用父函数中定义的同一个自由变量。

但这里的问题是为什么for循环中的变量变化会影响到所有的闭包函数？尤其是我们上面刚刚介绍的例子中明明说明了同一闭包的不同实例中引用的自由变量互相没有影响的。而且这个观点也绝对的正确。

那么问题到底出在哪里？应该怎样正确的分析这个错误的根源。

其实问题的关键就在于在返回闭包列表fs之前for循环的变量的值已经发生改变了，而且这个改变会影响到所有引用它的内部定义的函数。因为在函数my_func返回前其内部定义的函数并不是闭包函数，只是一个内部定义的函数。

当然这个内部函数引用的父函数中定义的变量也不是自由变量，而只是当前block中的一个local variable。

1 def my_func(*args):
2     fs = []
3     j = 0
4     for i in xrange(3):
5         def func():
6             return j * j
7         fs.append(func)
8     j = 2
9     return fs

上面的这段代码逻辑上与之前的例子是等价的。这里或许更好理解一点，因为在内部定义的函数func实际执行前，对局部变量j的任何改变均会影响到函数func的运行结果。

函数my_func一旦返回，那么内部定义的函数func便是一个闭包，其中引用的变量j成为一个只和具体闭包相关的自由变量。后面会分析，这个自由变量存放在Cell对象中。

使用lambda表达式重写这个例子：

1 def my_func(*args):
2     fs = []
3     for i in xrange(3):
4         func = lambda : i * i
5         fs.append(func)
6     return fs

经过上面的分析，我们得出下面一个重要的经验：返回闭包中不要引用任何循环变量，或者后续会发生变化的变量。

这条规则本质上是在返回闭包前，闭包中引用的父函数中定义变量的值可能会发生不是我们期望的变化。

正确的写法：

1 def my_func(*args):
2     fs = []
3     for i in xrange(3):
4         def func(_i = i):
5             return _i * _i
6         fs.append(func)
7     return fs

或者：

1 def my_func(*args):
2     fs = []
3     for i in xrange(3):
4         func = lambda _i = i : _i * _i
5         fs.append(func)
6     return fs

正确的做法便是将父函数的local variable赋值给函数的形参。函数定义时，对形参的不同赋值会保留在当前函数定义中，不会对其他函数有影响。

另外注意一点，如果返回的函数中没有引用父函数中定义的local variable，那么返回的函数不是闭包函数。

四、使用闭包注意事项

4.1、闭包中是不能直接修改外部作用域的局部变量的，具体修改办法见2.3

def foo():m = 0def foo1():m = 1print mprint mfoo1()print mfoo()
0
1
0

从执行结果可以看出，虽然在闭包里面也定义了一个变量m，但是其不会改变外部函数中的局部变量m。

4.2、以下这段代码是在python中使用闭包时一段经典的错误代码

def foo():a = 1def bar():a = a + 1return areturn bar

这段程序的本意是要通过在每次调用闭包函数时都对变量a进行递增的操作。但在实际使用时

>>> c = foo()
>>> print c()
Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in bar
UnboundLocalError: local variable 'a' referenced before assignment

这是因为在执行代码 c = foo()时，python会导入全部的闭包函数体bar()来分析其的局部变量，python规则指定所有在赋值语句左面的变量都是局部变量，则在闭包bar()中，变量a在赋值符号"="的左面，被python认为是bar()中的局部变量。再接下来执行print c()时，程序运行至a = a + 1时，因为先前已经把a归为bar()中的局部变量，所以python会在bar()中去找在赋值语句右面的a的值，结果找不到，就会报错。解决的方法很简单

def foo(): a = [1] def bar(): a[0] = a[0] + 1 return a[0] return bar

只要将a设定为一个容器就可以了。这样使用起来多少有点不爽，所以在python3以后，在a = a + 1 之前，使用语句nonlocal a就可以了，该语句显式的指定a不是闭包的局部变量。

4.3、还有一个容易产生错误的事例也经常被人在介绍python闭包时提起，我一直都没觉得这个错误和闭包有什么太大的关系，但是它倒是的确是在python函数式编程是容易犯的一个错误，我在这里也不妨介绍一下。先看下面这段代码

for i in range(3): print i

在程序里面经常会出现这类的循环语句，Python的问题就在于，当循环结束以后，循环体中的临时变量i不会销毁，而是继续存在于执行环境中。还有一个python的现象是，python的函数只有在执行时，才会去找函数体里的变量的值。

flist = []
for i in range(3): def foo(x): print x + i flist.append(foo)
for f in flist: f(2)

可能有些人认为这段代码的执行结果应该是2,3,4.但是实际的结果是4,4,4。这是因为当把函数加入flist列表里时，python还没有给i赋值，只有当执行时，再去找i的值是什么，这时在第一个for循环结束以后，i的值是2，所以以上代码的执行结果是4,4,4.
解决方法也很简单，改写一下函数的定义就可以了。

flist = []
for i in range(3):def foo(x,y=i):print x + yflist.append(foo)for f in flist:f(2)

五、闭包的作用

5.1、当闭包执行完后，仍然能够保持住当前的运行环境。

比如说，如果你希望函数的每次执行结果，都是基于这个函数上次的运行结果。我以一个类似棋盘游戏的例子来说明。假设棋盘大小为50*50，左上角为坐标系原点(0,0)，我需要一个函数，接收2个参数，分别为方向(direction)，步长(step)，该函数控制棋子的运动。棋子运动的新的坐标除了依赖于方向和步长以外，当然还要根据原来所处的坐标点，用闭包就可以保持住这个棋子原来所处的坐标。

origin = [0, 0]  # 坐标系统原点
legal_x = [0, 50]  # x轴方向的合法坐标
legal_y = [0, 50]  # y轴方向的合法坐标 def create(pos=origin):def player(direction, step):# 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等 # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。 new_x = pos[0] + direction[0] * stepnew_y = pos[1] + direction[1] * steppos[0] = new_xpos[1] = new_y# 注意！此处不能写成 pos = [new_x, new_y]，原因在上文有说过 return posreturn playerplayer = create()  # 创建棋子player，起点为原点
print player([1, 0], 10)  # 向x轴正方向移动10步
print player([0, 1], 20)  # 向y轴正方向移动20步
print player([-1, 0], 10)  # 向x轴负方向移动10步

输出为：

[10, 0]
[10, 20]
[0, 20]

5.2、闭包可以根据外部作用域的局部变量来得到不同的结果，

这有点像一种类似配置功能的作用，我们可以修改外部的变量，闭包根据这个变量展现出不同的功能。比如有时我们需要对某些文件的特殊行进行分析，先要提取出这些特殊行。

def make_filter(keep):def the_filter(file_name):file = open(file_name)lines = file.readlines()file.close()filter_doc = [i for i in lines if keep in i]return filter_docreturn the_filter

如果我们需要取得文件"result.txt"中含有"pass"关键字的行，则可以这样使用例子程序

filter = make_filter("pass")
filter_result = filter("result.txt")

六、闭包的应用

6.1、装饰器

自由变元可以记录闭包函数被调用的信息，以及闭包函数的一些计算结果中间值。而且被自由变量记录的值，在下次调用闭包函数时依旧有效。此处以装饰器为例介绍一下闭包的应用。

如果我们想对一个函数或者类进行修改重定义，最简单的方法就是直接修改其定义。但是这种做法的缺点也是显而易见的：

可能看不到函数或者类的定义
会破坏原来的定义，导致原来对类的引用不兼容
如果多人想在原来的基础上定制自己函数，很容易冲突

使用闭包可以相对简单的解决上面的问题，下面看一个例子：

def func_dec(func):def wrapper(*args):if len(args) == 2:func(*args)else:print 'Error! Arguments = %s'%list(args)return wrapper@func_dec
def add_sum(*args):print sum(args)# add_sum = func_dec(add_sum)
args = range(1,3)
add_sum(*args)

对于上面的这个例子，并没有破坏add_sum函数的定义，只不过是对其进行了一层简单的封装。如果看不到函数的定义，也可以对函数对象进行封装，达到相同的效果(即上面注释掉的13行)，而且装饰器是可以叠加使用的。

潜在的问题

但闭包的缺点也是很明显的，那就是经过装饰器装饰的函数或者类不再是原来的函数或者类了。这也是使用装饰器改变函数或者类的行为与直接修改定义最根本的差别。

实际应用的时候一定要注意这一点，下面看一个使用装饰器导致的一个很隐蔽的问题。

def counter(cls):obj_list = []def wrapper(*args, **kwargs):new_obj = cls(*args, **kwargs)obj_list.append(new_obj)print "class:%s'object number is %d" % (cls.__name__, len(obj_list))return new_objreturn wrapper@counter
class my_cls(object):STATIC_MEM = 'This is a static member of my_cls'def __init__(self, *args, **kwargs):print self, args, kwargsprint my_cls.STATIC_MEM

这个例子中我们尝试使用装饰器来统计一个类创建的对象数量。当我们创建my_cls的对象时，会发现something is wrong!

Traceback (most recent call last):File "G:\Cnblogs\Alpha Panda\Main.py", line 360, in <module>my_cls(1,2, key = 'shijun')File "G:\Cnblogs\Alpha Panda\Main.py", line 347, in wrappernew_obj = cls(*args, **kwargs)File "G:\Cnblogs\Alpha Panda\Main.py", line 358, in __init__print my_cls.STATIC_MEM
AttributeError: 'function' object has no attribute 'STATIC_MEM'

如果对装饰器不是特别的了解，可能会对这个错误感到诧异。经过装饰器修饰后，我们定义的类my_cls已经成为一个函数。

my_cls.__name__ == 'wrapper' and type(my_cls) is types.FunctionType

my_cls被装饰器counter修饰，等价于 my_cls = counter(my_cls)。

显然在上面的例子中，my_cls.STATIC_MEM是错误的，正确的用法是self.STATIC_MEM。

对象中找不到属性的话，会到类空间中寻找，因此被装饰器修饰的类的静态属性是可以通过其对象进行访问的。虽然my_cls已经不是类，但是其调用返回的值却是被装饰之前的类的对象。

该问题同样适用于staticmethod。那么有没有方法得到原来的类呢？当然可以，my_cls().__class__便是被装饰之前的类的定义。

那有没有什么方法能让我们还能通过my_cls来访问类的静态属性，答案是肯定的。

def counter(cls):obj_list = []@functools.wraps(cls)def wrapper(*args, **kwargs):... ...return wrapper

改写装饰器counter的定义，主要是对wrapper使用functools进行了一次包裹更新，使经过装饰的my_cls看起来更像装饰之前的类或者函数。该过程的主要原理就是将被装饰类或者函数的部分属性直接赋值到装饰之后的对象。如WRAPPER_ASSIGNMENTS（name, module and doc, ）和WRAPPER_UPDATES（dict）等。但是该过程不会改变wrapper是函数这样一个事实。

my_cls.__name__ == 'my_cls' and type(my_cls) is types.FunctionType

6.2、单例模式

七、参考文档：

1、https://www.cnblogs.com/yssjun/p/9887239.html

2、https://www.cnblogs.com/s-1314-521/p/9763376.html

3、https://www.jb51.net/article/54498.htm