¿Cuáles son algunos usos comunes de los decoradores de Python? [closed]

Si bien me gusta considerarme un codificador de Python razonablemente competente, un aspecto del lenguaje que nunca he podido asimilar son los decoradores.

Sé lo que son (superficialmente), he leído tutoriales, ejemplos, preguntas sobre Stack Overflow y entiendo la sintaxis, puedo escribir la mía, ocasionalmente uso @classmethod y @staticmethod, pero nunca se me ocurre usar un decorador para resolver un problema en mi propio código de Python. Nunca me encuentro con un problema en el que pienso, “Hmm… ¡este parece un trabajo para un decorador!”

Entonces, me pregunto si ustedes podrían ofrecer algunos ejemplos de dónde han usado decoradores en sus propios programas, y espero tener un “¡Ajá!” momento y obtener a ellos.

Utilizo decoradores principalmente para fines de sincronización.

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

Los he usado para la sincronizació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

Como se señaló en los comentarios, desde Python 2.5 puedes usar un with declaración junto con una threading.Lock (o multiprocessing.Lock desde la versión 2.6) para simplificar la implementación del decorador a solo:

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

De todos modos, luego lo usas así:

import threading
lock = threading.Lock()

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

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

Básicamente solo pone lock.acquire() / lock.release() a ambos lados de la llamada de función.

Utilizo decoradores para los parámetros de verificación de tipo que se pasan a mis métodos de Python a través de algún RMI. Entonces, en lugar de repetir el mismo conteo de parámetros, genera excepciones una y otra vez.

Por ejemplo, en lugar de:

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

solo declaro:

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

y accepts() hace todo el trabajo por mí.

Los decoradores se utilizan para cualquier cosa que desee “envolver” de forma transparente con funcionalidad adicional.

Django los usa para envolver Funcionalidad de “inicio de sesión requerido” en las funciones de vistaasí como para registro de funciones de filtro.

Puede usar decoradores de clase para agregar registros con nombre a las clases.

Cualquier funcionalidad suficientemente genérica que pueda “añadir” al comportamiento de una clase o función existente es un juego justo para la decoración.

También hay un discusión de casos de uso en el grupo de noticias Python-Dev señalado por PEP 318 — Decoradores de Funciones y Métodos.

Para las pruebas de nariz, puede escribir un decorador que suministre una función o método de prueba unitaria con varios conjuntos de parámetros:

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

La biblioteca Twisted utiliza decoradores combinados con generadores para dar la ilusión de que una función asíncrona es síncrona. Por ejemplo:

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

Usando esto, el código que se habría dividido en un montón de pequeñas funciones de devolución de llamada se puede escribir de forma bastante natural como un solo bloque, lo que lo hace mucho más fácil de entender y mantener.

Un uso obvio es para iniciar sesión, por supuesto:

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