Quali sono alcuni usi comuni per i decoratori di Python? [chiuso]

Mentre mi piace pensare a me stesso come un programmatore Python ragionevolmente competente, un aspetto del linguaggio che non sono mai stato in grado di comprendere è il decoratore.

So cosa sono (superficialmente), ho letto tutorial, esempi, domande su Stack Overflow e capisco la sintassi, posso scrivere il mio, ogni tanto uso @classmethod e @staticmethod, ma non mi viene mai in mente di usare un decoratore per risolvere un problema nel mio codice Python. Non ho mai riscontrato un problema in cui penso "Hmm ... questo sembra un lavoro per un decoratore!"

Quindi, mi chiedo se voi ragazzi potreste offrire alcuni esempi di dove avete usato decoratori nei vostri programmi, e spero che avrò un "A-ha!" momento e ottenerli .

Uso i decoratori principalmente per scopi di cronometraggio

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

Li ho usati per la sincronizzazione.

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

Come sottolineato nei commenti, da Python 2.5 è possibile utilizzare withun'istruzione in combinazione con un oggetto threading.Lock(o multiprocessing.Lockdalla versione 2.6) per semplificare l'implementazione del decoratore solo per:

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

Indipendentemente da ciò, lo usi in questo modo:

import threading
lock = threading.Lock()

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

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

Fondamentalmente mette lock.acquire()/ lock.release()su entrambi i lati della chiamata di funzione.

Uso i decoratori per i parametri di controllo del tipo che vengono passati ai miei metodi Python tramite alcuni RMI. Quindi, invece di ripetere lo stesso conteggio dei parametri, aumentare le eccezioni mumbo-jumbo ancora e ancora.

Ad esempio, anziché:

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

Dichiaro solo:

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

e accepts()fa tutto il lavoro per me.

I decoratori vengono utilizzati per tutto ciò che si desidera "avvolgere" in modo trasparente con funzionalità aggiuntive.

Django li usa per racchiudere la funzionalità "login richiesto" nelle funzioni di visualizzazione , nonché per registrare le funzioni di filtro .

È possibile utilizzare i decoratori di classi per aggiungere registri con nome alle classi .

Qualsiasi funzionalità sufficientemente generica da "attaccare" al comportamento di una classe o di una funzione esistente è un gioco equo per la decorazione.

C'è anche una discussione sui casi d'uso nel newsgroup Python-Dev indicato da PEP 318 - Decoratori per funzioni e metodi .

Per i nosetest, puoi scrivere un decoratore che fornisce una funzione o un metodo di unit test con diversi set di parametri:

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

La libreria Twisted utilizza decoratori combinati con generatori per dare l'illusione che una funzione asincrona sia sincrona. Per esempio:

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

Usando questo, il codice che sarebbe stato suddiviso in tonnellate di piccole funzioni di callback può essere scritto in modo abbastanza naturale come un singolo blocco, rendendo molto più facile da capire e mantenere.

Un uso ovvio è per la registrazione, ovviamente:

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

Li uso principalmente per il debug (wrapper attorno a una funzione che stampa i suoi argomenti e risultati) e la verifica (ad esempio per verificare se un argomento è di tipo corretto o, nel caso di un'applicazione Web, se l'utente ha i privilegi sufficienti per chiamare un particolare metodo).

Sto usando il seguente decoratore per creare una funzione thread-safe. Rende il codice più leggibile. È quasi simile a quello proposto da John Fouhy, ma la differenza è che si lavora su una singola funzione e che non è necessario creare esplicitamente un oggetto lock.

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

I decoratori vengono utilizzati per definire le proprietà di una funzione o come boilerplate che la altera; è possibile ma controintuitivo per loro restituire funzioni completamente diverse. Osservando le altre risposte qui, sembra che uno degli usi più comuni sia quello di limitare l'ambito di qualche altro processo: registrazione, profilazione, controlli di sicurezza, ecc.

CherryPy utilizza il dispacciamento degli oggetti per abbinare gli URL agli oggetti e, eventualmente, ai metodi. I decoratori di questi metodi segnalano se CherryPy è autorizzato o meno a utilizzare tali metodi. Ad esempio, adattato dal tutorial :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Li ho usati di recente, mentre lavoravo su un'applicazione web di social network. Per la comunità / i gruppi, avrei dovuto autorizzare l'adesione a creare nuove discussioni e rispondere a un messaggio che devi essere membro di quel particolare gruppo. Quindi, ho scritto un decoratore @membership_requirede l'ho messo dove avevo richiesto dal mio punto di vista.

Uso questo decoratore per correggere i parametri

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']

questo scritto quando refactoring alcune funzioni devono passare l'argomento "wanN" ma nei miei vecchi codici, ho passato solo N o "N"

Decorator può essere utilizzato per creare facilmente variabili del metodo di funzione.

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