Quais são alguns usos comuns para decoradores de Python? [fechadas]

Embora eu goste de me considerar um codificador Python razoavelmente competente, um aspecto da linguagem que nunca consegui entender são os decoradores.

Sei o que são (superficialmente), li tutoriais, exemplos, perguntas sobre o Stack Overflow e entendo a sintaxe, posso escrever minha própria, ocasionalmente use @classmethod e @staticmethod, mas nunca me ocorre usar um decorador para resolver um problema no meu próprio código Python. Nunca encontro um problema em que penso: "Hmm ... isso parece um trabalho para um decorador!"

Então, eu estou querendo saber se vocês podem oferecer alguns exemplos de onde você usou decoradores em seus próprios programas, e espero ter um "A-ha!" momento e obtê- los.

Eu uso decoradores principalmente para fins de tempo

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

Eu os usei para sincronização.

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

Conforme apontado nos comentários, desde o Python 2.5 você pode usar uma withdeclaração em conjunto com um objeto threading.Lock(ou multiprocessing.Lockdesde a versão 2.6) para simplificar a implementação do decorador para apenas:

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

Independentemente disso, você o usa assim:

import threading
lock = threading.Lock()

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

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

Basicamente, apenas coloca lock.acquire()/ lock.release()em ambos os lados da chamada de função.

Uso decoradores para parâmetros de verificação de tipo que são passados ​​para meus métodos Python por meio de alguma RMI. Então, em vez de repetir o mesmo parâmetro de contagem, crie mumbo-jumbo de exceção várias vezes.

Por exemplo, em vez de:

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

Eu apenas declaro:

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

e accepts()faz todo o trabalho para mim.

Os decoradores são usados ​​para qualquer coisa que você queira "envolver" de forma transparente com funcionalidade adicional.

O Django os usa para agrupar a funcionalidade "login required" nas funções de visualização , bem como para registrar funções de filtro .

Você pode usar decoradores de classe para adicionar logs nomeados às classes .

Qualquer funcionalidade suficientemente genérica que você possa "aderir" a uma classe ou comportamento de função existente é um jogo justo para decoração.

Há também uma discussão de casos de uso no grupo de notícias Python-Dev apontado pelo PEP 318 - Decoradores de funções e métodos .

Para testes nos, você pode escrever um decorador que forneça uma função ou método de teste de unidade com vários conjuntos de parâmetros:

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

A biblioteca Twisted usa decoradores combinados com geradores para dar a ilusão de que uma função assíncrona é síncrona. Por exemplo:

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

Usando isso, o código que teria sido dividido em várias funções de retorno de chamada pode ser escrito naturalmente como um único bloco, facilitando muito o entendimento e a manutenção.

Um uso óbvio é para o log, é claro:

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

Eu os uso principalmente para depuração (wrapper em torno de uma função que imprime seus argumentos e resultado) e verificação (por exemplo, para verificar se um argumento é do tipo correto ou, no caso de aplicativo da Web, se o usuário tem privilégios suficientes para chamar um determinado método).

Estou usando o decorador a seguir para tornar uma função segura para threads. Isso torna o código mais legível. É quase semelhante ao proposto por John Fouhy, mas a diferença é que se trabalha em uma única função e que não há necessidade de criar explicitamente um objeto de bloqueio.

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

Decoradores são usados ​​para definir as propriedades de uma função ou como um padrão que a altera; é possível, mas é contra-intuitivo retornar funções completamente diferentes. Observando as outras respostas aqui, parece que um dos usos mais comuns é limitar o escopo de outro processo - seja log, criação de perfil, verificações de segurança, etc.

CherryPy usa o envio de objetos para corresponder URLs a objetos e, eventualmente, métodos. Decoradores sobre esses métodos sinalizar ou não CherryPy é ainda permitido usar esses métodos. Por exemplo, adaptado do tutorial :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Eu os usei recentemente, enquanto trabalhava em aplicativos da Web para redes sociais. Para Comunidade / Grupos, eu deveria dar autorização de associação para criar uma nova discussão e responder a uma mensagem de que você precisa ser membro desse grupo específico. Então, eu escrevi um decorador @membership_requirede coloquei o que eu precisava na minha opinião.

Eu uso esse decorador para corrigir parâmetro

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

isto escrito quando refatorar algumas funções precisa passar o argumento "wanN", mas nos meus códigos antigos eu passei somente N ou 'N'

O Decorator pode ser usado para criar facilmente variáveis ​​de método de função.

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