问题描述

在我学习Python3的过程中，在尝试全局变量()和局部变量()的同时，我制作了一个非常基本的、独立的Python程序，并收到了结果，为此我请求专家解释。 然后，我在我的Python程序中执行了相同的两个函数(Any)，并收到了许多函数的列表(All？)值，而不管它是声明为本地、全局还是非本地的。 我的理解是，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__'}
>>>

推荐答案

简单说明

globals()指当前模块的属性字典。 locals()引用函数/代码段中的当前局部变量。

设置变量将仅更改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}

创建新类时会发生类似的情况

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

更深入的说明

如果您想知道为什么全局变量和局部变量是这样的，让我们来看看Python背后发生了什么。

一些基础工作

所有的Python代码都会在某个时刻传递等同于eval或exec函数的内容。这些函数接受三个参数：source、globals(默认为当前全局变量)和locals(默认为当前本地变量)。

函数globals()和locals()将返回传递到上述eval或exec函数的所有内容。

Python外壳做什么？

如果您这样做

>>> 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外壳程序会将globals和locals设置为相同的值。

函数执行

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

1. 分析传递给函数的参数并将它们添加到局部变量。
2. 执行函数代码
3. 返回其结果。

这里有一个伪算法：

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

创建新类

使用CLASS语句时，将分别执行所有缩进代码。

1. 将创建一个新词典，它将充当locals()
2. 您的代码与所述本地变量一起执行。
3. 该类是在
中传递本地变量创建的

如果执行此代码：

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)

如何映射到模块导入

如果导入模块，则会启动复杂的导入机制。这是一个简化的概述：

1. 解释器将查看模块是否已导入。
2. 解释器将找到该文件。
3. 然后读取并解析文件
4. 已创建模块对象。
5. 执行python脚本，并将其全局变量和局部变量设置为新模块的__dict__属性。
6. 返回模块对象。

它的工作原理如下：

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全局变量()和局部变量()内容的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！