Каковы некоторые общие применения для декораторов Python? [закрыто]

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

Я знаю, что они (поверхностно), я прочитал учебники, примеры, вопросы по переполнению стека, и я понимаю синтаксис, могу написать свой, иногда использовать @classmethod и @staticmethod, но мне никогда не приходит в голову использовать декоратор, чтобы решить проблему в моем собственном коде Python. Я никогда не сталкиваюсь с проблемой, когда думаю: «Хм ... это похоже на работу декоратора!»

Итак, мне интересно, если вы, ребята, могли бы предложить несколько примеров, где вы использовали декораторы в своих собственных программах, и, надеюсь, у меня будет "А-ха!" момент и получить их.

Я использую декораторы в основном для целей синхронизации

def time_dec(func):

  def wrapper(*arg):
      t = time.clock()
      res = func(*arg)
      print func.func_name, time.clock()-t
      return res

  return wrapper


@time_dec
def myFunction(n):
    ...

Я использовал их для синхронизации.

import functools

def synchronized(lock):
    """ Synchronization decorator """
    def wrap(f):
        @functools.wraps(f)
        def newFunction(*args, **kw):
            lock.acquire()
            try:
                return f(*args, **kw)
            finally:
                lock.release()
        return newFunction
    return wrap

Как указано в комментариях, начиная с Python 2.5 вы можете использовать withоператор в сочетании с threading.Lock(или multiprocessing.Lockначиная с версии 2.6) объектом, чтобы упростить реализацию декоратора до:

import functools

def synchronized(lock):
    """ Synchronization decorator """
    def wrap(f):
        @functools.wraps(f)
        def newFunction(*args, **kw):
            with lock:
                return f(*args, **kw)
        return newFunction
    return wrap

Независимо от этого, вы затем используете это так:

import threading
lock = threading.Lock()

@synchronized(lock)
def do_something():
  # etc

@synchronzied(lock)
def do_something_else():
  # etc

По сути, он просто ставит lock.acquire()/ lock.release()по обе стороны от вызова функции.

Я использую декораторы для проверки типов параметров, которые передаются моим методам Python через некоторые RMI. Таким образом, вместо того, чтобы повторять один и тот же подсчет параметров, снова и снова вызывать исключение mumbo-jumbo.

Например, вместо:

def myMethod(ID, name):
    if not (myIsType(ID, 'uint') and myIsType(name, 'utf8string')):
        raise BlaBlaException() ...

Я просто заявляю:

@accepts(uint, utf8string)
def myMethod(ID, name):
    ...

и accepts()делает всю работу за меня.

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

Django использует их для переноса функций «требуется вход в систему» ​​в функции просмотра , а также для регистрации функций фильтра .

Вы можете использовать декораторы классов для добавления именованных журналов в классы .

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

В группе новостей Python-Dev также обсуждаются варианты использования, на которые указывает PEP 318 - Декораторы для функций и методов .

Для тестирования носа вы можете написать декоратор, который предоставляет функцию или метод модульного тестирования с несколькими наборами параметров:

@parameters(
   (2, 4, 6),
   (5, 6, 11),
)
def test_add(a, b, expected):
    assert a + b == expected

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

@inlineCallbacks
def asyncf():
    doStuff()
    yield someAsynchronousCall()
    doStuff()
    yield someAsynchronousCall()
    doStuff()

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

Конечно, одно из очевидных применений - это регистрация:

import functools

def log(logger, level='info'):
    def log_decorator(fn):
        @functools.wraps(fn)
        def wrapper(*a, **kwa):
            getattr(logger, level)(fn.__name__)
            return fn(*a, **kwa)
        return wrapper
    return log_decorator

# later that day ...
@log(logging.getLogger('main'), level='warning')
def potentially_dangerous_function(times):
    for _ in xrange(times): rockets.get_rocket(NUCLEAR=True).fire()

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

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

def threadsafe_function(fn):
    """decorator making sure that the decorated function is thread safe"""
    lock = threading.Lock()
    def new(*args, **kwargs):
        lock.acquire()
        try:
            r = fn(*args, **kwargs)
        except Exception as e:
            raise e
        finally:
            lock.release()
        return r
    return new

class X:
    var = 0

    @threadsafe_function     
    def inc_var(self):
        X.var += 1    
        return X.var

Декораторы используются либо для определения свойств функции, либо как шаблон, который ее изменяет; для них возможно, но нелогично возвращать совершенно разные функции. Глядя на другие ответы здесь, кажется, что одним из наиболее распространенных применений является ограничение области действия какого-либо другого процесса - будь то ведение журнала, профилирование, проверки безопасности и т. Д.

CherryPy использует диспетчеризацию объектов для сопоставления URL-адресов с объектами и, в конечном итоге, с методами. Декораторы этих методов сообщают, разрешено ли CherryPy даже использовать эти методы. Например, адаптировано из учебника :

class HelloWorld:

    ...

    def secret(self):
        return "You shouldn't be here."

    @cherrypy.expose
    def index(self):
        return "Hello world!"

cherrypy.quickstart(HelloWorld())

Я использовал их недавно, работая над веб-приложением для социальных сетей. Что касается сообщества / групп, я должен был дать разрешение на членство для создания нового обсуждения и ответить на сообщение, что вы должны быть участником этой конкретной группы. Итак, я написал декоратор @membership_requiredи поставил его там, где мне нужно, на мой взгляд.

Я использую этот декоратор, чтобы исправить параметр

def fill_it(arg):
    if isinstance(arg, int):
        return "wan" + str(arg)
    else:
        try:
            # number present as string
            if str(int(arg)) == arg:
                return "wan" + arg
            else:
                # This should never happened
                raise Exception("I dont know this " + arg)
                print "What arg?"
        except ValueError, e:
            return arg

def fill_wanname(func):
    def wrapper(arg):
        filled = fill_it(arg)
        return func(filled)
    return wrapper

@fill_wanname
def get_iface_of(wanname):
    global __iface_config__
    return __iface_config__[wanname]['iface']

это написано, когда я выполняю рефакторинг, некоторые функции должны передавать аргумент "wanN", но в моих старых кодах я передал только N или 'N'

Декоратор может быть использован для простого создания переменных метода функции.

def static_var(varname, value):
    '''
    Decorator to create a static variable for the specified function
    @param varname: static variable name
    @param value: initial value for the variable
    '''
    def decorate(func):
        setattr(func, varname, value)
        return func
    return decorate

@static_var("count", 0)
def mainCallCount():
    mainCallCount.count += 1