python - globals()、locals() 和 vars() 有什么区别？

Question

globals()、locals() 和 vars() 有什么区别？他们返回什么？更新结果有用吗？

Answer 1

每个都返回一个字典:

• globals() always 返回 module 命名空间的字典
• locals() always 返回 当前 命名空间的 a 字典
• vars() 返回当前命名空间的 字典(如果调用时不带参数)或 参数的字典。

locals 和 vars 可以使用更多解释。如果 locals() 在函数内部被调用，它会使用当前局部变量命名空间(加上任何闭包变量)的值更新字典并返回它。在同一堆栈帧中多次调用 locals() 每次都会返回相同的 dict - 它作为 f_locals 属性附加到堆栈帧对象。 dict 的内容在每个 locals() 调用和每个 f_locals 属性访问时更新，但 仅 在此类调用或属性访问时更新。变量赋值时不会自动更新，在dict中赋值条目也不会赋值对应的局部变量:

import inspect

def f():
    x = 1
    l = locals()
    print(l)
    locals()
    print(l)
    x = 2
    print(x, l['x'])
    l['x'] = 3
    print(x, l['x'])
    inspect.currentframe().f_locals
    print(x, l['x'])

f()

给我们:

{'x': 1}
{'x': 1, 'l': {...}}
2 1
2 3
2 2

第一个 print(l) 只显示一个 'x' 条目，因为对 l 的赋值发生在 locals 之后() 调用。第二个 print(l)，在再次调用 locals() 之后，显示了一个 l 条目，即使我们没有保存返回值.第三和第四个 print 表明赋值变量不会更新 l 反之亦然，但是在我们访问 f_locals 后，局部变量被复制了再次进入 locals()。

两个音符:

1. 这种行为是 CPython 特有的——其他 Python 可能允许更新自动返回到本地命名空间。
2. 在 CPython 2.x 中，可以通过在函数中添加 exec "pass" 行来完成这项工作。这会将函数切换到较旧、较慢的执行模式，该模式使用 locals() dict 作为局部变量的规范表示。

如果 locals() 被调用 outside 一个函数，它会返回作为当前命名空间的实际字典。对命名空间的进一步更改反射(reflect)在字典中，对字典的更改反射(reflect)在命名空间中:

class Test(object):
    a = 'one'
    b = 'two'
    huh = locals()
    c = 'three'
    huh['d'] = 'four'
    print huh

给我们:

{
  'a': 'one',
  'b': 'two',
  'c': 'three',
  'd': 'four',
  'huh': {...},
  '__module__': '__main__',
}

到目前为止，我所说的关于 locals() 的所有内容也适用于 vars()... 区别如下:vars() 接受单个对象作为其参数，如果您给它一个对象，它会返回该对象的 __dict__。对于一个典型的对象，它的 __dict__ 是其大部分属性数据的存储位置。这包括类变量和模块全局变量:

class Test(object):
    a = 'one'
    b = 'two'
    def frobber(self):
        print self.c
t = Test()
huh = vars(t)
huh['c'] = 'three'
t.frobber()

这给了我们:

three

请注意，函数的 __dict__ 是它的属性命名空间，而不是局部变量。函数的 __dict__ 存储局部变量是没有意义的，因为递归和多线程意味着可以同时对函数进行多次调用，每个调用都有自己的局部变量:

def f(outer):
    if outer:
        f(False)
        print('Outer call locals:', locals())
        print('f.__dict__:', f.__dict__)
    else:
        print('Inner call locals:', locals())
        print('f.__dict__:', f.__dict__)

f.x = 3

f(True)

这给了我们:

Inner call locals: {'outer': False}
f.__dict__: {'x': 3}
Outer call locals: {'outer': True}
f.__dict__: {'x': 3}

这里，f 递归调用自身，所以内部调用和外部调用重叠。每个调用 locals() 时都看到自己的局部变量，但两个调用看到相同的 f.__dict__，而 f.__dict__ 没有'里面没有任何局部变量。