Как ввести переменную в область видимости с помощью декоратора?

Вы не можете. Имена с ограниченной областью (замыкания) определяются во время компиляции, вы не можете добавить больше во время выполнения.

Лучшее, на что вы можете надеяться, это добавить глобальные имена, используя собственное глобальное пространство имен функции:

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 в глобальной области видимости непосредственно.

Обратите внимание, что изменение глобальных переменных не является потокобезопасным, и любые временные вызовы других функций в том же модуле также будут видеть эту же глобальную переменную.

Есть простой способ делать то, что вы хотите, без использования глобальной переменной. Если вы хотите быть апатридом и потокобезопасным, у вас действительно нет выбора.

Используйте переменную 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()

Вы не можете. 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()

У меня работает обновление __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

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'

Я нашел интересный пост, предлагающий другое решение, создавая функции на лету. В основном:

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/.

Вот простая демонстрация использования декоратора для добавления переменной в область действия функции.

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

Вместо того, чтобы пересматривать глобальную область видимости, более разумно изменить саму аннотированную функцию.

Я поймал проблему с решением, использующим глобальные переменные.

Контекст глобальных переменных может быть перезаписан при наличии нескольких одновременных запросов. Я думал, что это невозможно, но это так - через некоторое время я поймал изменение контекста (глобальные), если запрос не был быстрым. Лучшее решение - передать переменную с помощью 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)

Вам нужно будет добавить дополнительный параметр к каждой украшенной функции.