Detaillierte Erklärung der Python-Dekoratoren

Detaillierte Erklärung des Python-Dekorators

Detaillierte Analyse des Python-Dekorators

Was Ist es ein Dekorateur?

Empfohlenes Lernen: Python-Video-Tutorial

Python-Dekoratoren (funktionale Dekoratoren) sind Funktionen, die dazu dienen, die Funktionalität der ursprünglichen Funktion zu erweitern Ändern Sie den ursprünglichen Funktionsnamen (oder Klassennamen) und fügen Sie der Funktion neue Funktionen hinzu.

Das Besondere an dieser Funktion ist, dass ihr Rückgabewert auch eine Funktion ist, in die die „ursprüngliche“ Funktion eingebettet ist

Im Allgemeinen, wenn wir so wollen Erweitern Sie den ursprünglichen Funktionscode. Der direkteste Weg besteht darin, in den Code einzudringen und ihn zu ändern, zum Beispiel:

import time
def f():
    print("hello")
    time.sleep(1)
    print("world")　　

Dies ist unsere originellste Funktion, und dann versuchen wir, die Summe aufzuzeichnen Ausführungszeit dieser Funktion, dann Der einfachste Weg besteht darin, den Originalcode zu ändern:

import time
def f():
    start_time = time.time()
    print("hello")
    time.sleep(1)
    print("world")
    end_time = time.time()
    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)

Aber in der tatsächlichen Arbeit kann der Kerncode manchmal nicht direkt geändert werden, also ohne den Originalcode zu ändern , wir Sie können eine andere Funktion definieren (aber die Funktion muss erneut ausgeführt werden, um wirksam zu werden)

import time
def deco(func):
    start_time = time.time()
    f()
    end_time = time.time()
    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)
def f():
    print("hello")
    time.sleep(1)
    print("world")
if __name__ == '__main__':
    deco(f)
    print("f.__name__ is",f.__name__)
    print()

Hier definieren wir eine Funktionsdeko, deren Parameter eine Funktion ist, und betten sie dann ein Wenn Sie jedoch die Funktionalität dieser zig Millionen Funktionen erweitern möchten, bedeutet dies, dass wir die Funktion deco() zehn Millionen Mal ausführen müssen Versuchen Sie, Dekoratoren zu verwenden, um das ursprüngliche Erscheinungsbild des Dekorators zu erreichen.

Die Deko-Funktion ist hier der originellste Dekorator value ist ebenfalls eine Funktion.

Die Funktion f() wird als Parameter innerhalb der Rückgabefunktion wrapper() ausgeführt. Fügen Sie dann @deco vor der Funktion f() hinzu und

f(. ) Funktion ist gleichbedeutend mit der Injektion. Solange f() aufgerufen wird, wurde sie in eine „neue Funktion mit mehr Funktionen“ umgewandelt,

(das Original muss nicht wiederholt werden). Funktion)

Erweiterung 1: Decorator mit festen Parametern

import time
def deco(f):
    def wrapper():
        start_time = time.time()
        f()
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" %execution_time )
    return wrapper
@deco
def f():
    print("hello")
    time.sleep(1)
    print("world")
if __name__ == '__main__':
    f()

Erweiterung 2: Decorator ohne feste Parameter

import time
def deco(f):
    def wrapper(a,b):
        start_time = time.time()
        f(a,b)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" % execution_time)
    return wrapper
@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))
if __name__ == '__main__':
    f(3,4)

Erweiterung 3: Mehrere Decorators verwenden Eine Funktion dekorieren

import time
def deco(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        execution_time_ = (end_time - start_time)*1000
        print("time is %d ms" %execution_time)
    return wrapper
@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))
@deco
def f2(a,b,c):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b+c))
if __name__ == '__main__':
    f2(3,4,5)
    f(3,4)

import time
def deco01(f):
    def wrapper(*args, **kwargs):
        print("this is deco01")
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" % execution_time)
        print("deco01 end here")
    return wrapper
def deco02(f):
    def wrapper(*args, **kwargs):
        print("this is deco02")
        f(*args, **kwargs)
        print("deco02 end here")
    return wrapper
@deco01
@deco02
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))
if __name__ == '__main__':
    f(3,4)

Decorator-Aufrufreihenfolge

Dekoratoren können überlagert verwendet werden. Wie ist also die Reihenfolge des Codes nach der Verwendung von Dekoratoren?

Für die „@“-Syntax in Python ? Zucker, die Reihenfolge, in der die Dekoratoren aufgerufen werden, ist die Umkehrung der Reihenfolge, die mit dem @-syntaktischen Zucker angegeben wurde.

In diesem Beispiel ist „f(3, 4) = deco01(deco02(f(3, 4 )))".

In Python integrierte Dekoratoren

Es gibt drei integrierte Dekoratoren in Python, die sich alle auf die Klassen staticmethod beziehen , classmethod und property .

staticmethod ist eine klassenstatische Methode. Der Unterschied zwischen ihr und den Mitgliedsmethoden besteht darin, dass sie ohne Instanziierung der Klasse aufgerufen werden kann Bei Klassenmethoden und Mitgliedsmethoden handelt es sich um Folgendes: Der erste empfangene Parameter ist nicht self (ein Zeiger auf eine Klasseninstanz), sondern cls (der spezifische Typ der aktuellen Klasse).

Eigenschaft bedeutet Eigenschaft und gibt Informationen an, auf die direkt zugegriffen werden kann durch eine Klasseninstanz

Staticmethod und classmethod werde ich hier nicht vorstellen. Schauen wir uns die Eigenschaft anhand eines Beispiels an.

Beachten Sie, dass bei Python-Klassen im neuen Stil das var-Attribut gelesen wird, wenn die durch den „@var.setter“-Dekorator oben dekorierte Mitgliedsfunktion entfernt wird -only-Attribut, und es wird eine Ausnahme ausgelöst, wenn ein Wert mit „foo.var = 'var 2′“ zugewiesen wird. Für die klassische Python-Klasse sind die deklarierten Attribute jedoch nicht schreibgeschützt. Selbst wenn der Dekorator „@var.setter“ entfernt wird, wird kein Fehler gemeldet.

Zusammenfassung

In diesem Artikel werden einige Verwendungsmöglichkeiten von Python-Dekoratoren vorgestellt. Der Code des Dekorators ist relativ einfach zu verstehen. Es ist leicht zu verstehen, solange Sie es anhand einiger Beispiele üben.

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung der Python-Dekoratoren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!