Question

[免责声明：可能有更多的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。

有没有办法做这样的事情？

Answer 1

你做不到。在编译时确定范围名称（闭包），在运行时不能添加更多。

您可以实现的最佳目标是使用函数的拥有全局命名空间添加全局名称：

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，而不是装饰。

请注意，更改全局变量不是线程安全的，并且对同一模块中的其他函数的任何瞬态调用仍将看到相同的全局变量。

Answer 2

你做不到。 Python有词法范围。这意味着标识符的含义仅基于查看源代码时物理上围绕它的范围来确定。

Answer 3

这是一种将多个变量注入函数范围的方法，其方式与@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()

Answer 4

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'

Answer 5

有一种干净的方法可以在不使用全局变量的情况下执行您想要的操作。如果你想成为无国籍和线程安全，你实际上没有选择。

使用“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()

Answer 6

以下是使用装饰器将变量添加到函数范围内的简单演示。

>>> 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!
>>>

Answer 7

假设在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

Answer 8

t == 't'

与修改全局范围相比，更改带注释的函数本身更为合理。

Answer 9

更新__globals__对我有用。

def f():
    print(a)


def with_context(**kw):
    def deco(fn):
        g = fn.__globals__
        g.update(kw)
        return fn

    return deco


with_context(a=3)(f)() # 3

Answer 10

我发现使用全局变量的解决方案存在问题。

当您有多个并发请求时，全局上下文可能会被覆盖。我以为那是不可能的，但这是-过了一段时间，如果请求不是很快的话，我就会发现上下文（全局变量）的变化。更好的解决方案是使用kwargs传递变量：

def is_login(old_fuction):
    def new_function(request, *args, **kwargs):
        secret_token = request.COOKIES.get('secret_token')
        if secret_token:
            items = SomeModel.objects.get(cookie = secret_token)
            if len(items) > 0:
                item = items[0]
                kwargs['current_user'] = item
                return old_fuction(request, *args, **kwargs)
            else:
                return HttpResponse('error')
        return HttpResponse(status=404)
    return new_function

@is_login  
def some_func(request, current_user):
    return HttpResponse(current_user.name)

您必须为每个装饰函数添加额外的参数。

Answer 11

我发现一个有趣的帖子通过动态创建函数提供了不同的解决方案。基本上：

def wrapper(func):
    cust_globals = func.__globals__.copy()

    # Update cust_globals to your liking

    # Return a new function
    return types.FunctionType(
        func.__code__, cust_globals, func.__name__, func.__defaults__, func.__closure__
    )

请参见https://hardenedapple.github.io/stories/computers/python_function_override/

如何使用装饰器将变量注入范围？

11 个答案: