Python学习之名字,作用域,名字空间(下)_Python

前言：

这里再回顾一下函数的local空间，首先我们往global空间添加一个键值对相当于定义一个全局变量，那么如果往函数的local空间里面添加一个键值对，是不是也等价于创建了一个局部变量呢？

				?

									def f1():

									    locals()["name "] = "夏色祭"

									    try:

									        print(name)

									    except Exception as e:

									        print(e)

									f1()  # name 'name' is not defined

对于全局变量来讲，变量的创建是通过向字典添加键值对的方式实现的。因为全局变量会一直在变，需要使用字典来动态维护。

但对于函数来讲，内部的变量是通过静态方式存储和访问的，因为局部作用域中存在哪些变量在编译的时候就已经确定了，我们通过PyCodeObject的co_varnames即可获取内部都有哪些变量。

所以，虽然我们说查找是按照LGB的方式查找，但是访问函数内部的变量其实是静态访问的，不过完全可以按照LGB的方式理解。

因此名字空间是Python的灵魂，它规定了Python变量的作用域，使得Python对变量的查找变得非常清晰。

LEGB规则

而从Python2.2开始，由于引入了嵌套函数，所以最好的方式应该是内层函数找不到某个变量时先去外层函数找，而不是直接就跑到global空间里面找。

那么此时的规则就是LEGB：

				?

									a = 1

									def foo():

									    a = 2

									    def bar():

									        print(a)

									    return bar

									f = foo()

									f()

									"""

									2

									"""

调用f，实际上调用的是函数bar，最终输出的结果是2。如果按照LGB的规则来查找的话，由于函数bar的作用域没有a、那么应该到全局里面找，打印的结果是1才对。

但是我们之前说了，作用域仅仅是由文本决定的，函数bar位于函数foo之内，所以函数bar定义的作用域内嵌于函数foo的作用域之内。换句话说，函数foo的作用域是函数bar的作用域的直接外围作用域。

所以应该先从foo的作用域里面找，如果没有那么再去全局里面找。而作用域和名字空间是对应的，所以最终打印了2。

另外在执行f = foo()的时候，会执行函数foo中的def bar():语句，这个时候解释器会将a=2与函数bar捆绑在一起，然后返回，这个捆绑起来的整体就叫做闭包。

所以：闭包 = 内层函数 + 引用的外层作用域

这里显示的规则就是LEGB，其中E表示enclosing，代表直接外围作用域。

global表达式

有一个很奇怪的问题，最开始学习Python的时候，笔者也为此困惑了一段时间，下面来看一下。

				?

									a = 1

									def foo():

									    print(a)

									foo()

									"""

									1

									"""

首先这段代码打印1，这显然是没有问题的，不过下面问题来了。

				?

									a = 1

									def foo():

									    print(a)

									    a = 2

									foo()

									"""

									UnboundLocalError: local variable 'a' referenced before assignment

									"""

仅仅是在print语句后面新建了一个变量a，结果就报错了，提示局部变量a在赋值之前就被引用了，这是怎么一回事，相信肯定有人为此困惑。

而想弄明白这个错误的原因，需要深刻理解两点：

一个赋值语句所定义的变量，在这个赋值语句所在的整个作用域内都是可见的；
函数中的变量是静态存储、静态访问的, 内部有哪些变量在编译的时候就已经确定；

在编译的时候，因为a = 2这条语句，所以知道函数中存在一个局部变量a，那么查找的时候就会在当前作用域中查找。但是还没来得及赋值，就print(a)了，所以报错：局部变量a在赋值之前就被引用了。但如果没有a = 2这条语句则不会报错，因为知道局部作用域中不存在a这个变量，所以会找全局变量a，从而打印1

更有趣的东西隐藏在字节码当中，我们可以通过反汇编来查看一下：

				?

									import dis

									a = 1

									def g():

									    print(a)

									dis.dis(g)

									"""

									  7           0 LOAD_GLOBAL              0 (print)

									              2 LOAD_GLOBAL              1 (a)

									              4 CALL_FUNCTION            1

									              6 POP_TOP

									              8 LOAD_CONST               0 (None)

									             10 RETURN_VALUE

									"""

									def f():

									    print(a)

									    a = 2

									dis.dis(f)

									"""

									 12           0 LOAD_GLOBAL              0 (print)

									              2 LOAD_FAST                0 (a)

									              4 CALL_FUNCTION            1

									              6 POP_TOP

									 13           8 LOAD_CONST               1 (2)

									             10 STORE_FAST               0 (a)

									             12 LOAD_CONST               0 (None)

									             14 RETURN_VALUE

									"""

中间的序号代表字节码的偏移量，我们先看第二条，g的字节码是LOAD_GLOBAL，意思是在global名字空间中查找；而f的字节码是LOAD_FAST，表示在local名字空间中查找。因此结果说明Python采用了静态作用域策略，在编译的时候就已经知道了名字藏身于何处。

而且上面的例子也表明，一旦函数内有了对某个名字的赋值操作，这个名字就会在作用域内可见，就会出现在local名字空间中。换句话说，会遮蔽外层作用域中相同的名字。

当然Python也为我们精心准备了global关键字，让我们在函数内部修改全局变量。比如函数内部出现了global a，就表示我后面的a是全局的，直接到global名字空间里面去找，不要在local空间里面找了。

				?

									a = 1

									def bar():

									    def foo():

									        global a

									        a = 2

									    return foo

									bar()()

									print(a)  # 2

									# 当然，也可以通过globals函数拿到名字空间

									# 然后直接修改里面的键值对

但如果外层函数里面也出现了变量a，而我们想修改的也是外层函数的a、不是全局的a，这时该怎么办呢？Python同样为我们准备了关键字: nonlocal，但是使用nonlocal的时候，必须是在内层函数里面。

				?

									a = 1

									def bar():

									    a = 2

									    def foo():

									        nonlocal a

									        a = "xxx"

									    return foo

									bar()()

									print(a)  # 1

									# 外界依旧是1，但是bar里面的a已经被修改了

属性引用与名字引用

属性引用实质上也是一种名字引用，其本质都是到名字空间中去查找一个名字所引用的对象。这个就比较简单了，比如a.xxx，就是到a里面去找属性xxx，这个规则是不受LEGB作用域限制的，就是到a里面查找，有就是有、没有就是没有。

但是有一点需要注意，我们说查找会按照LEGB规则，但这必须限制在自身所在的模块内，如果是多个模块就不行了。举个栗子：

				?

									# a.py

									print(name)

									# b.py

									name = "夏色祭"

									import a

关于模块的导入我们后续会详细说，总之目前在b.py里面执行的import a，你可以简单认为就是把a.py里面的内容拿过来执行一遍即可，所以这里相当于print(name)。

但是执行b.py的时候会提示变量name没有被定义，可把a导进来的话，就相当于print(name)，而我们上面也定义name这个变量了呀。

显然，即使我们把a导入了进来，但是a.py里面的内容依旧是处于一个模块里面。而我们也说了，名称引用虽然是LEGB规则，但是无论如何都无法越过自身所在的模块。print(name)在a.py里面，而变量name被定义在b.py里面，所以不可能跨过模块a的作用域去访问模块b里面的name，因此在执行 import a 的时候会抛出 NameError。

所以我们发现，虽然每个模块内部的作用域规则有点复杂，因为要遵循LEGB；但模块与模块之间的作用域还是划分的很清晰的，就是相互独立。

关于模块，我们后续会详细说。总之通过 . 的方式，本质上都是去指定的名字空间中查找对应的属性。

属性空间

我们知道，自定义的类里面如果没有__slots__，那么这个类的实例对象都会有一个属性字典。

				?

									class Girl:

									    def __init__(self):

									        self.name = "古明地觉"

									        self.age = 16

									g = Girl()

									print(g.__dict__)  # {'name': '古明地觉', 'age': 16}

									# 对于查找属性而言, 也是去属性字典中查找

									print(g.name, g.__dict__["name"])  # 古明地觉 古明地觉

									# 同理设置属性, 也是更改对应的属性字典

									g.__dict__["gender"] = "female"

									print(g.gender)  # female

当然模块也有属性字典，本质上和类的实例对象是一致的。

				?

									import builtins

									print(builtins.str)  # <class 'str'>

									print(builtins.__dict__["str"])  # <class 'str'>

									# 另外，有一个内置的变量 __builtins__，和导入的 builtins 等价

									print(__builtins__ is builtins)  # True

另外这个__builtins__位于 global名字空间里面，然后获取global名字空间的globals又是一个内置函数，于是一个神奇的事情就出现了。

				?

									print(globals()["__builtins__"].globals()["__builtins__"].

									      globals()["__builtins__"].globals()["__builtins__"].

									      globals()["__builtins__"].globals()["__builtins__"]

									      )  # <module 'builtins' (built-in)>

									print(globals()["__builtins__"].globals()["__builtins__"].

									      globals()["__builtins__"].globals()["__builtins__"].

									      globals()["__builtins__"].globals()["__builtins__"].list("abc")

									      )  # ['a', 'b', 'c']