Was sind einige häufige Verwendungszwecke für Python-Dekoratoren? [geschlossen]

Während ich mich gerne als einigermaßen kompetenten Python-Codierer betrachte, ist ein Aspekt der Sprache, die ich nie beherrschen konnte, Dekorateure.

Ich weiß, was sie sind (oberflächlich), ich habe Tutorials, Beispiele und Fragen zum Stapelüberlauf gelesen und ich verstehe die Syntax, kann meine eigene schreiben, gelegentlich @classmethod und @staticmethod verwenden, aber mir fällt nie ein, a zu verwenden Dekorateur, um ein Problem in meinem eigenen Python-Code zu lösen. Ich stoße nie auf ein Problem, bei dem ich denke: "Hmm ... das sieht nach einem Job für einen Dekorateur aus!"

Ich frage mich also, ob ihr vielleicht einige Beispiele dafür anbietet, wo ihr Dekorateure in euren eigenen Programmen verwendet habt, und hoffentlich habe ich ein "A-ha!" Moment und hol sie dir .

Ich benutze Dekorateure hauptsächlich für Timing-Zwecke

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

Ich habe sie für die Synchronisation verwendet.

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

Wie in den Kommentaren erwähnt, können Sie seit Python 2.5 eine withAnweisung in Verbindung mit einem Objekt threading.Lock(oder multiprocessing.Lockseit Version 2.6) verwenden, um die Implementierung des Dekorateurs auf Folgendes zu vereinfachen:

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

Unabhängig davon verwenden Sie es dann wie folgt:

import threading
lock = threading.Lock()

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

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

Grundsätzlich wird nur lock.acquire()/ lock.release()auf beiden Seiten des Funktionsaufrufs platziert.

Ich verwende Dekoratoren zur Typprüfung von Parametern, die über ein RMI an meine Python-Methoden übergeben werden. Anstatt die gleiche Parameterzählung zu wiederholen, wird immer wieder Mumbo-Jumbo ausgelöst.

Zum Beispiel anstelle von:

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

Ich erkläre nur:

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

und accepts()erledigt die ganze Arbeit für mich.

Dekorateure werden für alles verwendet, was Sie transparent mit zusätzlichen Funktionen "umhüllen" möchten.

Django verwendet sie zum Umschließen der Funktionen "Anmeldung erforderlich" in Ansichtsfunktionen sowie zum Registrieren von Filterfunktionen .

Sie können Klassendekoratoren verwenden, um benannte Protokolle zu Klassen hinzuzufügen .

Jede ausreichend allgemeine Funktionalität, die Sie an das Verhalten einer vorhandenen Klasse oder Funktion "anheften" können, ist ein faires Spiel für die Dekoration.

Es gibt auch eine Diskussion über Anwendungsfälle in der Python-Dev-Newsgroup, auf die PEP 318 - Decorators for Functions and Methods hinweist .

Für Nasentests können Sie einen Dekorateur schreiben, der eine Unit-Test-Funktion oder -Methode mit mehreren Parametersätzen bereitstellt:

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

Die Twisted-Bibliothek verwendet Dekoratoren in Kombination mit Generatoren, um die Illusion zu erzeugen, dass eine asynchrone Funktion synchron ist. Zum Beispiel:

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

Auf diese Weise kann Code, der in eine Menge kleiner Rückruffunktionen aufgeteilt worden wäre, ganz natürlich als einzelner Block geschrieben werden, was das Verständnis und die Wartung erheblich vereinfacht.

Eine offensichtliche Verwendung ist natürlich die Protokollierung:

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

Ich verwende sie hauptsächlich zum Debuggen (Wrapper um eine Funktion, die ihre Argumente und Ergebnisse druckt) und zur Überprüfung (z. B. um zu überprüfen, ob ein Argument vom richtigen Typ ist oder ob der Benutzer im Fall einer Webanwendung über ausreichende Berechtigungen zum Aufrufen einer bestimmten Funktion verfügt Methode).

Ich verwende den folgenden Dekorator, um eine Funktion threadsicher zu machen. Dadurch wird der Code besser lesbar. Es ist fast ähnlich wie das von John Fouhy vorgeschlagene, aber der Unterschied besteht darin, dass man an einer einzelnen Funktion arbeitet und dass es nicht notwendig ist, ein Sperrobjekt explizit zu erstellen.

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

Dekorateure werden entweder verwendet, um die Eigenschaften einer Funktion zu definieren, oder als Boilerplate, das sie ändert. Es ist möglich, aber nicht intuitiv, völlig unterschiedliche Funktionen zurückzugeben. Wenn man sich die anderen Antworten hier ansieht, scheint es eine der häufigsten Anwendungen zu sein, den Umfang eines anderen Prozesses einzuschränken - sei es Protokollierung, Profilerstellung, Sicherheitsüberprüfungen usw.

CherryPy verwendet das Versenden von Objekten, um URLs mit Objekten und schließlich Methoden abzugleichen. Dekorateure dieser Methoden signalisieren, ob CherryPy diese Methoden überhaupt verwenden darf oder nicht . Zum Beispiel aus dem Tutorial angepasst :

class HelloWorld:

    ...

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

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

cherrypy.quickstart(HelloWorld())

Ich habe sie kürzlich verwendet, als ich an einer Webanwendung für soziale Netzwerke gearbeitet habe. Für Community / Gruppen sollte ich die Berechtigung zur Mitgliedschaft erteilen, um eine neue Diskussion zu erstellen und auf eine Nachricht zu antworten, dass Sie Mitglied dieser bestimmten Gruppe sein müssen. Also schrieb ich einen Dekorateur @membership_requiredund stellte das, was ich brauchte, in meine Sicht.

Ich benutze diesen Dekorator, um Parameter zu korrigieren

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

Dies wurde geschrieben, wenn ich einige Funktionen umgestalte, die das Argument "wanN" übergeben müssen, aber in meinen alten Codes habe ich nur N oder 'N' übergeben

Mit Decorator können auf einfache Weise Funktionsmethodenvariablen erstellt werden.

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