python闭包的作用

作者整理笔记，记录备查

1、变量作用域

#全局函数 def outfunc (): a = 'outvar' #局部函数 def infunc(): print(a) #调用局部函数 return infunc #调用全局函数 get_a = outfunc() get_a()  访问变量a的值 

以上infunc函数就形成了闭包，外部函数返回的不是一个具体的值，而是一个函数。一般情况下，返回的函数会赋值给一个变量，这个变量可以在后面被继续执行调用。

2、闭包的概念

维基百科：在一些语言中，在函数中可以（嵌套）定义另一个函数时，如果内部的函数引用了外部的函数的变量，则可能产生闭包。闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。
维基百科的定义要点如下：

• 定义：闭包就是能够读取外部函数内的变量的函数。
• 作用1：闭包将外层函数内的局部变量和外层函数的外部连接起来。
• 作用2：将外层函数的变量持久地保存在内存中。

计算一个数的 n 次幂，使用闭包实现：

#闭包函数，其中 exponent 称为自由变量 def nth_power(exponent): def exponent_of(base): return base  exponent return exponent_of # 返回值是 exponent_of 函数 square = nth_power(2) # 计算一个数的平方 cube = nth_power(3) # 计算一个数的立方 print(square(2)) # 计算 2 的平方 print(cube(2)) # 计算 2 的立方 

在上面程序中，外部函数 nth_power() 的返回值是函数 exponent_of()，而不是一个具体的数值。

需要注意的是，在执行完 square = nth_power(2) 和 cube = nth_power(3) 后，外部函数 nth_power() 的参数 exponent 会和内部函数 exponent_of 一起赋值给 squre 和 cube，这样在之后调用 square(2) 或者 cube(2) 时，程序就能顺利地输出结果，而不会报错说参数 exponent 没有定义。

3、闭包的作用

3.1 读取函数内部的变量

借用以下案例，实现给content加tag的功能：

def tag(tag_name): def add_tag(content): return "<{0}>{1} 
    ".format(tag_name, content) return add_tag content = 'Hello' add_tag = tag('a') print add_tag(content) # Hello add_tag = tag('b') print add_tag(content) # Hello 

具体使用什么tag_name要根据实际需求来定，对外部调用的接口已经确定，就是add_tag(content)，如果使用面向接口的方式，可以这样写:

def add_tag(tag_name,content): return "<{0}>{1} 
    ".format(tag_name, content) add_tag('a','Hello') # Hello 

上面程序确实可以实现相同的功能，不过使用闭包，在添加大量同类型的tag_name时，更加易读和方便，只需要传入content参数

3.2 让函数内部的局部变量始终保持在内存中

def create(pos=[0,0]): def go(direction, step): new_x = pos[0]+direction[0]*step new_y = pos[1]+direction[1]*step pos[0] = new_x pos[1] = new_y return pos return go player = create() print(player([1,0],10)) print(player([0,1],20)) print(player([-1,0],10))  [10, 0] [10, 20] [0, 20] 

这段代码中，player实际上就是闭包go函数的一个实例对象。

它一共运行了三次，第一次是沿X轴前进了10来到[10,0]，第二次是沿Y轴前进了20来到 [10, 20]，第三次是反方向沿X轴退了10来到[0, 20]。

这证明了，函数create中的局部变量pos一直保存在内存中，并没有在create调用后被自动清除。

为什么会这样呢？原因就在于create是go的父函数，而go被赋给了一个全局变量，这导致go始终在内存中，而go的存在依赖于create，因此create也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。

这个时候，闭包使得函数的实例对象的内部变量，变得很像一个类的实例对象的属性，可以一直保存在内存中，并不断的对其进行运算。

4、注意事项

使用闭包，需要注意几点：

4.1 内存消耗

4.2 使用场景

当要实现的功能比较简单的时候，可以用闭包。例如：

• 当我们的代码中函数比较少的时候，可以使用闭包。但是如果我们要实现很多功能，还是要使用类（OOP）
• 如果我们的对象中只有一个方法时，使用闭包是会比用类来实现更优雅。

这有点类似于，如果我们要实现比较简单的函数功能，通常使用 lambda 匿名函数比定义一个完整的function更加优雅，而且几乎不会损失可读性。类似的还有用列表解析式代替 for 循环。

4.3 闭包无法改变外部函数局部变量指向的内存地址

def outfunc (): x = 'outvar' #局部函数 def infunc(): x = 'invar' print('outer x before call inner:', x, 'at', id(x)) #调用局部函数 print('outer x before call inner:', x, 'at', id(x)) infunc() print('outer x before call inner:', x, 'at', id(x)) outfunc()   outer x before call inner: outvar at 80 # outvar inner x before call inner: invar at 04 # invar outer x before call inner: outvar at 80 # outvar 

可以看到，局部函数并没有改变外部函数中变量x的地址，这与函数的作用域有关。如果要让内层函数不仅可以访问，还可以修改外层函数的变量，那么需要用到nonlocal声明，使得内层函数不要在自己的命名空间创建新的x，而是操作外层函数命名空间的x

def outfunc (): x = 'outvar' #局部函数 def infunc(): nonlocal x x = 'invar' print('inner x before call inner:', x, 'at', id(x)) #调用局部函数 print('outer x before call inner:', x, 'at', id(x)) infunc() print('outer x before call inner:', x, 'at', id(x)) outfunc()  outer x before call inner: outvar at 80 # outvar inner x before call inner: invar at 04 # outvar outer x before call inner: invar at 04 # outvar地址改变 

infunc改变了 outfunc 中变量x的内存地址

4.4 返回函数引用循环变量

返回闭包时，返回函数不要引用任何循环变量，或者后续会发生变化的变量
以下循环想得到1，4，9，但结果显然没有实现

def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() print(f1(),f2(),f3())  9 9 9 

返回的函数并没有立刻执行，而是直到调用了f()才执行。因为在向列表中添加 func 的时候，i 的值没有固定到f的实例对象中，而仅是将计算公式固定到了实例对象中。等到了调用f1()、f2()、f3()的时候才去取 i的值，这时候循环已经结束，i 的值是3，所以结果都是9。

如果一定要使用循环，需要再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变

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 f1, f2, f3 = count()  1 4 9 

5、闭包的__closure__属性

闭包比普通的函数多了一个 closure 属性，该属性记录着自由变量的地址。当闭包被调用时，系统就会根据该地址找到对应的自由变量，完成整体的函数调用。

def nth_power(exponent): def exponent_of(base): return base  exponent return exponent_of square = nth_power(2) #查看 __closure__ 的值 print(square.__closure__) # ( 
    
      ,)