Question

简而言之，问题是：有没有办法阻止Python查找当前范围之外的变量？

详细说明：

Python在外部作用域中查找变量定义（如果它们未在当前作用域中定义）。因此，在重构期间不小心的情况下，这样的代码可能会破坏：

def line(x, a, b):
    return a + x * b

a, b = 1, 1
y1 = line(1, a, b)
y2 = line(1, 2, 3)

如果我重命名了函数参数，但忘记在函数体内重命名它们，代码仍会运行：

def line(x, a0, b0):
    return a + x * b  # not an error

a, b = 1, 1
y1 = line(1, a, b)  # correct result by coincidence
y2 = line(1, 2, 3)  # wrong result

我知道it is bad practice to shadow names from外部范围。但是，无论如何都有这样做的原因有几个：

有时候使用相同的名称可能是有意义的，因为它们指的是同一个东西
有人可能会用尽有意义的变量名称
懒惰

有没有办法阻止Python查找当前范围之外的变量？（因此，访问a或b会在第二个示例中引发错误。）

由于懒惰，我宁愿选择无需重复的样板代码的解决方案：）

如果问题在Python版本方面含糊不清，我最感兴趣的是Python 3.3及以上版本。

Answer 1

是的，也许不是一般的。但是你可以用功能来做。

你想要做的是让函数的全局变为空。你不能替换全局变量，你不想修改它的内容（因为这只是为了摆脱全局变量和函数。）

但是：您可以在运行时创建函数对象。构造函数看起来像types.FunctionType((code, globals[, name[, argdefs[, closure]]])。在那里你可以替换全局命名空间：

def line(x, a0, b0):
   return a + x * b  # will be an error

a, b = 1, 1
y1 = line(1, a, b)  # correct result by coincidence

line = types.FunctionType(line.__code__, {})
y1 = line(1, a, b)  # fails since global name is not defined

您当然可以通过定义自己的装饰器来清理它：

import types
noglobal = lambda f: types.FunctionType(f.__code__, {}, argdefs=f.__defaults__)

@noglobal
def f():
    return x

x = 5
f() # will fail

严格地说，你不禁止它访问全局变量，你只需要让函数相信全局命名空间中没有变量。实际上你也可以使用它来模拟静态变量，因为如果它将变量声明为全局变量并赋值给它，它将最终出现在它自己的全局命名空间沙箱中。

如果您希望能够访问全局命名空间的一部分，那么您需要使用您希望它看到的功能填充全局沙箱功能。

Answer 2

不，你不能告诉Python不要在全球范围内查找名称。

如果可以，您将无法使用模块中定义的任何其他类或函数，没有从其他模块导入的对象，也无法使用内置名称。你的函数命名空间变成了几乎没有它需要的所有东西的沙漠，唯一的出路就是将所有东西都导入到本地命名空间中。 对于模块中的每个功能。

不要试图打破全局查找，而是要保持全局命名空间的清洁。不要添加不需要与模块中的其他范围共享的全局变量。例如，使用main()函数来封装真正的本地人。

另外，添加unittesting。没有（甚至只是几个）测试的重构总是容易产生错误。

Answer 3

正如@bers 所提到的，@skykings 的装饰器破坏了函数内部的大多数 Python 功能，例如 print() 和 import 语句。 @bers 通过在装饰器定义时添加当前从 import 导入的模块来绕过 globals() 语句。

这激发了我编写另一个装饰器，希望它能够满足大多数来看这篇文章的人真正想要的。潜在的问题是，以前的装饰器创建的新函数缺少 __builtins__ 变量，该变量包含新打开的解释器中可用的所有标准内置 Python 函数（例如 print）。

import types
import builtins

def no_globals(f):
    '''
    A function decorator that prevents functions from looking up variables in outer scope.
    '''
    # need builtins in globals otherwise can't import or print inside the function
    new_globals = {'__builtins__': builtins} 
    new_f = types.FunctionType(f.__code__, globals=new_globals, argdefs=f.__defaults__)
    new_f.__annotations__ = f.__annotations__ # for some reason annotations aren't copied over
    return new_f

那么用法如下

@no_globals
def f1():
    return x

x = 5
f1() # should raise NameError

@no_globals
def f2(x):
    import numpy as np
    print(x)
    return np.sin(x)

x = 5
f2(x) # should print 5 and return -0.9589242746631385

Answer 4

To discourage global variable lookup, move your function into another module. Unless it inspects the call stack or imports your calling module explicitly; it won't have access to the globals from the module that calls it.

In practice, move your code into a main() function, to avoid creating unnecessary global variables.

If you use globals because several functions need to manipulate shared state then move the code into a class.

Answer 5

理论上，您可以使用自己的装饰器在函数调用时删除globals()。隐藏所有globals()是一些开销，但是，如果没有太多globals()，它可能会有用。在操作期间，我们不创建/删除全局对象，我们只是覆盖字典中引用全局对象的引用。但是不要删除特殊的globals()（如__builtins__）和模块。可能您也不想从全局范围中删除callable。

from types import ModuleType
import re

# the decorator to hide global variables
def noglobs(f):
    def inner(*args, **kwargs):
        RE_NOREPLACE = '__\w+__'
        old_globals = {}
        # removing keys from globals() storing global values in old_globals
        for key, val in globals().iteritems():
            if re.match(RE_NOREPLACE, key) is None and not isinstance(val, ModuleType) and not callable(val):
                old_globals.update({key: val})

        for key in old_globals.keys():
            del globals()[key]  
        result = f(*args, **kwargs)
        # restoring globals
        for key in old_globals.iterkeys():
            globals()[key] = old_globals[key]
        return result
    return inner

# the example of usage
global_var = 'hello'

@noglobs
def no_globals_func():
    try:
        print 'Can I use %s here?' % global_var
    except NameError:
        print 'Name "global_var" in unavailable here'

def globals_func():
    print 'Can I use %s here?' % global_var 

globals_func()
no_globals_func()
print 'Can I use %s here?' % global_var

...

Can I use hello here?
Name "global_var" in unavailable here
Can I use hello here?

或者，您可以迭代模块中的所有全局callables（即函数）并动态修饰它们（它的代码更多）。

代码适用于Python 2，我认为可以为Python 3创建非常相似的代码。

Answer 6

有了@skyking的回答，我无法访问任何导入（我什至无法使用print）。此外，带有可选参数的函数也已损坏（比较How can an optional parameter become required?）。

@ Ax3l的评论对此有所改善。仍然无法访问导入的变量（from module import var）。

因此，我建议这样做：

def noglobal(f):
    return types.FunctionType(f.__code__, globals().copy(), f.__name__, f.__defaults__, f.__closure__)

对于每个装饰有@noglobal的功能，该函数都会创建到目前为止定义的globals() 的副本。这样可以使导入的变量（通常在文档顶部导入）可访问。如果像我一样做，首先定义函数，然后定义变量，则可以实现预期的效果，即能够访问函数中的导入变量，但不能访问代码中定义的变量。由于copy()创建了一个浅表副本（Understanding dict.copy() - shallow or deep?），因此这也应该在内存上非常有效。

请注意，通过这种方式，一个函数只能调用自身之上定义的函数，因此您可能需要对代码重新排序。

为记录起见，我从his Gist复制了@ Ax3l的版本：

def imports():
    for name, val in globals().items():
        # module imports
        if isinstance(val, types.ModuleType):
            yield name, val
        # functions / callables
        if hasattr(val, '__call__'):
            yield name, val

noglobal = lambda fn: types.FunctionType(fn.__code__, dict(imports()))

在Python中禁用全局变量查找

6 个答案: