由一个例子到python的名字空间

前言

例子引入

例1

#!/usr/bin/env python # encoding: utf-8   def func1():     x = 1     print globals()     print 'before func1:', locals()      def func2():         a = 1         print 'before fun2:', locals()         a += x         print 'after fun2:', locals()      func2()     print 'after func1:', locals()     print globals()  if __name__ == '__main__':     func1()

可以正常输出结果： 并且需要注意，在 func2 使用 x 变量之前的名字空间就已经有了 'x':1 .

before func1: {'x': 1} before fun2: {'a': 1, 'x': 1} after fun2: {'a': 2, 'x': 1} after func1: {'x': 1, 'func2': <function func2 at 0x7f7c89700b90>}

稍微改一点:如下

例2:

#!/usr/bin/env python # encoding: utf-8   def func1():     x = 1     print 'before func1:', locals()      def func2():         print 'before fun2:', locals()         x += x #就是这里使用x其余地方不变         print 'after fun2:', locals()      func2()     print 'after func1:', locals()  if __name__ == '__main__':     func1()

输出就开始报错: 而且在 before func2 也没有了 x .

before func1: {'x': 1} before fun2: {} Traceback (most recent call last):   File "test.py", line 18, in <module>     func1()   File "test.py", line 14, in func1     func2()   File "test.py", line 11, in func2     x += x UnboundLocalError: local variable 'x' referenced before assignment 

这两个例子正好涉及到了 python 里面最核心的内容： 名字空间 ，正好总结一下，然后在解释这几个例子。

名字空间(Namespace)

比如我们定义一个"变量"

In [14]: a NameError: name 'a' is not defined

所以，这里更准确的叫法应该是 名字 。 一些语言中比如 c,c++,java 变量名是内存地址别名, 而Python 的名字就是一个字符串，它与所指向的目标对象关联构成名字空间里面的一个键值对 {name: object} ，因此可以这么说，python的 名字空间 就是一个字典.。

分类

python里面有很多名字空间，每个地方都有自己的名字空间，互不干扰，不同空间中的两个相同名字的变量之间没有任何联系一般有4种: LEGB 四种

• locals : 函数内部的名字空间，一般包括函数的局部变量以及形式参数

• enclosiing function : 在嵌套函数中外部函数的名字空间, 对 fun2 来说， fun1 的名字空间就是。

• globals : 当前的模块空间，模块就是一些 py 文件。也就是说，globals()类似全局变量。

• __builtins__ : 内置模块空间， 也就是内置变量或者内置函数的名字空间。

当程序引用某个变量的名字时，就会从当前名字空间开始搜索。搜索顺序规则便是: LEGB .

locals  -> enclosing function -> globals -> __builtins

访问方式

其实上面都已经说了，这里暂时简单列一下

1. 使用 locals() 访问局部命名空间

2. 使用 globals() 访问全局命名空间

   这里有一点需要注意，就是涉及到了 from A import B 和 import A 的一点区别。

#!/usr/bin/env python # encoding: utf-8  import copy from copy import deepcopy   def func():     x = 123     print 'func locals:',locals()  s = 'hello world' if __name__ == '__main__':     func()     print 'globals:', globals()

输出结果:

func locals: {'x': 123} globals: {'__builtins__': <module '__builtin__' (built-in)>,  '__file__': 'test.py',  '__package__': None,  's': 'hello world', 'func': <function func at 0x7f1c3d617c80>,  'deepcopy': <function deepcopy at 0x7f1c3d6177d0>,  '__name__': '__main__',  'copy': <module 'copy' from '/usr/lib/python2.7/copy.pyc'>,  '__doc__': None}

从输出结果可以看出 globals() 包含了定义的函数，变量等。对于 'deepcopy': <function deepcopy at 0x7f1c3d6177d0> 可以看出 deepcopy 已经被导入到自己的名字空间了，而不是在 copy 里面。 而导入的 import copy 则还保留着自身的名字空间。因此要访问 copy 的方法，就需要使用 copy.function 了。这也就是为什么推荐使用 import module 的原因，因为 from A import B 这样会把 B 引入自身的名字空间，容易发生覆盖或者说污染。

生存周期

每个名字空间都有自己的生存周期，如下:

• __builtins__ : 在 python 解释器启动的时候，便已经创建,直到退出

• globals : 在模块定义被读入时创建，通常也一直保存到解释器退出。

• locals : 在 函数调用 时创建, 直到函数返回，或者抛出异常之后，销毁。 另外递归函数每一次均有自己的名字空间。

看着没有问题，但是有很多地方需要考虑。比如名字空间都是在代码编译时期确定的，而不是执行期间。这个也就可以解释为什么在例1中， before func2: 的locals()里面包含了 x: 1 这一项。再看下面这个，

def func():     if False:         x = 10 #该语句永远不执行     print x

肯定会报错的，但是错误不是

NameError: global name 'x' is not defined

而是:

UnboundLocalError: local variable 'x' referenced before assignment

虽然 x = 10 永远不会执行，但是在执行之前的编译阶段，就会把 x 作为 locals 变量，但是后面编译到 print 的时候，发现没有赋值,因此直接抛出异常， locals() 里面便不会有 x 。这个就跟例子2中, before func2 里面没有 x 是一个道理。

赋值

a = 10

这个语句就是把 a 放入到了对应的命名空间, 然后让它指向一个值为10的整数对象。

a = [] a.append(1) 

总结

分析例子

现在再看例子2, 就清晰多了， x += x 编译到这里时，发现了赋值语句，于是准备把 x 新加入最内层名字空间也就是 func2 中，即使上层函数已经存在了; 但是赋值的时候，又要用到 x 的值， 然后就会报错:

UnboundLocalError: local variable 'x' referenced before assignment

#!/usr/bin/env python # encoding: utf-8  def func1():     x = [1,2]     print 'before func1:', locals()      def func2():         print 'before fun2:', locals()         x[0] += x[0] #就是这里使用x[0]其余地方不变         print 'after fun2:', locals()      func2()     print 'after func1:', locals()  if __name__ == '__main__':     func1() 

这个结果就是：

 before func1: {'x': [1, 2]} before fun2: {'x': [1, 2]} after fun2: {'x': [2, 2]} after func1: {'x': [2, 2], 'func2': <function func2 at 0x7fb67b253b18>} 

延伸

与闭包的不同

locals()与globals()

在最外层的模块空间里 locals() 就是 globals()

In [2]: locals() is globals() Out[2]: True

另外我们可以手动修改 globals() 来创建名字

In [3]: globals()['a'] = 'abcde' In [4]: a Out[4]: 'abcde'

但是 locals() 在函数里面的话， 貌似是不起作用的，如下：

In [5]: def func():    ...:     x = 10    ...:     print x    ...:     print locals()    ...:     locals()['x'] = 20    ...:     print x In [6]: func() 10 {'x': 10} 10 

这是因为解释器会将 locals 名字复制到 一个叫 FAST 的 区域来优化访问速度，而实际上解释器访问对象时，是从 FAST 区域里面读取的，而非 locals() 。所以直接修改 locals() 并不能影响 x (可以使用 exec 动态访问，不再细述)。 不过赋值操作，会同时刷新 locals() 和 FAST 区域。

查了不少资料，说了这么多，我只想说，作为 python 最核心的东西，名字空间还有很多很多地方需要探究，比如

• 作用域(scope)与名字空间, 这里只是模糊了二者的区别

• 面向对象，也就是类的名字空间， 又有不一样的地方。。。

学一点记录一点吧。

参考