Quelles sont les utilisations courantes des décorateurs Python? [fermé]

Bien que j'aime à me considérer comme un codeur Python raisonnablement compétent, un des aspects du langage que je n'ai jamais réussi à comprendre est celui des décorateurs.

Je sais ce que c'est (superficiellement), j'ai lu des tutoriels, des exemples, des questions sur Stack Overflow, et je comprends la syntaxe, je peux écrire la mienne, parfois utiliser @classmethod et @staticmethod, mais il ne m'est jamais venu à l'esprit d'utiliser un décorateur pour résoudre un problème dans mon propre code Python. Je ne rencontre jamais un problème où je pense, "Hmm ... cela ressemble à un travail pour un décorateur!"

Donc, je me demande si vous pourriez offrir des exemples où vous avez utilisé des décorateurs dans vos propres programmes, et j'espère que j'aurai un "A-ha!" moment et les obtenir .

J'utilise des décorateurs principalement à des fins de synchronisation

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

Je les ai utilisés pour la synchronisation.

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

Comme indiqué dans les commentaires, depuis Python 2.5, vous pouvez utiliser une withinstruction en conjonction avec un objet threading.Lock(ou multiprocessing.Lockdepuis la version 2.6) pour simplifier l'implémentation du décorateur pour simplement:

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

Quoi qu'il en soit, vous l'utilisez ensuite comme ceci:

import threading
lock = threading.Lock()

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

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

Fondamentalement, il place simplement lock.acquire()/ lock.release()de chaque côté de l'appel de fonction.

J'utilise des décorateurs pour les paramètres de vérification de type qui sont passés à mes méthodes Python via certains RMI. Donc, au lieu de répéter le même comptage de paramètres, le mumbo-jumbo qui soulève des exceptions encore et encore.

Par exemple, au lieu de:

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

Je déclare simplement:

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

et accepts()fait tout le travail pour moi.

Les décorateurs sont utilisés pour tout ce que vous souhaitez «envelopper» de manière transparente avec des fonctionnalités supplémentaires.

Django les utilise pour encapsuler la fonctionnalité "connexion requise" sur les fonctions d'affichage , ainsi que pour enregistrer les fonctions de filtre .

Vous pouvez utiliser des décorateurs de classe pour ajouter des journaux nommés aux classes .

Toute fonctionnalité suffisamment générique sur laquelle vous pouvez vous "accrocher" au comportement d'une classe ou d'une fonction existante est un jeu équitable pour la décoration.

Il y a aussi une discussion sur les cas d'utilisation sur le groupe de discussion Python-Dev pointé par PEP 318 - Décorateurs pour les fonctions et méthodes .

Pour les tests noset, vous pouvez écrire un décorateur qui fournit une fonction ou une méthode de test unitaire avec plusieurs ensembles de paramètres:

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

La bibliothèque Twisted utilise des décorateurs combinés à des générateurs pour donner l'illusion qu'une fonction asynchrone est synchrone. Par exemple:

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

En utilisant cela, le code qui aurait été décomposé en une tonne de petites fonctions de rappel peut être écrit tout naturellement en un seul bloc, ce qui le rend beaucoup plus facile à comprendre et à maintenir.

Une utilisation évidente est bien sûr pour la journalisation:

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

Je les utilise principalement pour le débogage (wrapper autour d'une fonction qui affiche ses arguments et ses résultats) et la vérification (par exemple pour vérifier si un argument est de type correct ou, dans le cas d'une application Web, si l'utilisateur a les privilèges suffisants pour appeler un particulier méthode).

J'utilise le décorateur suivant pour créer une fonction threadsafe. Cela rend le code plus lisible. Elle est presque similaire à celle proposée par John Fouhy mais la différence est que l'on travaille sur une seule fonction et qu'il n'est pas nécessaire de créer explicitement un objet verrou.

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

Les décorateurs sont utilisés soit pour définir les propriétés d'une fonction, soit comme passe-partout qui la modifie; il est possible mais contre-intuitif pour eux de retourner des fonctions complètement différentes. En regardant les autres réponses ici, il semble que l'une des utilisations les plus courantes consiste à limiter la portée d'un autre processus - que ce soit la journalisation, le profilage, les contrôles de sécurité, etc.

CherryPy utilise la répartition des objets pour faire correspondre les URL aux objets et, éventuellement, aux méthodes. Les décorateurs de ces méthodes indiquent si CherryPy est même autorisé à utiliser ces méthodes. Par exemple, adapté du tutoriel :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Je les ai utilisés récemment, tout en travaillant sur une application Web de réseautage social. Pour la communauté / les groupes, j'étais censé donner l'autorisation d'adhésion pour créer une nouvelle discussion et répondre à un message que vous devez être membre de ce groupe particulier. J'ai donc écrit un décorateur @membership_requiredet je l'ai mis là où je le souhaitais à mon avis.

J'utilise ce décorateur pour fixer le paramètre

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

ceci écrit quand je refactorise certaines fonctions qui doivent passer l'argument "wanN" mais dans mes anciens codes, je ne passe que N ou 'N'

Decorator peut être utilisé pour créer facilement des variables de méthode de fonction.

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