Python의 범위 및 네임스페이스 예제 분석

변수는 단지 기호일 뿐입니다

인터프리터의 관점에서 변수는 단지 일반 포인터 PyObject *일 뿐이며 Python의 관점에서 변수는 객체에 바인딩하는 데 사용되는 이름 또는 기호일 뿐입니다.

변수의 정의는 본질적으로 이름과 객체 사이의 제약 관계를 설정하는 것이므로 할당문 a = 1은 본질적으로 a 및 1을 바인딩하며, 이는 기호 a를 통해 찾을 수 있습니다. PyLongObject.

변수 할당 외에도 함수와 클래스를 만드는 것은 변수를 정의하거나 이름과 개체 간의 바인딩을 완료하는 것과 같습니다.

def foo(): pass

class A(): pass

함수를 만드는 것은 변수를 정의하는 것과 같습니다. 먼저 함수 본문을 기반으로 함수 개체를 만든 다음 foo 기호를 함수 개체에 바인딩합니다. 따라서 함수 이름과 함수 본문이 분리되어 있으며, 클래스의 경우에도 마찬가지입니다.

import os

모듈을 가져오는 것도 변수를 정의하는 것입니다. os 가져오기는 os라는 이름을 모듈 객체에 바인딩하는 것과 동일하며, 지정된 모듈 객체는 os를 통해 찾을 수 있습니다.

또 다른 예로, import numpy as np의 as 문은 변수를 정의하고 np라는 이름을 해당 모듈 객체에 바인딩합니다. 앞으로는 np라는 이름을 통해 지정된 모듈을 얻을 수 있습니다.

그리고 우리가 모듈을 임포트할 때 인터프리터가 이런 일을 하는데, 예를 들어 import os

os = __import__("os")와 동일하며, 본질적으로 변수 할당문임을 알 수 있습니다.

변수의 가시성

우리는 할당문, 함수 정의, 클래스 정의 및 모듈 가져오기가 기본적으로 이름과 개체 간의 바인딩을 완성한다는 것을 알고 있습니다. 개념적으로 말하면 실제로 name과 obj 사이의 매핑 관계를 얻습니다. 해당 obj는 name을 통해 얻을 수 있으며 해당 위치는 이름 공간입니다.

선택한 사전이 네임스페이스를 구현하는 데 가장 적합한 데이터 구조라는 것은 의심의 여지가 없습니다. 앞서 사전을 소개했을 때 사전이 고도로 최적화되어 있다고 말했는데, 그 이유는 가상 머신 자체도 많은 수의 사전을 사용하기 때문인데, 이는 여기 네임스페이스에서 반영될 수 있습니다.

그러나 모듈 내부에는 다음과 같은 이름(변수)에 여전히 가시성 문제가 있습니다.

number = 123

def foo():
    number = 456
    print(number)

foo()
print(number)  
"""
456
123
"""

동일한 변수 이름이 표시되지만 인쇄된 값은 실제로 다르므로 서로 다른 개체를 가리킨다는 것을 나타냅니다. 즉, 이 두 변수는 서로 다른 네임스페이스에 생성됩니다.

네임스페이스는 사전이므로 둘이 동일한 네임스페이스에 있는 경우 사전의 키가 반복되지 않기 때문에 number = 456이 실행되면 사전에서 "number" 키를 가진 값이 456으로 업데이트됩니다. 그러나 123은 여전히 ​​외부에 인쇄되어 있습니다. 이는 두 개가 동일한 이름 공간에 있지 않으며 인쇄된 숫자는 당연히 동일한 숫자가 아니라는 것을 의미합니다.

각 모듈에는 여러 네임스페이스가 포함될 수 있으며, 각 네임스페이스는 범위와 연결됩니다. 범위는 프로그램의 텍스트 영역으로 이해할 수 있습니다. 이 영역에 정의된 변수는 의미가 있지만 일단 이 영역을 벗어나면 유효하지 않습니다.

범위의 개념을 기억하는 것이 중요합니다. 범위는 프로그램의 텍스트에 의해서만 결정됩니다. Python에서 변수의 범위는 텍스트에서의 위치에 따라 결정됩니다.

그래서 Python에는 정적 어휘 범위가 있는 반면, 네임스페이스는 범위의 동적 표현입니다. 프로그램 텍스트로 정의된 범위는 Python이 실행될 때 네임스페이스(사전)로 변환됩니다. 함수를 입력하면 새로운 범위가 생성되므로 함수가 실행될 때 네임스페이스가 생성됩니다.

Python이 소스 코드를 컴파일할 때 코드의 각 블록에 대해 PyCodeObject가 생성됩니다. 새 네임스페이스나 범위를 입력하는 것은 새 코드 블록을 입력하는 것과 같습니다.

Python 사용 경험에 따르면 함수와 클래스는 새로운 블록이며 Python이 실행될 때 해당 네임스페이스가 생성된다는 것이 분명합니다.

네임스페이스는 변수의 컨텍스트를 정의하며, 변수의 의미는 변수가 위치한 네임스페이스에 따라 달라집니다. 특히 변수가 바인딩되는 개체는 네임스페이스에 의해 결정되며 정의되지 않습니다.

동일한 범위에 있는 코드는 범위에 나타나는 이름에 직접 액세스할 수 있습니다. 이를 직접 액세스라고 하지만 다른 범위에서는 속성 액세스를 위해 액세스 한정자를 사용해야 합니다.

class A:
    a = 1


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

A에서 B의 콘텐츠에 액세스하려면 A.property를 사용해야 합니다. 이는 A에서 A까지의 속성을 가져오는 것을 의미합니다. 하지만 B의 콘텐츠는 모두 동일한 범위에 있으므로 직접 액세스할 수 있으므로 액세스할 필요가 없습니다.

이름에 액세스하는 동작을 이름 참조라고 합니다. 이름 참조 규칙은 Python 프로그램의 동작을 결정합니다.

number = 123

def foo():
    number = 456
    print(number)

foo()
print(number)

아직 위 코드인데, 함수에서 할당문을 삭제하면 프로그램을 다시 실행하면 어떤 결과가 나올까요? Python 관점에서 보면 함수 범위에 숫자 변수가 없으므로 분명히 외부 숫자를 찾을 것입니다. 따라서 우리는 다음과 같은 결론을 얻을 수 있습니다:

• 作用域是层层嵌套的；

• 内层作用域可以访问外层作用域；

• 即使没有尝试，我们也可以想象外层作用域无法访问内层作用域。如果是把外层的 number = 123 给去掉，那么最后面的 print(number) 铁定报错；

• 查找元素会依次从当前作用域向外查找，也就是查找元素时，对应的作用域是按照从小往大、从里往外的方向前进的；

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() 函数可以返回当前作用域的局部命名空间

• globals 函数：获取当前作用域的 global 名字空间，global 名字空间也称为全局名字空间；

• __builtins__函数：或者 import builtins，获取当前作用域的 builtin 名字空间，builtint 名字空间也称为内置名字空间；

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

name = "古明地觉"

def foo():
    pass

print("name" in globals())
print("foo" in globals())
"""
True
True
"""

请注意，我们认为foo是一个单独的代码块，其对应一个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 名字空间中插入一个键值对，也等价于定义一个全局变量、并和对象绑定起来。

• name="xxx" 等价于 globals["name"]="xxx";

• print(name) 等价于 print(globals["name"])；

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

def f():
    name = "古明地觉"
    age = 16
    return locals()


def g():
    name = "古明地恋"
    age = 15
    return locals()


print(locals() == globals())  # True
print(f())  # {'name': '古明地觉', 'age': 16}
print(g())  # {'name': '古明地恋', 'age': 15}

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

但是对于函数而言，局部名字空间和全局名字空间就不一样了。每个函数都有自己的本地名称空间，因此调用 locals() 可以获取该函数的本地名称空间。但是 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 &#39;str&#39;>

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

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

因为常数 1 可以直接被加载，所以 while True 循环加上符号查找过程增加了复杂度。但是在 Python3 中两者就等价了，因为 True 在 Python3 中是一个关键字，也会直接作为一个常量来加载。

局部变量是静态存储的

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

def func():
    locals()["where"] = "地灵殿"
    try:
        print(where)
    except Exception as e:
        print(e)

func()  # name 'where' is not defined

使用字典来实现全局变量时，变量会以键值对的形式被添加到字典中。因为全局变量会一直在变，需要使用字典来动态维护。

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

所以，虽然我们说遍历查找是按照 LGB 的方式，但是访问函数内部的变量其实是静态访问的，不过完全可以按照 LGB 的方式理解。关于这方面的细节，后续还会细说。

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

LEGB 规则

前面说的 LGB 是针对 Python2.2 之前的，而从 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 在赋值之前被引用”的错误。但如果没有 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，表示静态查找。这个结果表明 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 已经被修改了

属性空间

我们知道，自定义的类里面如果没有 __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 &#39;str&#39;>
print(builtins.__dict__["str"])  # <class &#39;str&#39;>

# 另外，有一个内置的变量 __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 &#39;builtins&#39; (built-in)>

print(globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"].
      globals()["__builtins__"].globals()["__builtins__"].list("abc")
      )  # [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]

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

위 내용은 Python의 범위 및 네임스페이스 예제 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!