python的闭包

文章转载来自http://blog.csdn.net/marty_fu/article/details/7679297

闭包这个概念在不少语言中都有涉及，本文主要谈谈python中的闭包。Python中使用闭包主要是在进行函数式开发时使用。

一，定义

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

>>>def addx(x):
>>>    def adder(y): return x + y
>>>    return adder
>>> c =  addx(8)
>>> type(c)
<type 'function'>
>>> c.__name__
'adder'
>>> c(10)
18

结合这段简单的代码和定义来讲明闭包：

若是在一个内部函数里：adder(y)就是这个内部函数，

对在外部做用域（但不是在全局做用域）的变量进行引用：x就是被引用的变量，x在外部做用域addx里面，但不在全局做用域里，

则这个内部函数adder就是一个闭包。

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

二，使用闭包注意事项

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

>>> def foo():
...     m = 0
...     def foo1():
...         m = 1
...         print m
...
...     print m
...     foo1()
...     print m
...
>>> foo()
0
1
0

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

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

 

def foo():
    a = 1
    def bar():
        a = a + 1
        return a
    return 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 以前，使用语句nonloacal a就能够了，该语句显式的指定a不是闭包的局部变量。

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.

解决方法也很简单，改写一下函数的定义就能够了。

for i in range(3):
    def foo(x,y=i): print x + y
    flist.append(foo)

 

三，做用

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

用途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]*step
        new_y = pos[1] + direction[1]*step
        pos[0] = new_x
        pos[1] = new_y
        #注意！此处不能写成 pos = [new_x, new_y]，缘由在上文有说过
        return pos
    return player

player = 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]

用途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_doc
    return the_filter

若是咱们须要取得文件"result.txt"中含有"pass"关键字的行，则能够这样使用例子程序

 

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

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