亲宝软件园·资讯

展开

Python名字空间

​ 编程学习网   ​ 人气:0

前言:

这里再回顾一下函数的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']

所以global名字空间和builtin名字空间,都保存了指向彼此的指针,不管套娃多少次,都是可以的。

小结

在 Python 中,一个名字(变量)的可见范围由作用域决定,而作用域由语法静态划分,划分规则提炼如下:

与作用域相对应, Python在运行时借助PyDictObject对象保存作用域中的名字,构成动态的名字空间 。

这样的名字空间总共有 4 个:

查找名字时会按照LEGB规则查找,但是注意:无法跨越文件本身,也就是按照自身文件的LEGB。如果属性查找都找到builtin空间了,那么证明这已经是最后的倔强。如果builtin空间再找不到,那么就只能报错了,不可能跑到其它文件中找。

加载全部内容

相关教程
猜你喜欢
用户评论