Які існують для декораторів 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. Тож замість того, щоб повторювати один і той же підрахунок параметрів, мамо-джамбо, що підвищує винятки, знову і знову.

Наприклад, замість:

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