简单解释
globals()指当前模块的属性字典。locals()指的是函数/代码片段中的当前局部变量。
设置一个变量将only永远改变locals()。 （除非你告诉 python 否则使用global or nonlocal关键词。）
这是一个例子
默认情况下，模块范围的全局变量与局部变量具有相同的字典：
>>> globals() is locals()
True
由于在这种情况下全局变量是局部变量，因此修改局部变量也会修改全局变量。
如果您创建一个函数并查看其中的局部变量，您会发现局部变量会有所不同
>>> def test():
... print("globals is locals:", globals() is locals())
... print("globals:", globals())
... print("locals:", locals())
>>> test()
globals is locals: False
globals: {'__name__': '__main__', ...}
locals: {}
当您更改函数局部变量时，局部变量将自动更新
>>> def test2():
... print("locals 1:", locals())
... x = 1
... print("locals 2:", locals())
>>> test2()
locals 1: {}
locals 2: {'x': 1}
创建新类时会发生类似的情况
>>> class Test:
... print("locals:", locals())
locals: {'__module__': '__main__', '__qualname__': 'Test'}
更深入的解释
如果您想知道为什么全局变量和局部变量是这样的，让我们看看 Python 底层发生了什么。
一些基础工作
所有 python 代码都会传递相当于eval or exec在某个时刻发挥作用。这些函数接受三个参数：source, globals（默认为当前全局变量）和locals（默认为当前本地人）。
功能globals() and locals()将返回已传递到的任何内容eval or exec函数如上所示。
Python Shell 有什么作用？
如果你这样做
>>> print(globals())
REPL 将在内部做一些类似的事情
# This variable stores your globals.
_my_main_module = {}
def exec_some_line(line):
return eval(line, globals=_my_main_module, locals=_my_main_module)
# ...
exec_some_line("print(globals())")
正如你所看到的，Python Shell 会在某个时刻设置globals and locals到同一个字典。
函数执行
在内部，函数执行本质上会做三件事：
- 解析传递给函数的参数并将它们添加到局部变量中。
- 执行函数的代码
- 返回其结果。
这是一个伪算法：
def __call__(*args, **kwargs):
local_variables = parse_signature_with_args(args, kwargs)
exec(function_source, function_globals, local_variables)
return function_result
创建新类
当使用类语句时，所有缩进的代码将被单独执行。
- 创建一个新字典，它将充当
locals()
- 您的代码是与所述当地人一起执行的。
- 该类是通过局部变量创建的
如果执行这段代码：
class Test:
a = 5
大约会发生这样的情况：
# 1. A new dictionary is created
_dict = type.__prepare__()
_dict["__module__"] = __name__
_dict["__qualname__"] = "Test"
# 2. Execute the code
exec("a = 5", globals=globals(), locals=_dict)
# 3. A class is created
Test = type("Test", (), _dict)
这如何映射到模块导入
如果导入模块，则会启动复杂的导入机制。这是一个简化的概述：
- 解释器将查看模块是否已导入。
- 解释器将找到该文件。
- 然后读取并解析文件
- 创建了一个模块对象。
- python 脚本被执行，其全局变量和局部变量将被设置为新模块的
__dict__属性。
- 返回模块对象。
它的工作原理是这样的：
import sys
from types import ModuleType
def __import__(name):
# 1. See if module is already imported
if name in sys.modules:
return sys.modules[name]
# 2. Find file.
filename = find_out_path_to_file(name)
# 3. Read and parse file
with open(filename) as f:
script = f.read()
# 4. Create the new module
module = ModuleType(name)
# 5. Execute the code of the module.
exec(script, globals=module.__dict__, locals=module.__dict__)
# 6. Return the new module.
return module
