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

Si bien me gusta pensar en mí mismo como un codificador de Python razonablemente competente, un aspecto del lenguaje que nunca he podido entender son los decoradores.

Sé cuáles 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 Python. Nunca encuentro un problema en el que pienso, "Hmm ... ¡esto 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 "¡A-ha!" momento y conseguirlos .

Yo uso decoradores principalmente para propósitos de tiempo

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 puede usar una withdeclaración junto con un objeto threading.Lock(o multiprocessing.Lockdesde la versión 2.6) para simplificar la implementación del decorador para simplemente:

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, entonces 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 cada lado de la llamada a la 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 alguna RMI. Entonces, en lugar de repetir el mismo recuento de parámetros, mumbo-jumbo que 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 la funcionalidad de "inicio de sesión requerido" en las funciones de visualización , así como para registrar funciones de filtro .

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

Cualquier funcionalidad suficientemente genérica que pueda "agregar" al comportamiento de una clase o función existente es un juego justo para la decoración.

También hay una discusión de casos de uso en el grupo de noticias Python-Dev señalado por PEP 318 - Decoradores para funciones y métodos .

Para las pruebas nasales, puede escribir un decorador que proporcione 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 usa decoradores combinados con generadores para dar la ilusión de que una función asincrónica es sincrónica. Por ejemplo:

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

Con 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 natural como un solo bloque, lo que hace que sea 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()

Los uso principalmente para la depuración (envoltura alrededor de una función que imprime sus argumentos y resultados) y verificación (por ejemplo, para verificar si un argumento es del tipo correcto o, en el caso de una aplicación web, si el usuario tiene suficientes privilegios para llamar a un particular método).

Estoy usando el siguiente decorador para hacer que una función sea segura. Hace que el código sea más legible. Es casi similar al propuesto por John Fouhy, pero la diferencia es que uno trabaja en una sola función y que no hay necesidad de crear un objeto de bloqueo explícitamente.

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

Los decoradores se usan para definir las propiedades de una función o como repetitivo que la altera; Es posible, pero contra-intuitivo, que devuelvan funciones completamente diferentes. Mirando las otras respuestas aquí, parece que uno de los usos más comunes es limitar el alcance de algún otro proceso, ya sea registro, creación de perfiles, controles de seguridad, etc.

CherryPy utiliza el envío de objetos para hacer coincidir las URL con los objetos y, finalmente, los métodos. Los decoradores en esos métodos indican si CherryPy incluso tiene permitido usar esos métodos. Por ejemplo, adaptado del tutorial :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Los usé recientemente, mientras trabajaba en la aplicación web de redes sociales. Para la comunidad / grupos, se suponía que debía autorizar la membresía para crear una nueva discusión y responder a un mensaje de que debe ser miembro de ese grupo en particular. Entonces, escribí un decorador @membership_requiredy lo puse donde lo requería en mi opinión.

Yo uso este decorador para arreglar el 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']

esto está escrito cuando refactorizo ​​algunas funciones necesitan pasar el argumento "wanN" pero en mis viejos códigos, pasé N o 'N' solamente

Decorator se puede utilizar para crear fácilmente variables de método de funció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