亲宝软件园·资讯

展开

Python名字

​ 编程学习网   ​ 人气:0

前言:

我们在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

怎么样,是不是很有趣呢?以上就是本次分享的所有内容,想要了解更多欢迎前往公众号:Python编程学习圈,每日干货分享

加载全部内容

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