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.

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

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)

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)

In Python integrierte Dekoratoren

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

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.

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!