7

我定义了三个应该改变全局变量的函数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使用viaimport main来寻址。之后的结果是预期的 3。x__main__.x

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

4

2 回答 2

10

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

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

相反，该global语法向编译器表明，即使为变量赋值，也不应将其视为局部变量，也不应为其分配索引。它将改为使用LOAD_GLOBAL和STORE_GLOBAL操作码来访问变量。这些操作码较慢，因为它们使用名称在可能的许多字典（本地、全局）中进行查找。

如果仅访问变量以读取该值，则编译器总是发出，LOAD_GLOBAL因为它不知道它应该是局部变量还是全局变量，因此假定它是全局变量。

因此，在您的第一个函数中， usingglobal 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字段。由于模块是将所有顶级映射存储为字段的对象，因此您正在分配给模块x中的变量。__main__正如您所发现的，__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__并创建一个新的绑定x模块中的值__main__到名为的局部变量x。总是这样，from ${module} import ${name}只需创建一个新的绑定当前命名空间。当您为变量分配新值时，x您只需更改当前绑定，而不是模块__main__中不相关的绑定（尽管如果该值是可变的，并且您对其进行了变异，则更改将通过所有绑定可见）。以下是操作码：

>>> 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 中，所有赋值都是将名称绑定到字典中的值，而取消引用只是进行字典查找（这是一个粗略的近似，但非常接近概念模型）。这样做时obj.field，您正在查找obj(accessible via obj.__dict__)的隐藏字典以获取"field"密钥。

当你有一个裸变量名时，然后在字典中查找它locals()，然后在globals()字典中查找它是否不同（在模块级别执行代码时它们是相同的）。对于赋值，它总是将绑定放在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
于 2013-02-16T11:11:36.077 回答
8

为什么不from __main__ import工作changeXto2，而import __main__工作changeXto3？

它工作正常，只是没有做你想做的事。它将名称和值复制到本地命名空间，而不是让代码访问__main__的命名空间。

如果我们也可以使用模块处理全局变量，为什么我们需要 Python 中的全局语句__main__？

因为它们仅在您的代码在__main__. 如果你正在运行，比如说，othermodule在导入它之后，那么__main__将引用主脚本而不是 othermodule.

于 2013-02-16T10:35:11.737 回答