Python3 globals() 和 locals() 内容

Question

在我的 Python3 学习中，在尝试 globals() 和 locals() 时，我制作了一个非常基本的独立 Python 程序并收到了结果 求专家解释.

然后，我在我的 Python 程序（任何）中执行了相同的 2 个函数，并在我的程序中收到了许多（全部？）值的列表，无论它是声明为本地、全局还是非。

我的理解是 globals() 函数包含声明为全局变量的所有值的列表（对于局部变量也是如此），但根据我的观察，结果显示出一些不同的东西。

谁能解释一下我看到了什么以及为什么？

这是程序和结果：

python程序：

 print("Globals=",globals())
 print("Locals=",locals())

结果（以上两行程序）：

=============== RESTART: /home/pi/Junk/globals_locals_test.py ==========
Globals= {'__package__': None, '__spec__': None, '__loader__': <class '
_frozen_importlib.BuiltinImporter'>, '__doc__': None, '__file__': '
/home/pi/Junk/globals_locals_test.py', '__builtins__': <module 'builtins'
 (built-in)>, '__name__': '__main__'}
Locals= {'__package__': None, '__spec__': None, '__loader__': <class '
_frozen_importlib.BuiltinImporter'>, '__doc__': None, '__file__': '
/home/pi/Junk/globals_locals_test.py', '__builtins__': <module 'builtins'
 (built-in)>, '__name__': '__main__'}
>>>

Answer 1

简单说明

globals()指的是当前模块的属性字典。 locals()指的是你function/code-snippet.

中当前的局部变量

设置一个变量只会改变locals()。（除非您使用 global 或 nonlocal 关键字告诉 python。）

举个例子

默认情况下，模块范围的全局变量与局部变量是相同的字典：

>>> 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}

创建新的 classes

时会发生类似的事情

>>> class Test:
...     print("locals:", locals())
locals: {'__module__': '__main__', '__qualname__': 'Test'}

更深入的解释

如果您想知道为什么全局变量和局部变量是它们的样子，让我们看看 Python.

背后发生了什么

一些基础工作

所有 python 代码在某些时候传递等同于 eval 或 exec 函数的内容。这些函数接受三个参数：source、globals（默认为当前全局变量）和 locals（默认为当前局部变量）。

函数 globals() 和 locals() 将 return 传递给上面显示的 eval 或 exec 函数的任何内容。

PythonShell有什么作用？

如果你这样做

>>> 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 和 locals 设置为同一个字典。

函数执行

在内部，函数执行基本上会做三件事：

解析传递给函数的参数并将它们添加到局部变量。
执行函数的代码
Return 其结果。

这里是一个伪算法：

def __call__(*args, **kwargs):
    local_variables = parse_signature_with_args(args, kwargs)
    exec(function_source, function_globals, local_variables)
    return function_result

正在创建新的 classes

使用class语句时，所有缩进的代码将单独执行。

创建了一个新词典，它将充当 locals()
你的代码是用所说的本地人执行的。
class 是通过

如果你执行这段代码：

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__ 属性。
模块对象 returned.

它的工作原理是这样的：

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

Python3 globals() 和 locals() 内容

Python3 globals() and locals() contents

python

global

python-3.5

简单说明

更深入的解释