Details zum Python-Dekorator

Ein Dekorator ist im Wesentlichen eine Python-Funktion, die es anderen Funktionen ermöglicht, zusätzliche Funktionen hinzuzufügen, ohne Codeänderungen vorzunehmen. Der Rückgabewert des Dekorators ist ebenfalls ein Funktionsobjekt .

wird häufig in Szenarien mit übergreifenden Anforderungen verwendet, wie zum Beispiel: Protokolleinfügung, Leistungstests, Transaktionsverarbeitung, Caching, Berechtigungsüberprüfung usw. Dekoratoren sind ein hervorragendes Design zur Lösung dieser Art von Problemen. Mit Dekoratoren können wir eine große Menge ähnlichen Codes extrahieren, der nichts mit der Funktion selbst zu tun hat, und ihn weiterhin wiederverwenden.

Schauen wir uns zunächst ein einfaches Beispiel an:

def now():
    print('2017_7_29')

Jetzt gibt es eine neue Anforderung, das Ausführungsprotokoll der Funktion aufzuzeichnen, also füge ich den Protokollcode in den Code ein:

def now():
    print('2017_7_29')
    logging.warn("running")

假设有类似的多个需求，怎么做？再写一个logging在now函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码.

def use_logging(func):     
    logging.warn("%s is running" % func.__name__)     
    func()  
def now():     
    print('2017_7_29')    
use_logging(now)

In der Implementierung ist es logisch nicht schwierig, aber in diesem Fall müssen wir jedes Mal eine Funktion als Parameter an die Protokollfunktion übergeben. Darüber hinaus hat diese Methode die ursprüngliche logische Struktur des Codes zerstört. Bei der vorherigen Ausführung der Geschäftslogik wurde now() ausgeführt, jetzt muss sie jedoch in use_logging(now) geändert werden.

Gibt es also einen besseren Weg? Natürlich gibt es das, die Antwort lautet: Dekorateure.

Zunächst müssen Sie verstehen, dass eine Funktion auch ein Objekt ist und Funktionsobjekte Variablen zugewiesen werden können, sodass die Funktion auch über Variablen aufgerufen werden kann. Zum Beispiel:

(=

Einfacher Dekorator

Im Wesentlichen ist der Dekorator eine Funktion höherer Ordnung, die eine Funktion zurückgibt. Daher müssen wir einen Dekorator definieren, der Protokolle drucken kann, der wie folgt definiert werden kann:

def log(func):
    def wrapper(*args,**kw):
        print('call %s():'%func.__name__)
        return func(*args,**kw)
    return wrapper
# 由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，
# 只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
# wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。
# 在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

Das obige log akzeptiert eine Funktion als Parameter und gibt eine Funktion zurück, da es sich um einen Dekorator handelt. Führen Sie nun Folgendes aus:

now = log(now)
now()

rrree

Funktion log ist ein Dekorator. Er umschließt die Funktion, die die eigentliche Geschäftsmethode ausführt. Es sieht so aus, als ob sie jetzt durch log dekoriert wird. Wenn in diesem Beispiel die Funktion eintritt, wird sie als Aspekt (Aspekt) bezeichnet, und diese Programmiermethode wird als aspektorientierte Programmierung (aspektorientierte Programmierung) bezeichnet.

Verwenden Sie syntaktischen Zucker:

输出结果:
call now():
2017_7_28

@-Symbol ist syntaktischer Zucker für Dekorateure. Es wird beim Definieren von Funktionen verwendet, um eine weitere Zuweisungsoperation zu vermeiden.

Auf diese Weise können wir Ihnen helfen Sie können den Satz now = log(now) weglassen und now() direkt aufrufen, um das gewünschte Ergebnis zu erhalten. Wenn wir andere ähnliche Funktionen haben, können wir den Dekorator weiterhin aufrufen, um die Funktion zu dekorieren, ohne die Funktion wiederholt zu ändern oder neue Pakete hinzuzufügen. Dadurch verbessern wir die Wiederverwendbarkeit des Programms und erhöhen die Lesbarkeit des Programms.

Der Grund, warum Dekoratoren in Python so bequem zu verwenden sind, liegt darin, dass Python-Funktionen als Parameter an andere Funktionen wie gewöhnliche Objekte übergeben, anderen Variablen zugewiesen und als Rückgabewerte verwendet werden können . Kann innerhalb einer anderen Funktion definiert werden.

Dekorator mit Parametern:

Wenn der Dekorator selbst Parameter übergeben muss, müssen Sie eine Funktion auf hoher Ebene schreiben Das gibt den Dekorator zurück. Order-Funktionen sind etwas komplizierter zu schreiben. Um beispielsweise den Text des Protokolls anzupassen:

@logdef now():
    print('2017_7_28')

Dieser dreischichtige verschachtelte Dekorator wird wie folgt verwendet:

def log(text):
    def decorator(func):
            def wrapper(*args,**kw):
                        print('%s %s()'%(text,func.__name__))
                        return func(*args,**kw)        
            return wrapper    
     return decorator

entspricht

@log(()
now()

, weil wir gesagt haben dass Funktionen auch Objekte sind, sie haben Attribute wie __name__, aber wenn Sie sich die vom Dekorator dekorierten Funktionen ansehen, hat sich ihr __name__ vom ursprünglichen 'now' in 'wrapper' geändert:

<span style="color: #000000;">now = log('goal')(now)<br># 首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数<br>now()</span>

Aufgrund der zurückgegebenen Funktion wrapper() lautet der Name 'wrapper', daher müssen Sie die Attribute __name__ und andere Attribute der ursprünglichen Funktion in die Funktion wrapper() kopieren. Andernfalls ist ein Code erforderlich, der auf der Funktion basiert Die Signatur wird fehlerhaft ausgeführt.

Es ist nicht erforderlich, Code wie wrapper.__name__ = func.__name__ zu schreiben. Daher wird ein vollständiger Dekorator wie folgt geschrieben: functools.wraps

print(now.__name__)# wrapper

rrree

Klassendekoration Gerät :

Schauen wir uns Klassendekoratoren an. Im Vergleich zu Funktionsdekoratoren haben Klassendekoratoren die Vorteile größerer Flexibilität, hoher Kohäsion und Kapselung. Die Verwendung von Klassendekoratoren kann auch auf die Methode __call__ innerhalb der Klasse zurückgreifen. Diese Methode wird aufgerufen, wenn der Dekorator mithilfe der @-Form an eine Funktion angehängt wird

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

Zusammenfassung:

Verallgemeinert Mit anderen Worten Der Zweck eines Dekorateurs besteht darin, einem vorhandenen Objekt zusätzliche Funktionalität hinzuzufügen. ​

Gleichzeitig wird der Dekorateur im objektorientierten (OOP) Designmuster als Dekorationsmuster bezeichnet. Der Dekorationsmodus von OOP muss durch Vererbung und Kombination implementiert werden, und Python unterstützt nicht nur den Dekorator von OOP, sondern auch Dekoratoren direkt von der Syntaxebene aus. Der Dekorator von Python kann als Funktion oder Klasse implementiert werden.

Weitere Informationen zu diesem Thema finden Sie in der Spalte Python-Video-Tutorial

Das obige ist der detaillierte Inhalt vonDetails zum Python-Dekorator. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!