Question

在Python中使用globals（）函数的原因是什么？它只返回已经是全局变量的全局变量字典，所以它们可以在任何地方使用......我只是出于好奇，试图学习python。

def F():
    global x
    x = 1

def G():
    print(globals()["x"]) #will return value of global 'x', which is 1

def H():
    print(x) #will also return value of global 'x', which, also, is 1

F()
G()
H()

我真的不明白这一点吗？只有我需要的时候，如果我有本地和全局变量，两者都有相同的名称

def F():
    global x
    x = 1

def G():
    x = 5
    print(x) #5
    print(globals()["x"]) #1

F()
G()

但是你应该永远不会遇到两个具有相同名称的变量，并且需要在同一范围内使用它们的问题。

Answer 1

Python为程序员提供了大量用于内省运行环境的工具。 globals()只是其中之一，它在调试会话中非常有用，可以查看全局范围实际包含的对象。

我确定，其背后的基本原理与使用locals()查看函数中定义的变量，或使用dir查看模块内容的原理相同，或者对象的属性。

来自C ++背景，我可以理解这些事情似乎是不必要的。在静态链接的静态类型环境中，它们绝对是。在这种情况下，在编译时确切知道哪些变量是全局变量，对象将具有哪些成员，甚至是另一个编译单元导出的名称。

然而，在动态语言中，这些东西并没有固定;它们可以根据代码的导入方式，甚至在运行时进行更改。至少由于这个原因，在调试器中访问这类信息是非常宝贵的。

Answer 2

当您需要使用函数的字符串名称调用函数时，它也很有用。例如：

def foo():
    pass

function_name_as_string = 'foo'

globals()[function_name_as_string]() # foo().

Answer 3

您可以将globals()和locals()的结果传递给eval，execfile和__import__命令。这样做会为这些命令创建一个受限制的环境。

因此，存在这些函数以支持其他功能，这些功能受益于给予可能与当前上下文不同的环境。例如，您可以在调用其中一个函数之前调用globals()然后删除或添加一些变量。

Answer 4

globals()对eval()很有用 - 如果你想评估一些引用范围内变量的代码，那些变量将是全局变量或本地变量。

为了扩展一点，eval()内置函数将解释给它的一串Python代码。签名是：eval(codeString, globals, locals)，您可以这样使用它：

def foo():
    x = 2
    y = eval("x + 1", globals(), locals())
    print("y=" + y) # should be 3

这很有效，因为解释器从x变量的dict中获取locals()的值。您当然可以将自己的变量字典提供给eval。

Answer 5

它在声明性python中很有用。例如，下面的FooDef和BarDef是用于定义一系列数据结构的类，然后由某个包用作其输入或其配置。这使您可以在输入内容方面获得很大的灵活性，并且不需要编写解析器。

# FooDef, BarDef are classes

Foo_one = FooDef("This one", opt1 = False, valence = 3 )
Foo_two = FooDef("The other one", valence = 6, parent = Foo_one )

namelist = []
for i in range(6):
    namelist.append("nm%03d"%i)

Foo_other = FooDef("a third one", string_list = namelist )

Bar_thing = BarDef( (Foo_one, Foo_two), method = 'depth-first')

请注意，此配置文件使用循环来构建名称列表，这些名称是Foo_other配置的一部分。因此，这种配置语言带有一个非常强大的“预处理器”，并带有一个可用的运行时库。如果您想要查找复杂的日志，或者从zip文件中提取内容并对其进行解码，则将其作为生成配置的一部分（当然，对于输入可能来自不受信任的来源......）

包使用以下内容读取配置：

conf_globals = {}  # make a namespace
# Give the config file the classes it needs
conf_globals['FooDef']= mypkgconfig.FooDef  # both of these are based ...
conf_globals['BarDef']= mypkgconfig.BarDef  # ... on .DefBase

fname = "user.conf"
try:
    exec open(fname) in conf_globals
except Exception:
    ...as needed...
# now find all the definitions in there
# (I'm assuming the names they are defined with are
# significant to interpreting the data; so they
# are stored under those keys here).

defs = {}
for nm,val in conf_globals.items():
    if isinstance(val,mypkgconfig.DefBase):
        defs[nm] = val

所以，最后指出，globals()在使用这样的软件包时很有用，如果你想在程序上完成一系列定义：

for idx in range(20):
    varname = "Foo_%02d" % i
    globals()[varname]= FooDef("one of several", id_code = i+1, scale_ratio = 2**i)

这相当于写出

Foo_00 = FooDef("one of several", id_code = 1, scale_ratio=1)
Foo_01 = FooDef("one of several", id_code = 2, scale_ratio=2)
Foo_02 = FooDef("one of several", id_code = 3, scale_ratio=4)
... 17 more ...

通过从python模块收集一堆定义来获取其输入的包的示例是PLY（Python-lex-yacc）http://www.dabeaz.com/ply/ - 在这种情况下，对象主要是函数对象，但是元数据来自函数对象（它们的名称，文档字符串和定义顺序）也构成了输入的一部分。使用globals()并不是一个很好的例子。此外，它是由＆＃39;配置＆＃39;导入的。 - 后者是一个普通的python脚本 - 而不是相反。

我已经使用了声明性的python＆＃39;在我为之工作的一些项目上，并且在为这些项目编写配置时有机会使用globals()。你当然可以争辩说这是由于配置语言的弱点而导致的。被设计。以这种方式使用globals()并不会产生非常明确的结果;只是结果可能比写出十几个几乎相同的陈述更容易维持。

您还可以根据其名称使用它在配置文件中赋予变量重要性：

# All variables above here starting with Foo_k_ are collected
# in Bar_klist
#
foo_k = [ v for k,v in globals().items() if k.startswith('Foo_k_')]
Bar_klist  = BarDef( foo_k , method = "kset")

此方法对于定义了大量表和结构的任何 python模块非常有用，可以更轻松地将项添加到数据中，而无需维护引用。

Answer 6

它还可以用于从a获取类'classname'的实例字符串：

class C:
    def __init__(self, x):
        self.x = x
        print('Added new instance, x:', self.x)


def call(str):
    obj = globals()[str](4)
    return obj

c = call('C')
print(c.x)

Answer 7

如果您想导入刚刚构建的模块，这可能会很有用：

a.py

[...]

def buildModule():
    [...code to build module...]
    return __import__("somemodule")

[...]

b.py

from a import buildModule

def setup():
   globals()["somemodule"] = buildModule()

Answer 8

不是。 Python真正具有的全局变量是模块范围的变量。

# a.py
print(globals())

import b
b.tt()

# b.py
def tt():
    print(globals())

运行python a.py，至少globals()['__name__']的两个输出是不同的。

Github上cpython中的代码here显示了它。

Answer 9

我在回答中没有注意到有关使用 globals() 检查您是否设置了值的任何内容。也许您只在调试时设置值或忘记设置值并希望避免出现异常。尽管在某些情况下 locals() 可能是更好的解决方案，以避免访问全局范围和仅访问局部范围。

# DEBUG = True
if 'DEBUG' in globals():
    print(f'We found debug flag and it has value {DEBUG}.')
else: 
    print(f'Debug flag was not found.')

您也可以将它与 get() 结合使用以设置未找到变量时的默认值

# VARIABLE = "Value of var"
my_var = globals().get("VARIABLE", "Value was not found")
print(my_var)    # Prints: "Value was not found"
print(VARIABLE)  # Raises NameError

VARIABLE = "Value of var"
my_var = globals().get("VARIABLE", "Value was not found")
print(my_var)    # prints: "Value of var"
print(VARIABLE)  # prints: "Value of var"

Python中globals（）的原因？

9 个答案: