[免责声明：可能有更多pythonic方式做我想做的事情，但我想知道python的范围如何在这里工作]
我正在尝试找到一种方法来制作一个装饰器，它可以将名称注入到另一个函数的范围内（这样名称不会在装饰器的范围之外泄漏）。例如，如果我有一个函数说打印一个名为var但尚未定义的变量，我想在调用它的装饰器中定义它。这是一个打破的例子：
c = 'Message'
def decorator_factory(value):
def msg_decorator(f):
def inner_dec(*args, **kwargs):
var = value
res = f(*args, **kwargs)
return res
return inner_dec
return msg_decorator
@decorator_factory(c)
def msg_printer():
print var
msg_printer()
我想打印“Message”，但它给出：
NameError: global name 'var' is not defined
追溯甚至指向var定义：
<ipython-input-25-34b84bee70dc> in inner_dec(*args, **kwargs)
8 def inner_dec(*args, **kwargs):
9 var = value
---> 10 res = f(*args, **kwargs)
11 return res
12 return inner_dec
所以我不明白为什么它找不到var。
有没有办法做这样的事情？
你不能。范围名称（闭包）是在编译时确定的，您无法在运行时添加更多。
您可以希望实现的最好的方法是使用函数自己的全局命名空间添加全局名称：
def decorator_factory(value):
def msg_decorator(f):
def inner_dec(*args, **kwargs):
g = f.__globals__ # use f.func_globals for py < 2.6
sentinel = object()
oldvalue = g.get('var', sentinel)
g['var'] = value
try:
res = f(*args, **kwargs)
finally:
if oldvalue is sentinel:
del g['var']
else:
g['var'] = oldvalue
return res
return inner_dec
return msg_decorator
f.__globals__是包装函数的全局命名空间，因此即使装饰器位于不同的模块中也是如此。如果已将var定义为全局，则将其替换为新值，并在调用该函数后恢复全局变量。
这是有效的，因为函数中未分配给的任何名称在周围范围内找不到，而是标记为全局。
演示：
>>> c = 'Message'
>>> @decorator_factory(c)
... def msg_printer():
... print var
...
>>> msg_printer()
Message
>>> 'var' in globals()
False
但是，我可以直接在全球范围内定义var，而不是装饰。
请注意，更改全局变量不是线程安全的，并且对同一模块中的其他函数的任何瞬态调用仍将看到相同的全局变量。
你不能。 Python有词法范围。这意味着标识符的含义仅基于查看源代码时物理上围绕它的范围来确定。
这是一种将多个变量注入函数范围的方法，其方式与@Martijn Pieters在其答案中的方式类似。我发布它主要是因为它是一个更通用的解决方案，并且不需要多次应用来执行它 - 因为他需要做同样的事情（以及许多其他的）答案。
from functools import wraps
def inject_variables(context):
""" Decorator factory. """
def variable_injector(func):
@wraps(func)
def decorator(*args, **kwargs):
try:
func_globals = func.__globals__ # Python 2.6+
except AttributeError:
func_globals = func.func_globals # Earlier versions.
saved_values = func_globals.copy() # Shallow copy of dict.
func_globals.update(context)
try:
result = func(*args, **kwargs)
finally:
func_globals = saved_values # Undo changes.
return result
return decorator
return variable_injector
if __name__ == '__main__':
namespace = {'a': 5, 'b': 3}
@inject_variables(namespace)
def test():
print('a:', a)
print('b:', b)
test()
Python是词法范围的，所以我担心没有干净的方法来做你想要的东西而没有一些潜在的令人讨厌的副作用。我建议只通过装饰器将var传递给函数。
c = 'Message'
def decorator_factory(value):
def msg_decorator(f):
def inner_dec(*args, **kwargs):
res = f(value, *args, **kwargs)
return res
inner_dec.__name__ = f.__name__
inner_dec.__doc__ = f.__doc__
return inner_dec
return msg_decorator
@decorator_factory(c)
def msg_printer(var):
print var
msg_printer() # prints 'Message'
有一种干净的方法可以在不使用全局变量的情况下执行所需操作。如果你想成为无状态和线程安全，你真的没有选择。
使用“kwargs”变量：
c = 'Message'
def decorator_factory(value):
def msg_decorator(f):
def inner_dec(*args, **kwargs):
kwargs["var"] = value
res = f(*args, **kwargs)
return res
return inner_dec
return msg_decorator
@decorator_factory(c)
def msg_printer(*args, **kwargs):
print kwargs["var"]
msg_printer()
下面是使用装饰器将变量添加到函数范围的简单演示。
>>> def add_name(name):
... def inner(func):
... # Same as defining name within wrapped
... # function.
... func.func_globals['name'] = name
...
... # Simply returns wrapped function reference.
... return func
...
... return inner
...
>>> @add_name("Bobby")
... def say_hello():
... print "Hello %s!" % name
...
>>> print say_hello()
Hello Bobby!
>>>
假设在python函数中是对象，你可以做...
#!/usr/bin/python3
class DecorClass(object):
def __init__(self, arg1, arg2):
self.a1 = arg1
self.a2 = arg2
def __call__(self, function):
def wrapped(*args):
print('inside class decorator >>')
print('class members: {0}, {1}'.format(self.a1, self.a2))
print('wrapped function: {}'.format(args))
function(*args, self.a1, self.a2)
return wrapped
@DecorClass(1, 2)
def my_function(f1, f2, *args):
print('inside decorated function >>')
print('decorated function arguments: {0}, {1}'.format(f1, f2))
print('decorator class args: {}'.format(args))
if __name__ == '__main__':
my_function(3, 4)
结果是：
inside class decorator >>
class members: 1, 2
wrapped function: (3, 4)
inside decorated function >>
decorated function arguments: 3, 4
decorator class args: (1, 2)
更多解释在这里http://python-3-patterns-idioms-test.readthedocs.io/en/latest/PythonDecorators.html
def merge(d1, d2):
d = d1.copy()
d.update(d2)
return d
# A decorator to inject variables
def valueDecorator(*_args, **_kargs):
def wrapper(f):
def wrapper2(*args, **kargs):
return f(*args, **kargs)
wrapper2.__name__ = f.__name__
wrapper2.__doc__ = f.__doc__
oldVars = getattr(f, 'Vars', [])
oldNamedVars = getattr(f, 'NamedVars', {})
wrapper2.Vars = oldVars + list(_args)
wrapper2.NamedVars = merge(oldNamedVars, _kargs)
return wrapper2
return wrapper
@valueDecorator(12, 13, a=2)
@valueDecorator(10, 11, a=1)
def func():
print(func.Vars)
print(func.NamedVars)
更改注释函数本身不是修改全局范围，而是更合理。