python - "global"和 "import __main__"之间的区别

Question

我定义了三个函数来更改全局变量 x。

def changeXto1():
    global x
    x = 1

def changeXto2():
    from __main__ import x
    x = 2

def changeXto3():
    import __main__
    __main__.x = 3

x = 0
print x
changeXto1()
print x
changeXto2()
print x
changeXto3()
print x

它给出了结果:

0
1
1
3

changeXto1 使用普通的全局语句。结果符合预期 x == 1。changeXto2 使用 from __main__ import 来处理 x。这是行不通的。之后 x 仍然是 1。changeXto3 使用 import main 通过 __main__.xx。之后的结果如预期的那样是 3。

为什么 from __main__ import 在 changeXto2 中工作，而 import __main__ 在 changeXto3 中工作？如果我们也可以使用 __main__ 模块处理全局变量，为什么我们需要 Python 中的全局语句？

Answer 1

这与 Python 如何将您的代码转换为字节码(编译步骤)有关。

在编译函数时，Python 将所有分配的变量视为局部变量并执行优化以减少它必须执行的名称查找次数。每个局部变量都被分配了一个索引，当函数被调用时，它们的值将存储在一个由索引寻址的堆栈局部数组中。编译器将发出 LOAD_FAST 和 STORE_FAST 操作码来访问变量。

global 语法指示编译器，即使变量被赋值，它也不应被视为局部变量，不应被分配索引。它将改为使用 LOAD_GLOBAL 和 STORE_GLOBAL 操作码来访问变量。这些操作码较慢，因为它们使用名称在可能的许多词典(本地、全局)中进行查找。

如果一个变量只是为了读取值而被访问，编译器总是发出 LOAD_GLOBAL 因为它不知道它应该是局部变量还是全局变量，因此假设它是一个全局。

因此，在您的第一个函数中，使用 global x 通知编译器您希望它将对 x 的写访问视为写入全局变量而不是局部变量。该函数的操作码很清楚:

>>> dis.dis(changeXto1)
  3           0 LOAD_CONST               1 (1)
              3 STORE_GLOBAL             0 (x)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE        

在您的第三个示例中，您将 __main__ 模块导入到名为 __main__ 的局部变量中，然后分配给它的 x 字段。由于模块是将所有顶级映射存储为字段的对象，因此您将分配给 __main__ 模块中的变量 x。正如您所发现的，__main__ 模块字段直接映射到 globals() 字典中的值，因为您的代码是在 __main__ 模块中定义的.操作码显示您没有直接访问 x:

>>> dis.dis(changeXto3)
  2           0 LOAD_CONST               1 (-1)
              3 LOAD_CONST               0 (None)
              6 IMPORT_NAME              0 (__main__)
              9 STORE_FAST               0 (__main__)

  3          12 LOAD_CONST               2 (3)
             15 LOAD_FAST                0 (__main__)
             18 STORE_ATTR               1 (x)
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        

第二个例子很有趣。由于您为 x 变量赋值，编译器假定它是一个局部变量并进行优化。然后，from __main__ import x 导入模块 __main__ 并在模块 __main__< 中创建一个新绑定(bind) x 的值 到名为 x 的局部变量。情况总是如此，from ${module} import ${name} 只是创建一个新的绑定(bind)当前命名空间。当您为变量 x 分配一个新值时，您只需更改当前绑定(bind)，而不是不相关的模块 __main__ 中的绑定(bind)(尽管如果该值是可变的，并且您改变它，变化将通过所有绑定(bind)可见)。以下是操作码:

>>> dis.dis(f2)
  2           0 LOAD_CONST               1 (-1)
              3 LOAD_CONST               2 (('x',))
              6 IMPORT_NAME              0 (__main__)
              9 IMPORT_FROM              1 (x)
             12 STORE_FAST               0 (x)
             15 POP_TOP             

  3          16 LOAD_CONST               3 (2)
             19 STORE_FAST               0 (x)
             22 LOAD_CONST               0 (None)
             25 RETURN_VALUE        

考虑这一点的一个好方法是，在 Python 中，所有赋值都是将名称绑定(bind)到字典中的值，而解引用只是进行字典查找(这是一个粗略的近似，但非常接近概念模型) .在执行 obj.field 时，您正在查找 obj 的隐藏字典(可通过 obj.__dict__ 访问)以获取 "字段” 键。

当你有一个裸变量名时，它会在 locals() 字典中查找，如果不同，则在 globals() 字典中查找(它们是当代码在模块级别执行时也是如此)。对于赋值，它总是将绑定(bind)放在 locals() 字典中，除非您通过执行 global ${name} 声明您想要全局访问(此语法也在顶层工作)。

所以翻译你的函数，这几乎是你写的:

# NOTE: this is valid Python code, but is less optimal than
# the original code. It is here only for demonstration.

def changeXto1():
    globals()['x'] = 1

def changeXto2():
    locals()['x'] = __import__('__main__').__dict__['x']
    locals()['x'] = 2

def changeXto3():
    locals()['__main__'] = __import__('__main__')
    locals()['__main__'].__dict__['x'] = 3