Python函数的做用域规则和闭包

做用域规则

命名空间是从名称到对象的映射，Python中主要是经过字典实现的，主要有如下几个命名空间：

• 内置命名空间，包含一些内置函数和内置异常的名称，在Python解释器启动时建立，一直保存到解释器退出。内置命名实际上存在于一个叫__builtins__的模块中，能够经过globals()['__builtins__'].__dict__查看其中的内置函数和内置异常。
• 全局命名空间，在读入函数所在的模块时建立，一般状况下，模块命名空间也会一直保存到解释器退出。能够经过内置函数globals()查看。
• 局部命名空间，在函数调用时建立，其中包含函数参数的名称和函数体内赋值的变量名称。在函数返回或者引起了一个函数内部没有处理的异常时删除，每一个递归调用有它们本身的局部命名空间。能够经过内置函数locals()查看。

python解析变量名的时候，首先搜索局部命名空间。若是没有找到匹配的名称，它就会搜索全局命名空间。若是解释器在全局命名空间中也找不到匹配值，最终会检查内置命名空间。若是仍然找不到，就会引起NameError异常。

不一样命名空间内的名称绝对没有任何关系，好比：

a = 42
def foo():
    a = 13
    print "globals: %s" % globals()
    print "locals: %s" % locals()
    return a
foo()
print "a: %d" % a

结果：

globals: {'a': 42, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Users\\h\\Desktop\\test4.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002C17AC8>, '__doc__': None}
locals: {'a': 13}
a: 42

可见在函数中对变量a赋值会在局部做用域中建立一个新的局部变量a，外部具备相同命名的那个全局变量a不会改变。

在Python中赋值操做老是在最里层的做用域，赋值不会复制数据，只是将命名绑定到对象。删除也是如此，好比在函数中运行del a，也只是从局部命名空间中删除局部变量a,全局变量a不会发生任何改变。

若是使用局部变量时尚未给它赋值，就会引起UnboundLocalError异常：

a = 42
def foo():
    a += 1
    return a
foo()

上述函数中定义了一个局部变量a，赋值语句a += 1会尝试在a赋值以前读取它的值，但全局变量a是不会给局部变量a赋值的。

要想在局部命名空间中对全局变量进行操做，可使用global语句，global语句明确地将变量声明为属于全局命名空间：

a = 42
def foo():
    global a
    a = 13
    print "globals: %s" % globals()
    print "locals: %s" % locals()
    return a
foo()
print "a: %d" % a

输出：

globals: {'a': 13, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'C:\\Users\\h\\Desktop\\test4.py', '__package__': None, '__name__': '__main__', 'foo': <function foo at 0x0000000002B87AC8>, '__doc__': None}
locals: {}
a: 13

可见全局变量a发生了改变。

Python支持嵌套函数(闭包)，但python 2只支持在最里层的做用域和全局命名空间中给变量从新赋值，内部函数是不能够对外部函数中的局部变量从新赋值的，好比：

def countdown(start):
    n = start
    def display():
        print n
    def decrement():
        n -= 1
    while n > 0:
        display()
        decrement()
countdown(10)

运行会报UnboundLocalError异常，python 2中，解决这个问题的方法是把变量放到列表或字典中：

def countdown(start):
    alist = []
    alist.append(start)
    def display():
        print alist[0]
    def decrement():
        alist[0] -= 1
    while alist[0] > 0:
        display()
        decrement()
countdown(10)

在python 3中可使用nonlocal语句解决这个问题，nonlocal语句会搜索当前调用栈中的下一层函数的定义。：

def countdown(start):
    n = start
    def display():
        print n
    def decrement():
        nonlocal n
        n -= 1
    while n > 0:
        display()
        decrement()
countdown(10)

 闭包

闭包（closure）是函数式编程的重要的语法结构，Python也支持这一特性，举例一个嵌套函数：

def foo():
    x = 12
    def bar():
        print x
    return bar
foo()()

输出：12

能够看到内嵌函数能够访问外部函数定义的做用域中的变量，事实上内嵌函数解析名称时首先检查局部做用域，而后从最内层调用函数的做用域开始，搜索全部调用函数的做用域，它们包含非局部但也非全局的命名。

组成函数的语句和语句的执行环境打包在一块儿，获得的对象就称为闭包。在嵌套函数中，闭包将捕捉内部函数执行所须要的整个环境。

python函数的code对象，或者说字节码中有两个和闭包有关的对象：

• co_cellvars: 是一个元组，包含嵌套的函数所引用的局部变量的名字
• co_freevars: 是一个元组，保存使用了的外层做用域中的变量名

再看下上面的嵌套函数：

>>> def foo():
	    x = 12
	    def bar():
		    return x
	    return bar

>>> foo.func_code.co_cellvars
('x',)
>>> bar = foo()
>>> bar.func_code.co_freevars
('x',)

能够看出外层函数的code对象的co_cellvars保存了内部嵌套函数须要引用的变量的名字，而内层嵌套函数的code对象的co_freevars保存了须要引用外部函数做用域中的变量名字。

在函数编译过程当中内部函数会有一个闭包的特殊属性__closure__(func_closure)。__closure__属性是一个由cell对象组成的元组，包含了由多个做用域引用的变量：

>>> bar.func_closure
(<cell at 0x0000000003512C78: int object at 0x0000000000645D80>,)

若要查看闭包中变量的内容：

>>> bar.func_closure[0].cell_contents
12

若是内部函数中不包含对外部函数变量的引用时，__closure__属性是不存在的：

>>> def foo():
	    x = 12
	    def bar():
		    pass
	    return bar

>>> bar = foo()
>>> print bar.func_closure
None

当把函数看成对象传递给另一个函数作参数时，再结合闭包和嵌套函数，而后返回一个函数当作返回结果，就是python装饰器的应用啦。

延迟绑定

须要注意的一点是，python函数的做用域是由代码决定的，也就是静态的，但它们的使用是动态的，是在执行时肯定的。

>>> def foo(n):
	    return n * i

>>> fs = [foo for i in range(4)]
>>> print fs[0](1)

当你期待结果是0的时候，结果倒是3。

这是由于只有在函数foo被执行的时候才会搜索变量i的值, 因为循环已结束, i指向最终值3, 因此都会获得相同的结果。

在闭包中也存在相同的问题：

def foo():
    fs = []
    for i in range(4):
        fs.append(lambda x: x*i)
    return fs
for f in foo():
    print f(1)

返回：

3
3
3
3

解决方法，一个是为函数参数设置默认值：

>>> fs = [lambda x, i=i: x * i for i in range(4)]
>>> for f in fs:
	    print f(1)

另外就是使用闭包了：

>>> def foo(i):
	    return lambda x: x * i

>>> fs = [foo(i) for i in range(4)]
>>> for f in fs:
	    print f(1)

或者：

>>> for f in map(lambda i: lambda x: i*x, range(4)):
	    print f(1)

使用闭包就很相似于偏函数了，也可使用偏函数:

>>> fs = [functools.partial(lambda x, i: x * i, i) for i in range(4)]
>>> for f in fs:
	    print f(1)

这样自由变量i都会优先绑定到闭包函数上。