Python闭包

举例:

# -*-( coding: utf-8 -*
def fa(m):
def fb(n):
return m+n;
return fb;

a=10;
b=20;
print fa(a)(b);

>>>30

一、定义

python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).这个定义是相对直白的，好理解的，不像其他定义那样学究味道十足（那些学究味道重的解释，在对一个名词的解释过程中又充满了一堆让人抓狂的其他陌生名词，不适合初学者）。下面举一个简单的例子来说明。

?

1

2

3

4

5

6

7

8

9

10

>>>defaddx(x):

>>>defadder(y): return x +y

>>>returnadder

>>> c=addx(8)

>>>type(c)

<type'function'>

>>> c.__name__

'adder'

>>> c(10)

18

结合这段简单的代码和定义来说明闭包：
如果在一个内部函数里：adder(y)就是这个内部函数，
对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域addx里面，但不在全局作用域里，
则这个内部函数adder就是一个闭包。

再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，adder就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。

二、使用闭包注意事项

1.闭包中是不能修改外部作用域的局部变量的

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

>>>deffoo():

...  m=0

... deffoo1():

...   m=1

...  printm

...

... printm

...  foo1()

... printm

...

>>> foo()

0

1

0

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

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

?

1

2

3

4

5

6

deffoo():

 a=1

 defbar():

  a=a +1

  returna

 returnbar

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

?

1

2

3

4

5

6

>>> c=foo()

>>>printc()

Traceback (most recent call last):

 File"<stdin>", line1,in<module>

 File"<stdin>", line4,inbar

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的值，结果找不到，就会报错。解决的方法很简单

?

1

2

3

4

5

6

deffoo():

 a=[1]

 defbar():

  a[0]=a[0]+1

  returna[0]

 returnbar

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

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

?

1

2

fori in range(3):

 printi

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

?

1

2

3

4

5

6

flist=[]

fori in range(3):

 deffoo(x):print x +i

 flist.append(foo)

forf in flist:

 f(2)

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

?

1

2

3

fori in range(3):

 deffoo(x,y=i):printx +y

 flist.append(foo)

三、作用

说了这么多，不免有人要问，那这个闭包在实际的开发中有什么用呢？闭包主要是在函数式开发过程中使用。以下介绍两种闭包主要的用途。

用途1：当闭包执行完后，仍然能够保持住当前的运行环境。

闭包无法修改外部函数的局部变量。这个是什么意思呢？

def outerFunc():    x = 0    def innerFunc():        x = 1        print('inner x:',x)    print('outer x before call inner:',x)    innerFunc()    print('outer x after call inner:',x)outerFunc()
1
2
3
4
5
6
7
8
9
10

如果innerFunc可以修改x的值的话，x的值前后会发生变化，但结果是：

outer x before call inner: 0inner x: 1outer x after call inner: 0
1
2
3

在innerFunc中x的值发生了改变，但是在outerFunc中x的值并未发生变化。

python循环中不包含域的概念。

flist = []for i in range(3):    def func(x):        return x*i    flist.append(func)for f in flist:    print(f(2))
1
2
3
4
5
6
7
8
9

按照大家正常的理解，应该输出的是0, 2, 4对吧？但实际输出的结果是:4, 4, 4. 原因是什么呢？loop在python中是没有域的概念的，flist在像列表中添加func的时候，并没有保存i的值，而是当执行f(2)的时候才去取，这时候循环已经结束，i的值是2，所以结果都是4。

ps:补充说明： 
这之所以会发生是由于Python中的“后期绑定”行为——闭包中用到的变量只有在函数被调用的时候才会被赋值。所以，在上面的代码中，任何时候，当返回的函数被调用时，Python会在该函数被调用时的作用域中查找 i 对应的值（这时，循环已经结束，所以 i 被赋上了最终的值2）

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

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

origin=[0,0]# 坐标系统原点

legal_x=[0,50]# x轴方向的合法坐标

legal_y=[0,50]# y轴方向的合法坐标

defcreate(pos=origin):

 defplayer(direction,step):

  # 这里应该首先判断参数direction,step的合法性，比如direction不能斜着走，step不能为负等

  # 然后还要对新生成的x，y坐标的合法性进行判断处理，这里主要是想介绍闭包，就不详细写了。

  new_x=pos[0]+direction[0]*step

  new_y=pos[1]+direction[1]*step

  pos[0]=new_x

  pos[1]=new_y

  #注意！此处不能写成 pos = [new_x, new_y]，原因在上文有说过

  returnpos

 returnplayer

  

player=create() # 创建棋子player，起点为原点

printplayer([1,0],10)# 向x轴正方向移动10步

printplayer([0,1],20)# 向y轴正方向移动20步

printplayer([-1,0],10)# 向x轴负方向移动10步

输出为：

?

1

2

3

[10,0]

[10,20]

[0,20]

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

?

1

2

3

4

5

6

7

8

defmake_filter(keep):

 defthe_filter(file_name):

  file=open(file_name)

  lines=file.readlines()

  file.close()

  filter_doc=[i foriin lines ifkeep in i]

  returnfilter_doc

 returnthe_filter

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

?

1

2

filter= make_filter("pass")

filter_result= filter("result.txt")

以上两种使用场景，用面向对象也是可以很简单的实现的，但是在用Python进行函数式编程时，闭包对数据的持久化以及按配置产生不同的功能，是很有帮助的。

闭包(closure)是函数式编程的重要的语法结构。函数式编程是一种编程范式 (而面向过程编程和面向对象编程也都是编程范式)。在面向过程编程中，我们见到过函数(function)；在面向对象编程中，我们见过对象(object)。函数和对象的根本目的是以某种逻辑方式组织代码，并提高代码的可重复使用性(reusability)。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。

不同的语言实现闭包的方式不同。Python以函数对象为基础，为闭包这一语法结构提供支持的 (我们在特殊方法与多范式中，已经多次看到Python使用对象来实现一些特殊的语法)。Python一切皆对象，函数这一语法结构也是一个对象。在函数对象中，我们像使用一个普通对象一样使用函数对象，比如更改函数对象的名字，或者将函数对象作为参数进行传递。

 

函数对象的作用域

和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用def语句定义的，函数对象的作用域与def所在的层级相同。比如下面代码，我们在line_conf函数的隶属范围内定义的函数line，就只能在line_conf的隶属范围内调用。

Python

1

2

3

4

5

6

7

def line_conf():

    def line(x):

        return 2*x+1

    print(line(5))   # within the scope

 

line_conf()

print(line(5))       # out of the scope

line函数定义了一条直线(y = 2x + 1)。可以看到，在line_conf()中可以调用line函数，而在作用域之外调用line将会有下面的错误：

NameError: name ‘line’ is not defined

说明这时已经在作用域之外。

 

同样，如果使用lambda定义函数，那么函数对象的作用域与lambda所在的层级相同。

 

闭包

函数是一个对象，所以可以作为某个函数的返回结果。

Python

1

2

3

4

5

6

7

defline_conf():

    defline(x):

        return2*x+1

    returnline      # return a function object

 

my_line=line_conf()

print(my_line(5))

上面的代码可以成功运行。line_conf的返回结果被赋给line对象。上面的代码将打印11。

 

如果line()的定义中引用了外部的变量，会发生什么呢？

Python

1

2

3

4

5

6

7

8

9

def line_conf():

    b = 15

    def line(x):

        return 2*x+b

    return line       # return a function object

 

b = 5

my_line = line_conf()

print(my_line(5))

我们可以看到，line定义的隶属程序块中引用了高层级的变量b，但b信息存在于line的定义之外 (b的定义并不在line的隶属程序块中)。我们称b为line的环境变量。事实上，line作为line_conf的返回值时，line中已经包括b的取值(尽管b并不隶属于line)。

上面的代码将打印25，也就是说，line所参照的b值是函数对象定义时可供参考的b值，而不是使用时的b值。

 

一个函数和它的环境变量合在一起，就构成了一个闭包(closure)。在Python中，所谓的闭包是一个包含有环境变量取值的函数对象。环境变量取值被保存在函数对象的__closure__属性中。比如下面的代码：

Python

1

2

3

4

5

6

7

8

9

10

defline_conf():

    b=15

    defline(x):

        return2*x+b

    returnline      # return a function object

 

b=5

my_line=line_conf()

print(my_line.__closure__)

print(my_line.__closure__[0].cell_contents)

__closure__里包含了一个元组(tuple)。这个元组中的每个元素是cell类型的对象。我们看到第一个cell包含的就是整数15，也就是我们创建闭包时的环境变量b的取值。

 

下面看一个闭包的实际例子：

Python

1

2

3

4

5

6

7

8

defline_conf(a,b):

    defline(x):

        returnax+b

    returnline

 

line1=line_conf(1,1)

line2=line_conf(4,5)

print(line1(5),line2(5))

这个例子中，函数line与环境变量a,b构 成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个环境变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。