我们在PyFrameObject里面看到了3个独立的名字空间：f_locals、f_globals、f_builtins。名字空间对于Python来说是一个非常重要的概念，Python虚拟机的运行机制和名字空间有着非常紧密的联系。并且在Python中，与名字空间这个概念紧密联系在一起的还有名字、作用域这些概念，下面就来剖析这些概念是如何体现的。

变量只是一个名字

很早的时候我们就说过，从解释器的角度来看，变量只是一个泛型指针PyObject *，而从Python的角度来看，变量只是一个名字、或者说符号，用于和对象进行绑定的。

变量的定义本质上就是建立名字和对象之间的约束关系，所以a = 1这个赋值语句本质上就是将a和1绑定起来，让我们通过a这个符号可以找到对应的PyLongObject。

除了变量赋值，创建函数、类也相当于定义变量，或者说完成名字和对象之间的绑定。

def foo(): pass
class A(): pass

创建一个函数也相当于定义一个变量，会先根据函数体创建一个函数对象，然后将名字foo和函数对象绑定起来。所以函数名和函数体之间是分离的，同理类也是如此。

import os

导入一个模块，也是在定义一个变量。import os相当于将名字os和模块对象绑定起来，通过os可以找到指定的模块对象。

import numpy as np当中的as语句同样是在定义变量，将名字np和对应的模块对象绑定起来，以后就可以通过np这个名字去获取指定的模块了。

另外，当我们导入一个模块的时候，解释器是这么做的。比如：import os等价于os=__import__("os")，可以看到本质上还是一个赋值语句。

作用域和名字空间

我们说赋值语句、函数定义、类定义、模块导入，本质上只是完成了名字和对象之间的绑定。而从概念上讲，我们实际上得到了一个name和obj之间的映射关系，通过name可以获取对应的obj，而它们的容身之所就是名字空间。

所以名字空间是通过PyDictObject对象实现的，这对于映射来说简直再适合不过了。而在前面介绍字典的时候，我们说过字典是被高度优化的，原因就是虚拟机本身也重度依赖字典，从这里的名字空间即可得到体现。

但是一个模块内部，名字还存在可见性的问题，比如：

a = 1
def foo():
    a = 2
    print(a)  # 2

foo()
print(a)  # 1

我们看到同一个变量名，打印的确是不同的值，说明指向了不同的对象，换句话说这两个变量是在不同的名字空间中被创建的。

然后我们知道名字空间本质上是一个字典，如果两者是在同一个名字空间，那么由于字典的key的不重复性，当执行a=2的时候，会把字典里面key为a的value给更新成2。但是在外面还是打印1，这说明两者所在的不是同一个名字空间，打印的也就自然不是同一个a。

因此对于一个模块而言，内部是可能存在多个名字空间的，每一个名字空间都与一个作用域相对应。作用域就可以理解为一段程序的正文区域，在这个区域里面定义的变量是有意义的，然而一旦出了这个区域，就无效了。

对于作用域这个概念，至关重要的是要记住：它仅仅是由源程序的文本所决定的。在Python中，一个变量在某个位置是否起作用，是由它的文本位置决定的。

因此Python具有静态作用域(词法作用域)，而名字空间则是作用域的动态体现，一个由程序文本定义的作用域在Python运行时会转化为一个名字空间、即一个PyDictObject对象。而进入一个函数，显然进入了一个新的作用域，因此函数在执行时，会创建一个名字空间。

我们之前说，在对Python源代码进行编译的时候，对于代码中的每一个block，都会创建一个PyCodeObject与之对应。而当进入一个新的名字空间、或者说作用域时，我们就算是进入一个新的block了。

而根据我们使用Python的经验，显然函数、类都是一个新的block，当Python运行的时候会为它们创建各自的名字空间。

所以名字空间是名字、或者变量的上下文环境，名字的含义取决于名字空间。更具体的说，一个变量绑定的对象是不确定的，需要由名字空间来决定。

位于同一个作用域的代码可以直接访问作用域中出现的名字，即所谓的直接访问；但不同作用域，则需要通过访问修饰符 . 进行属性访问。

class A:
    a = 1


class B:
    b = 2
    print(A.a)  # 1
    print(b)  # 2

如果想在B里面访问A里面的内容，要通过A.属性的方式，表示通过A来获取A里面的属性。但是访问B的内容就不需要了，因为都是在同一个作用域，所以直接访问即可。

访问名字这样的行为被称为名字引用，名字引用的规则决定了Python程序的行为。

a = 1
def foo():
    a = 2
    print(a)  # 2

foo()
print(a)  # 1

还是上面的代码，如果我们把函数里面的a=2给删掉，意味着函数的作用域里面已经没有a这个变量了，那么再执行程序会有什么后果呢？从Python层面来看，显然是会寻找外部的a。

因此我们可以得到如下结论：

LGB规则

我们说函数、类有自己的作用域，但是模块对应的源文件本身也有相应的作用域。比如：

name = "编程学习网"
age = 16

def foo():
    return 123

class A:
    pass

由于这个文件本身也有自己的作用域，显然是global作用域，所以解释器在运行这个文件的时候，也会为其创建一个名字空间，而这个名字空间就是global名字空间。它里面的变量是全局的，或者说是模块级别的，在当前文件的任意位置都可以直接访问。

而函数也有作用域，这个作用域称为local作用域，对应local名字空间；同时Python自身还定义了一个最顶层的作用域，也就是builtin作用域，像内置函数、内建对象都在builtin里面。

这三个作用域在Python2.2之前就存在了，所以那时候Python的作用域规则被称之为LGB规则：名字引用动作沿着local作用域(local名字空间)、global作用域(global名字空间)、builtin作用域(builtin名字空间)来查找对应的变量。

而获取名字空间，Python也提供了相应的内置函数：

每个函数都有自己local名字空间，因为不同的函数对应不同的作用域，但是global名字空间则是全局唯一。

name = "编程学习网"

def foo():
    pass

print(globals())  
# {..., 'name': '编程学习网', 'foo': <function foo at 0x000002977EDF61F0>}

里面的...表示省略了一部分输出，我们看到创建的全局变量就在里面。而且foo也是一个变量，它指向一个函数对象。

但是注意，我们说foo也是一个独立的block，因此它会对应一个PyCodeObject。但是在解释到def foo的时候，会根据这个PyCodeObject对象创建一个PyFunctionObject对象，然后将foo和这个函数对象绑定起来。

当我们调用foo的时候，再根据PyFunctionObject对象创建PyFrameObject对象、然后执行，这些留在介绍函数的时候再细说。总之，我们看到foo也是一个全局变量，全局变量都在global名字空间中。

总之，global名字空间全局唯一，它是程序运行时的全局变量和与之绑定的对象的容身之所，你在任何一个地方都可以访问到global名字空间。正如，你在任何一个地方都可以访问相应的全局变量一样。

此外，我们说名字空间是一个字典，变量和对象会以键值对的形式存在里面。那么换句话说，如果我手动地往这个global名字空间里面添加一个键值对，是不是也等价于定义一个全局变量呢？

globals()["name"] = "编程学习网"
print(name)  # 编程学习网


def f1():
    def f2():
        def f3():
            globals()["age"] = 16
        return f3
    return f2


f1()()()
print(age)  # 16

我们看到确实如此，通过往global名字空间里面插入一个键值对完全等价于定义一个全局变量。并且global名字空间是唯一的，你在任何地方调用globals()得到的都是global名字空间，正如你在任何地方都可以访问到全局变量一样。

所以即使是在函数中向global名字空间中插入一个键值对，也等价于定义一个全局变量、并和对象绑定起来。

对于local名字空间来说，它也对应一个字典，显然这个字典就不是全局唯一的了，每一个局部作用域都会对应自身的local名字空间。

def f():
    name = "夏色祭"
    age = 16
    return locals()


def g():
    name = "神乐mea"
    age = 38
    return locals()


print(locals() == globals())  # True
print(f())  # {'name': '夏色祭', 'age': 16}
print(g())  # {'name': '神乐mea', 'age': 38}

显然对于模块来讲，它的local名字空间和global名字空间是一样的，也就是说，模块对应的PyFrameObject对象里面的f_locals和f_globals指向的是同一个PyDictObject对象。

但是对于函数而言，局部名字空间和全局名字空间就不一样了。调用locals是获取自身的局部名字空间，而不同函数的local名字空间是不同的。但是globals函数的调用结果是一样的，获取的都是global名字空间，这也符合函数内找不到某个变量的时候会去找全局变量这一结论。

所以我们说在函数里面查找一个变量，查找不到的话会找全局变量，全局变量再没有会查找内置变量。本质上就是按照自身的local空间、外层的global空间、内置的builtin空间的顺序进行查找。

因此local空间会有很多个，因为每一个函数或者类都有自己的局部作用域，这个局部作用域就可以称之为该函数的local空间；但是global空间则全局唯一，因为该字典存储的是全局变量。无论你在什么地方，通过调用globals函数拿到的永远是全局名字空间，向该空间中添加键值对，等价于创建全局变量。

对于builtin名字空间，它也是一个字典。当local空间、global空间都没有的时候，会去builtin空间查找。问题来了，builtin名字空间如何获取呢？答案是使用builtins模块，通过builtins.__dict__即可拿到builtin名字空间。

# 等价于__builtins__
import builtins

#我们调用list显然是从内置作用域、也就是builtin名字空间中查找的
#但我们只写list也是可以的
#因为local空间、global空间没有的话，最终会从builtin空间中查找
#但如果是builtins.list，那么就不兜圈子了
#表示: "builtin空间，就从你这获取了"
print(builtins.list is list)  # True

builtins.dict = 123
#将builtin空间的dict改成123
#那么此时获取的dict就是123
#因为是从内置作用域中获取的
print(dict + 456)  # 579

str = 123
#如果是str = 123，等价于创建全局变量str = 123
#显然影响的是global空间
print(str)  # 123
# 但是此时不影响builtin空间
print(builtins.str)  # <class 'str'>

这里提一下Python2当中，while 1比while True要快，为什么？

因为True在Python2中不是关键字，所以它是可以作为变量名的。那么Python在执行的时候就要先看local空间和global空间里有没有True这个变量，有的话使用我们定义的，没有的话再使用内置的True。

而1是一个常量，直接加载就可以，所以while True多了符号查找这一过程。但是在Python3中两者就等价了，因为True在Python3中是一个关键字，也会直接作为一个常量来加载。

eval和exec

记得之前介绍 eval 和 exec 的时候，我们说这两个函数里面还可以接收第二个参数和第三个参数，它们分别表示global名字空间、local名字空间。

# 如果不指定，默认当前所在的名字空间
# 显然此时是全局名字空间
exec("name = '古明地觉'")
print(name)  # 古明地觉

# 但是我们也可以指定某个名字空间
dct = {}
# 将 dct 作为全局名字空间
# 这里我们没有指定第三个参数，也就是局部名字空间
# 如果指定了全局名字空间、但没有指定局部名字空间
# 那么局部名字空间默认和全局名字空间保持一致
exec("name = 'satori'", dct)
print(dct["name"])  # satori

至于 eval 也是同理：

dct = {"seq": [1, 2, 3, 4, 5]}
try:
    print(eval("sum(seq)"))
except NameError as e:
    print(e)  # name 'seq' is not defined

# 告诉我们 seq 没有被定义
# 因为我们需要将 dct 作为名字空间
print(eval("sum(seq)", dct))  # 15

所以名字空间本质上就是一个字典，所谓的变量不过是字典里面的一个 key。为了进一步加深印象，

再举个模块的例子：

# 我们自定义一个模块吧
# 首先模块也是一个对象，类型为 <class 'module'>
# 但是底层没有将这个类暴露给我们，所以需要换一种方式获取
import sys
module = type(sys)
# 以上就拿到了模块的类型对象，调用即可得到模块对象
my_module = module("自己定义的")
print(sys)  # <module 'sys' (built-in)>
print(my_module)  # <module '自己定义的'>

# 此时的 my_module 啥也没有，我们为其添砖加瓦
my_module.__dict__["name"] = "古明地觉"
print(my_module.name)  # 古明地觉
# 给模块设置属性，本质上也是操作相应的属性字典
# 当然获取属性也是如此。如果再和exec结合的话
code = """
age = 16
def foo():
    return "我是函数foo"
    
from functools import reduce     
"""
# 此时属性就设置在了模块的属性字典里面
exec(code, my_module.__dict__)
print(my_module.age)  # 16
print(my_module.foo())  # 我是函数foo
print(my_module.reduce(int.__add__, [1, 2, 3, 4, 5]))  # 15