资讯专栏INFORMATION COLUMN

Python 的命名空间

ralap / 1544人阅读

摘要:真正管理这些名子的事物就是本文的主角命名空间。闭包命名空间闭包函数的名称空间引入。函数调用时产生新的局部命名空间函数返回结果抛出异常时释放命名空间,每一次递归都生成一个命名空间。标识符产生地点决定标识符所处的命名空间。

懒得扫全文的童鞋,可以直接跳到最后看总结。
我们先从一个简单的栗子说起:

栗子

a 文件中有变量 va 以及类 A,b 文件导入 aclass A ,并打印出 A

#a.py
va = ["dobi", "a", "dog"]

print("a1", id(va))

class A():
    def __init__(self):
        pass

    def rtn(self):
        global va
        va.insert(1,"is")
        print("a3", id(va))
        return va

print("a2", va)


#b.py
from a import A

print("b", A)

执行 b 文件的结果为:

Reloaded modules: a
a1 2407907960200
a2 ["dobi", "a", "dog"]
b 

可以发现,虽然 b 只是导入了 a 中的 class A,但导入这个过程却执行了整个 a 文件,那么我们是否能够在 b 中访问 a 中的全局变量 va 呢:

print(va)
# NameError: name "va" is not defined
print(a.va)
# NameError: name "a" is not defined
print(b.va)
# NameError: name "b" is not defined

尝试了各类调用方法,发现都无法正常访问 a 的全局变量 va,既然 b 的导入执行了整个 a 文件,甚至还打印出了 vaid 和值,又为什么无法在 b 中调用 va 呢?

这个问题所涉及到的内容就是:命名空间。

但在开始正题之前,我们需要阐明若干概念:

一些基本概念的澄清 对象

Python 一切皆对象,每个对象都具有 一个ID、一个类型、一个值;对象一旦建立,ID 便不会改变,可以直观的认为 ID 就是对象在内存中的地址

a = [1, 2]
b = a
id(a)
# 2407907978632
id(b)
# 2407907978632
b[1] = 3
a
# [1, 3]

上例 a, b 共享了同一个 ID、同一个值、同一个类型。因此 a, b 表达的是同一个对象,但 a, b 又明显是不同的,比如一个叫 "a" 一个叫 "b"...既然是同一个对象,为什么又有不同的名字呢?难道名字不是对象的属性?

标识符

事实确实如此,这是 Python 比较特殊一点:如同"a" "b" 这样的名称其实有一个共同的名字:identifier(注意不要与 ID 混淆了),中文名为“标识符”,来解释一下:

标识符:各类对象的名称,比如函数名、方法名、类名,变量名、常量名等。

在 Python 中赋值并不会直接复制数据,而只是将名称绑定到对象,对象本身是不知道也不需要关心(该关心这个的是程序猿)自己叫什么名字的。一个对象甚至可以指向不同的标识符,上例中的"a" "b"便是如此。真正管理这些名子的事物就是本文的主角“命名空间”。

命名空间

命名空间(Namespace):名字(标识符)到对象的映射。

简而言之,命名空间可以理解为:记录对象和对象名字对应关系的空间;现今 Python 的大部分命名空间是通过字典来实现的,也即一个命名空间就是名字到对象的映射,标识符是键,对象则是值。

作用域

与命名空间相对的一个概念就是“作用域”,那么什么又是作用域呢?

作用域(Scope):本质是一块文本区域,Python 通过该文本区域可以直接访问相应的命名空间。

这里需要搞清楚什么是直接访问:

#x.py
a = 1
class A():
    def func():pass
python x.py
a   #直接访问
# 1
A.func  #属性访问

Python 中不加 . 的访问为直接访问,反之为属性访问。

因此可以简单的将作用域理解为“直接访问命名空间的一种实现”,具体而言:

作用域内相应的命名空间可以被直接访问;

只有作用域内的命名空间才可以被直接访问(因此并不是所有的命名空间都可以被直接访问)。

看不懂? 没关系,后面会解释,现在先回到命名空间这个话题上,我们经常接触的命名空间有四类:

LEGB LEGB 命名空间

这四类命名空间可以简记为 LEGB:

局部命名空间(local):指的是一个函数或者一个类所定义的名称空间;包括函数的参数、局部变量、类的属性等。

闭包命名空间(enclosing function):闭包函数 的名称空间(Python 3 引入)。

全局命名空间(global):读入一个模块(也即一个.py文档)后产生的名称空间。

内建命名空间(builtin):Python 解释器启动时自动载入__built__模块后所形成的名称空间;诸如 str/list/dict...等内置对象的名称就处于这里。

为了说清楚这几类命名空间,举个栗子:

#c.py
v1 = "a global var"

def func(v):
    v2 = "a local var"
    def inn_func():
        v3 = v2 + v
        return v3
    return inn_func

内建命名空间比较好理解,我们重点讲解下其他三个:

"v1" 为全局变量 v1 的名子,其所处的命名空间为全局命名空间;需要注意的是全局命名空间包括 "func" 但不包括 func 的参数和内部变量。

func 囊括 "v""v2""inn_func" 名称的空间为局部命名空间;

执行 func 后,func 的作用域释放(或许遗忘更合适),并返回了绑定了 vv2 变量的闭包函数 inn_func,此时闭包所具有命名空间即为闭包命名空间,因此局部命名空间和闭包命名空间是相对而言的,对于父函数 func 而言,两者具有产生时间上的差异。

LEGB 访问规则

通过上面描述,我们发现 LEGB 四类命名空间本身具有明显的内外层级概念,而这种层级概念正是构建作用域的前提:作用域依据这种层级概念将不同类型的命名空间组织起来并划归到不同层级的作用域,然后定义好不同层级作用域之间的访问规则,从而实现命名空间的直接访问:
LEGB 访问规则: 同样的标识符在各层命名空间中可以被重复使用而不会发生冲突,但 Python 寻找一个标识符的过程总是从当前层开始逐层往上找,直到首次找到这个标识符为止

#d.py
v1 = 1
v2 = 3
def f():
    v1 = 2
    print(1, v1)
    print(2, v2)

f()
print(3, v1)
1 2
2 3
3 1

上例中,全局变量和函数 f 都定义了 变量 v1,结果 Python 会优先选择 f 的局部变量 v1 ,对于 f 内并未定义的变量 v2 ,Python 会向上搜寻全局命名空间,读取全局变量 v2 后打印输出。

global 和 nonlocal 语句 global 和 nonlocal 的作用

如前所述,对于上层变量,python 允许直接读取,但是却不可以在内层作用域直接改写上层变量,来看一个典型的闭包结构:

#e.py
gv = ["a", "global", "var"]

def func(v):
    gv = ["gv"] + gv #UnboundLocalError:local variable "gv" referenced before assignment
    lv = []
    def inn_func():
        lv = lv + [v]  #UnboundLocalError:local variable "lv" referenced before assignment
        gv.insert(1, lv[0])
        return gv
    return inn_func

实际调用 func()函数后,上面两处对 gvlv 进行赋值操作的地方都会发生 UnboundLocalError:因为 Python 在执行函数前,会首先生成各层命名空间和作用域,因此 Python 在执行赋值前会将func 内的 "gv" "lv" 写入局部命名空间和闭包命名空间,当 Python 执行赋值时会在局部作用域、闭包作用域内发现局部命名空间和闭包命名空间内已经具有"gv""lv" 标识符,但这两个非全局标识符在该赋值语句执行之前并没有被赋值,也即没有对象与标识符关联,因此无法参与四则运算,从而引发错误;但这段程序本意可能只是想让具有对象的全局变量gv 和局部变量 lv 参与运算,为了避免类似的情况发生,Python 便引入了 globalnonlocal 语句就来说明所修饰的 gvlv 分别来自全局命名空间和局部命名空间,声明之后,就可以在 funcinn_func 内直接改写上层命名空间内 gvlv 的值:

#f.py
gv = ["a", "global", "var"]

def func(v):
    global gv
    gv = ["gv"] + gv
    lv = []
    print(id(lv))
    def inn_func():
        nonlocal lv
        lv = lv + [v]
        print(id(lv))
        gv.insert(1, lv[0])
        return gv
    return inn_func
a = func("is")
# 2608229974344

a()
# 2608229974344
# ["gv", "is", "a", "global", "var"]

print(gv)
# ["gv", "is", "a", "global", "var"]

如上,全局变量 gv 值被函数改写了, inn_func 修改的也确实是父函数 lv的值 (依据 ID 判断)。

借壳

那么是不是不使用 globalnonlocal 就不能达到上面的目的呢?来看看这段程序:

#g.py
gv = ["a", "global", "var"]

def func(v):
    gv.insert(0, "gv")
    lv = []
    print(id(lv))
    def inn_func():
        lv.append(v)
        print(id(lv))
        gv.insert(1, lv[0])
        return gv
    return inn_func

执行的结果:

a = func("is")
# 2608110869168

a()
# 2608110869168
# ["gv", "is", "a", "global", "var"]

print(gv)
# ["gv", "is", "a", "global", "var"]

可以发现,执行结果同上面完全一致,问题自然来了:“为什么不用 global nonlocal 也可以改写全局变量gv和父函数变量lv的值?

为了看清楚这个过程,我们将上面的gv.insert(0, "gv") lv.append(v) 改写为 gv[0:0] = ["gv"] lv[:] = [v]:

#h.py
gv = ["a", "global", "var"]

def func(v):
    gv[0:0] = ["gv"]
    lv = []
    print(id(lv))
    def inn_func():
        lv[:] = [v]
        print(id(lv))
        gv.insert(1, lv[0])
        return gv
    return inn_func

执行结果:

a = func("is")
# 2608229959496

a()
# 2608229959496
# ["gv", "is", "a", "global", "var"]

同 g.py 文件的执行结果完全一致,事实上两者之间的内在也是完全一样的。
So 我们其实改写的不是 gvlv ,而是 gvlv 的元素 gv[0:0]lv[:] 。因此,不需要 globalnonlocal 修饰就可以直接改写,这就是“借壳”,nonlocal 尚未引入 Python 中,比如 Python 2.x 若要在子函数中改写父函数变量的值就得通过这种方法。
当然借壳蕴藏着一个相对复杂的标识符创建的问题:比如子函数通过借壳修改父函数变量lv的值,那么子函数的标识符lv是怎么绑定到父函数变量lv的值 ID 的上的?

关于这个问题,这里有个问答就是讨论这个的:python的嵌套函数中局部作用域问题?

global 和 nonlocal 语句对标识符创建的不同影响

另外,需要注意的是:global 语句只是声明该标识符引用的变量来自于全局变量,但并不能直接在当前层创建该标识符;nonlocal 语句则会在子函数命名空间中创建与父函数变量同名的标识符:

#j.py
gv = "a global var"

def func():
    global gv
    lv = "a local var"
    print(locals())
    def inn_func():
        nonlocal lv
        global gv
        print(locals())
    return inn_func

执行结果:

c = func()
{"lv": "a local var"}   #运行 `func` 函数后,`global` 语句并未将 `gv` 变量引入局部命名空间

c()
{"lv": "a local var"}   #运行闭包函数后,`nonlocal` 语句将父函数变量 `lv` 引入闭包命名空间

之所以 nonlocal 语句与 global 语句的处置不同,在于全局变量的作用域生存期很长,在模块内随时都可以访问,而父函数的局部作用域在父函数执行完毕后便会直接释放,因此 nonlocal 语句必须将父函数变量的标识符和引用写入闭包命名空间。

命名空间的生命周期 创建规则

实际上,到这里其实还有一个重要的重要问题没有解决:“标识符并不是天生就在命名空间内的,命名空间也不是平白无故就产生的,那么命名空间是在什么时候被创建?又是在什么时候被删除的呢?”
规则有四:

内建命名空间在 Python 解释器启动时创建,之后会一直存在;

模块的全局命名空间在模块定义被读入时创建,通常模块命名空间也会保持到解释器退出。

函数调用时产生新的局部命名空间;函数返回结果、抛出异常时释放命名空间,每一次递归都生成一个命名空间。

标识符产生地点决定标识符所处的命名空间。

这四点就是拿来秒懂的!不过,仍然有一点常常被忽视:类的命名空间:

类的局部命名空间

首先,函数和类执行时都会产生局部命名空间,但类的执行机制不同于函数:

#i.py
def a():
    print("function")

class A():
    print(1)
    class B():
        print(2)
        class C():
            print(3)

执行文件,结果为:

1
2
3

如上,类就是一个可执行的代码块,只要该类被加载,就会被执行,这一点不同于函数。
类之所以这么设计的原因在于:类是创建其他实例(生成其他的类或者具体的对象)的对象,因此必须在实例之前被创建,而类又可能涉及到与其他类的继承、重载等一系列问题,故在代码加载时就被创建利于提高效率和降低逻辑复杂度。

其次,与函数不同的是,类的局部命名空间并非作用域

class A():
    a = 1
    b = [a + i for i in range(3)]  #NameError: name "a" is not defined

执行上段代码,我们可以发现在类 A 内列表推导式无法调取 a 的值,但函数却可以:

def func():
    a = 1
    b = [a + i for i in range(3)]
    print(b)

func()  #[1, 2, 3]

因此,A 中的 a 不同于函数 func 中的 a 在局部命名空间中可以被任意读取,之所以说是“不可以被任意”读取而不是“不可被读取”,原因在于在类A 的局部空间内,a 其实一定程度上是可以直接被读取的:

class A():
    a = 1
    c = a + 2

执行上段代码后:

A.c 
#3

而上例中 b 的赋值操作不能执行,原因在于列表推导式会创建自己的局部命名空间,因此难以访问到 a

编译与局部命名空间

Python 是动态语言,很多行为是动态发生的,但 Python 自身也在不断进步,比如为了提高效率,有些行为会在编译时候完成,局部变量的创建就是如此:

def func():
    a = 1
    def inn_func():
        print(a)  # error
        a = 2     # error
    inn_func()

上段程序还未执行,就提示存在有语法错误,原因在于python 解释器发现 inn_func 内存在自身的 a 变量,但却在声明之前就被 print 了。

总结

啰嗦了这么多,终于该结尾了!
我们再来回过头来看下文章开头的栗子:
1、为什么 b.py 只是导入 a.py 中的 class A,却执行了整个 a.py 文件?
答:因为 Python 并不知道 class A 在 a.py 文档的何处,为了能够找到 class A,Python 需要执行整个文档。
2、为什么 b.py 的导入执行了整个 a.py 文档,却在 b 中难以调用 a 的全局变量 va
答:Python 的全局变量指的是模块全局,因此不可以跨文档,因此 global 语句也是不可以跨文档的。另外, b 只是导入了 a 的 class A,因此并不会导入 a 中所有的标识符,所以 类似a.va 这样的调用也是不起作用的。

关于命名空间:
1、赋值、定义类和函数都会产生新的标识符;
2、全局变量的标识符不能跨文档;
3、各级命名空间相互独立互不影响;
4、Python 总是从当前层逐渐向上寻找标识符;
5、内层作用域若想直接修改上层变量,需要通过 global nonlocal 语句先声明;
6、单纯的 global 语句并不能为所在层级创建相应标识符,但 nonlocal 语句可以在闭包空间中创建相应标识符;
7、类的局部命名空间不是作用域。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/37781.html

相关文章

  • python基础知识之函数初阶——命名空间

    摘要:在内置命名空间不能使用全局和局部的名字。可以形象地理解成内置命名空间具有最高级别,不需要定义就可以使用,全局命名空间次之,最低级是局部命名空间。 python中的命名空间分三种: 内置的命名空间,在启动解释器的时候自动加载进内存的各种名字所在的空间,比如print,input等不需要定义就可以使用的名字 全局命名空间,就是从上到下所有我们定义的变量名和函数名所在的空间,是在程序从上到下...

    dack 评论0 收藏0
  • python基础教程:作用域和命名空间

    摘要:正如我们前面举的张三的例子那样,不同命名空间中的名称之间没有任何关系。作用域作用域,是一个命名空间可直接发放完的代码的文本区域。删除也是如此,语句会从局部命名空间的引用中移除对的绑定。 命名空间和作用域的概念我们之前也提到过,比如内置函数globals(),函数中变量的作用域,模块使用的import等等。这些可能让我们对这两个概念有了大致的理解。本节再详细探讨一下。 showImg(h...

    wangzy2019 评论0 收藏0
  • 深度辨析 Python eval() 与 exec()

    摘要:内置函数们能够被提拔出来,这就意味着它们皆有独到之处,有用武之地。因此,掌握内置函数的用法,就成了我们应该点亮的技能。报错包含了内置命名空间中的名称,在控制台中输入,就能发现很多内置函数异常和其它属性的名称。 Python 提供了很多内置的工具函数(Built-in Functions),在最新的 Python 3 官方文档中,它列出了 69 个。 大部分函数是我们经常使用的,例如 p...

    AndroidTraveler 评论0 收藏0
  • Python与家国天下

    摘要:正如儒家经典所阐述修身齐家治国平天下。除此之外,模块还有如下最基本的属性在一个模块的全局空间里,有些属性是全局起作用的,称之为全局变量,而其它在局部起作用的属性,会被称为局部变量。 导读:Python猫是一只喵星来客,它爱地球的一切,特别爱优雅而无所不能的 Python。我是它的人类朋友豌豆花下猫,被授权润色与发表它的文章。如果你是第一次看到这个系列文章,那我强烈建议,请先看看它写的前...

    姘搁『 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<