作用域规则
命名空间是从名称到对象的映射，Python中主要是通过字典实现的，主要有以下几个命名空间：
- 内置命名空间，包含一些内置函数和内置异常的名称，在Python解释器启动时创建，一直保存到解释器退出。内置命名实际上存在于一个叫__builtins__的模块中，可以通过globals()[‘__builtins__‘].__dict__查看其中的内置函数和内置异常。
- 全局命名空间，在读入函数所在的模块时创建，通常情况下，模块命名空间也会一直保存到解释器退出。可以通过内置函数globals()查看。
- 局部命名空间，在函数调用时创建，其中包含函数参数的名称和函数体内赋值的变量名称。在函数返回或者引发了一个函数内部没有处理的异常时删除，每个递归调用有它们自己的局部命名空间。可以通过内置函数locals()查看。
python解析变量名的时候， 首先搜索局部命名空间。如果没有找到匹配的名称，它就会搜索全局命名空间。如果解释器在全局命名空间中也找不到匹配值，最终会检查内置命名空间。如果仍然找不到，就会引发NameError异常。
不同命名空间内的名称绝对没有任何关系，比如：
| 1 2 3 4 5 6 7 8 | a = 42 def foo(): a = 13 print "globals: %s" % globals() print "locals: %s" % locals() return a foo() print "a: %d" % a |
|---|
结果：
| 1 2 3 | 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异常：
| 1 2 3 4 5 | a = 42 def foo(): a +``= 1 return a foo() |
|---|
上述函数中定义了一个局部变量a，赋值语句a += 1会尝试在a赋值之前读取它的值，但全局变量a是不会给局部变量a赋值的。
要想在局部命名空间中对全局变量进行操作，可以使用global语句，global语句明确地将变量声明为属于全局命名空间：
| 1 2 3 4 5 6 7 8 9 | a = 42 def foo(): global a a = 13 print "globals: %s" % globals``() print "locals: %s" % locals``() return a foo() print "a: %d" % a |
|---|
输出：
| 1 2 3 | 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只支持在最里层的作用域和全局命名空间中给变量重新赋值，内部函数是不可以对外部函数中的局部变量重新赋值的，比如：
| 1 2 3 4 5 6 7 8 9 10 | def countdown(start): n = start def display(): print n def decrement(): n -``= 1 while n > 0``: display() decrement() countdown(``10``) |
|---|
运行会报UnboundLocalError异常，python 2中，解决这个问题的方法是把变量放到列表或字典中：
| 1 2 3 4 5 6 7 8 9 10 11 | 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语句会搜索当前调用栈中的下一层函数的定义。：
| 1 2 3 4 5 6 7 8 9 10 11 | def countdown(start): n = start def display(): print n def decrement(): nonlocal n n -``= 1 while n > 0``: display() decrement() countdown(``10``) |
|---|
闭包
闭包（closure）是函数式编程的重要的语法结构，Python也支持这一特性，举例一个嵌套函数：
| 1 2 3 4 5 6 | def foo(): x = 12 def bar(): print x return bar foo()() |
|---|
输出：12
可以看到内嵌函数可以访问外部函数定义的作用域中的变量，事实上内嵌函数解析名称时首先检查局部作用域，然后从最内层调用函数的作用域开始，搜索所有调用函数的作用域，它们包含非局部但也非全局的命名。
组成函数的语句和语句的执行环境打包在一起，得到的对象就称为闭包。在嵌套函数中，闭包将捕捉内部函数执行所需要的整个环境。
python函数的code对象，或者说字节码中有两个和闭包有关的对象：
- co_cellvars: 是一个元组，包含嵌套的函数所引用的局部变量的名字
- co_freevars: 是一个元组，保存使用了的外层作用域中的变量名
再看下上面的嵌套函数：
| 1 2 3 4 5 6 7 8 9 10 11 | >>> 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对象组成的元组，包含了由多个作用域引用的变量：
| 1 2 | >>> bar.func_closure (<cell at 0x0000000003512C78``: int object at 0x0000000000645D80``>,) |
|---|
若要查看闭包中变量的内容：
| 1 2 | >>> bar.func_closure[``0``].cell_contents 12 |
|---|
如果内部函数中不包含对外部函数变量的引用时，__closure__属性是不存在的：
| 1 2 3 4 5 6 7 8 9 | >>> def foo(): x = 12 def bar(): pass return bar >>> bar = foo() >>> print bar.func_closure None |
|---|
当把函数当作对象传递给另外一个函数做参数时，再结合闭包和嵌套函数，然后返回一个函数当做返回结果，就是python装饰器的应用啦。
延迟绑定
需要注意的一点是，python函数的作用域是由代码决定的，也就是静态的，但它们的使用是动态的，是在执行时确定的。
| 1 2 3 4 5 | >>> def foo(n): return n * i >>> fs = [foo for i in range``(``4``)] >>> print fs[``0``](``1 ) |
|---|
当你期待结果是0的时候，结果却是3。
这是因为只有在函数foo被执行的时候才会搜索变量i的值, 由于循环已结束, i指向最终值3, 所以都会得到相同的结果。
在闭包中也存在相同的问题：
| 1 2 3 4 5 6 7 | def foo(): fs = [] for i in range (``4``): fs.append(``lambda x: x *``i) return fs for f in foo(): print f(``1``) |
|---|
返回：
| 1 2 3 4 | 3 3 3 3 |
|---|
解决方法，一个是为函数参数设置默认值：
| 1 2 3 | >>> fs = [``lambda x, i``= i: x * i for i in range``(``4``)] >>> for f in fs: print f(``1``) |
|---|
另外就是使用闭包了：
| 1 2 3 4 5 6 | >>> def foo(i): return lambda x: x * i >>> fs = [foo(i) for i in range``(``4``)] >>> for f in fs: print f(``1``) |
|---|
或者：
| 1 2 | >>> for f in map``( lambda i: lambda x: i``*``x, range``(``4``)): print f(``1``) |
|---|
使用闭包就很类似于偏函数了，也可以使用偏函数:
| 1 2 3 | >>> fs = [functools.partial(``lambda x, i: x * i, i) for i in range (``4``)] >>> for f in fs: print f(``1``) |
|---|
这样自由变量i都会优先绑定到闭包函数上。
本文转载自: 掘金