Quelles sont les utilisations courantes des décorateurs Python ?

Question

Bien que j'aime à penser que je suis un codeur Python raisonnablement compétent, les décorateurs sont un aspect du langage que je n'ai jamais réussi à maîtriser.

Je sais ce qu'ils sont (superficiellement), j'ai lu des tutoriels, des exemples, des questions sur Stack Overflow, et je comprends la syntaxe, je peux écrire les miens, utiliser occasionnellement @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 me dis : "Hmm... ça ressemble à un travail pour un décorateur !".

Je me demandais donc si vous pouviez me donner des exemples d'utilisation de décorateurs dans vos propres programmes, et j'espère que j'aurai un moment "A-ha ! obtenir les.

Answer 1

J'utilise les décorateurs principalement pour des raisons de timing

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

Answer 2

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 un fichier with dans le cadre d'une threading.Lock (ou multiprocessing.Lock depuis la version 2.6) pour simplifier l'implémentation du décorateur en le réduisant à un simple objet :

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

En gros, ça met juste lock.acquire() / lock.release() de part et d'autre de l'appel de fonction.

Answer 3

J'utilise les décorateurs pour vérifier le type des paramètres qui sont passés à mes méthodes Python via un RMI. Ainsi, au lieu de répéter encore et encore le même charabia de comptage de paramètres et de levée d'exceptions.

Par exemple, au lieu de :

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

Je viens de déclarer :

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

et accepts() fait tout le travail pour moi.

Answer 4

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 envelopper fonctionnalité "login requis" sur les fonctions de vue ainsi que pour enregistrement des fonctions du filtre .

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

Toute fonctionnalité suffisamment générique que vous pouvez ajouter au comportement d'une classe ou d'une fonction existante peut être décorée.

Il y a aussi un discussion des cas d'utilisation sur le newsgroup Python-Dev indiqué par PEP 318 -- Les décorateurs pour les fonctions et les méthodes .

Answer 5

Voici un très bon tutoriel avec de bons exemples

Bruce Eckel sur les décorateurs

Exemple : un système de construction basé sur les décorateurs

J'ai trouvé l'article très utile.