摘要:

  1. 什么是命名空间
  2. 命名空间有哪些
  3. 变量查找原则
  4. 分析一个UnboundLocalError的例子

什么是命名空间

首先说什么是命名空间呢!我们知道,在Python中,一切都是对象,然后通过名字去引用对象。例如我们执行了一条语句a = 3,Python做的工作就是让名字a去引用一个 Int 对象3。这种名字和对象的对应关系都存储在一个字典中,而这个字典,就叫做命名空间。任何一个模块,类,实例,函数,都有其命名空间,这个命名空间可以通过__dict__来访问。比如下面这段代码:

1
2
3
4
5
6
7
>>> import sys
>>> m = sys.modules[__name__]
>>> print(m.__dict__ is globals())
True
>>> a = 3
>>> globals().get('a')
32

在上面的例子中,我们首先通过sys.modules获取了当前运行的模块,然后通过__dict__成员获取了当前模块的命名空间,然后发现globals函数返回的就是当前模块的命名空间。当我们执行了a = 3语句以后,可以看到,当前模块的命名空间中多了一个a成员,其值为3。

命名空间有哪些

前面我们讲到,每个类,函数,实例,模块都有其命名空间,可以通过__dict__成员来访问,如下面代码所示:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> import sys
>>> main_module = sys.modules[__name__]
>>> module_member = 'module'
>>> class C:
...     class_member = 'class'
>>> c = C()
>>> c.instance_member = 'instance'
>>> def func():
...     func_member = 'function'
...     fls = sys._getframe(0).f_locals
...     print('fls and locals() are same object? %s' % (fls is locals()))
...     print(fls['func_member'])
>>>
>>> print(main_module.__dict__['module_member'])
module
>>> print(C.__dict__['class_member'])
class
>>> print(c.__dict__['instance_member'])
instance
>>> func()
fls and locals() are same object? True
function

在上面的代码中,我们分别访问了,模块,类,实例,函数的命名空间,并在其中取出了我们命名的变量。其中,访问函数的命名空间有些特殊,我们是通过_getframe函数访问了当前栈帧,然后在栈帧中找到了当前函数的命名空间。当然这个函数的命名空间也可以通过locals函数访问到。

变量查找原则

从上面的例子中,我们了解到,命名空间其实就是存储名字和对象的对应关系的,那么当我们通过一个名字来获取一个对象的时候,其查找命名空间的顺序是怎样的呢?在Python中遵循着LEGB的查找原则。

LEGB的意思就是Local -> Enclosing Function -> Global -> Builtins

遇到一个名字的时候,Python解释器首先会去本地命名空间(Local)中查找,然后再去其所在函数的作用域(Enclosing Function)中查找,如果还没找到,就去全局命名空间(Global)中查找,最后会去__builtin__这个模块中查找,__builtin__模块在 Python3 中已经重命名成了builtins,详见 stackoverflow 上关于builtin的提问,感谢@欧阳杰童鞋指出这个问题。

例如下面的一段代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
>>> x = 1234
... __builtin__.s = 'Hello, World!'
... def test():
...     y = 'abc'
...     print(x)
...     print(y)
...     print(s)
...
... test()
...
1234
abc
Hello, World!

在上面的代码中,s 是builtins命名空间中的名字,y 是local命名空间中的名字,x 是Global命名空间中的名字,它们都能够被正确找到并打印出来。

分析一个UnboundLocalError例子

在最后,我们来分析这样一段代码:

1
2
3
4
5
6
x = 1234
def test():
    print(x)
    x = 'abc'

test()
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

<ipython-input-45-9f45a812fe7a> in <module>()
      4     x = 'abc'
      5
----> 6 test()


<ipython-input-45-9f45a812fe7a> in test()
      1 x = 1234
      2 def test():
----> 3     print(x)
      4     x = 'abc'
      5


UnboundLocalError: local variable 'x' referenced before assignment

在上面的函数中,我们要打印一个名字x,它首先会去本地命名空间中查找,没有找到。然后去当前函数test的作用域中查找,找到了。此时Python解释器就会发现x这个名字还没有添加到local本地命名空间中,就被引用了。所以就会抛出一个异常,说x还未被赋值就被引用了。如果我们把代码改成下面这种形式,发现就可以正常运行了:

1
2
3
4
5
x = 1234
def test():
    print(x)

test()
1
1234

为什么删除了x的赋值语句,这个函数就能正常运行了呢? 这是因为此时Python解释器查找命名空间的顺序变了。解释器首先会去查找本地命名空间,发现没有,然后去查找函数test的作用域,发现也没有,接着再去查找全局命名空间,此时找到了,就会打印出x的值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import dis

x = 1234
def test_right():
    print(x)

dis.dis(test_right)

print('-' * 20)

x = 1234
def test_error():
    print(x)
    x = 'abc'

dis.dis(test_error)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
  5           0 LOAD_GLOBAL              0 (print)
              3 LOAD_GLOBAL              1 (x)
              6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
              9 POP_TOP
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE
--------------------
 13           0 LOAD_GLOBAL              0 (print)
              3 LOAD_FAST                0 (x)
              6 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
              9 POP_TOP

 14          10 LOAD_CONST               1 ('abc')
             13 STORE_FAST               0 (x)
             16 LOAD_CONST               0 (None)
             19 RETURN_VALUE

通过查看这两个函数的反汇编出来的代码可以看到,这两个函数访问x的时候,一个是通过LOAD_GLOBAL指令,访问的全局命名空间,另外一个则是通过LOAD_FAST指令访问的本地命名空间。通过这些反汇编出来的代码,可以部分地证明我们上面的猜想。