Vertiefte Kenntnisse der Python-Dekoratoren

Einführung in Decorators:

Decorator ist eine erweiterte Python-Syntax. Dekorateure können eine Funktion, Methode oder Klasse verarbeiten. In Python haben wir viele Möglichkeiten, Funktionen und Klassen zu verarbeiten. In Python-Abschlüssen sehen wir beispielsweise Funktionsobjekte als Rückgabeergebnis einer bestimmten Funktion. Im Vergleich zu anderen Methoden ist die Decorator-Syntax einfach und der Code gut lesbar. Daher werden Dekoratoren häufig in Python-Projekten verwendet.

Der Dekorator erschien erstmals in Python 2.5. Er wurde ursprünglich zur Verarbeitung aufrufbarer Objekte wie Funktionen und Methoden verwendet (aufrufbare Objekte, solche Objekte werden mit __call__-Methoden definiert). In Python 2.6 und späteren Python-Versionen werden Dekoratoren weiterhin zur Verarbeitung von Klassen verwendet.

Der Dekorator wird hauptsächlich zum Umschließen von Funktionen für einige allgemeine Funktionen verwendet, z. B. Protokolldruck, Funktionstiming und Identitätsauthentifizierung. Um dies zu erreichen, können wir Dekoratoren verwenden, die die Komplexität des gesamten Programms und die Codemenge im Programm reduzieren können.

Es ist eigentlich eine Funktion. Der Unterschied besteht darin, dass es eine Funktion als Parameter akzeptiert und eine alternative Version der Funktion zurückgibt.

Sehen Sie sich unten ein einfaches Beispiel an:

def add_number(func):
def adder(arg):
return func(arg)+100
return adder
def f(x):
return x
f=add_number(f)
print f(20)

add_number ist eine Dekoratorfunktion, die eine Funktion (f) als Parameter akzeptiert und eine andere Funktion zurückgibt (Addierer) wird der Originalfunktion zugewiesen. Auf diese Weise realisiert die Originalfunktion die Additionsfunktion, ohne zusätzlichen Code hinzuzufügen.

Dies ist die ursprüngliche Implementierung des Dekorators.

Aber diese Methode ist immer noch etwas umständlich. Schließlich drehen wir uns immer noch im Kreis und verwenden f=add_number(f), um die ursprüngliche Funktion neu zuzuweisen.

Tatsächlich können die folgenden Methoden verwendet werden, um den Verweis auf Dekoratoren in Python zu vereinfachen.

def add_number(func):
def adder(arg):
return func(arg)+100
return adder
@add_number
def f(x):
return x
print f(20)

Es ist nur ein einfacher @add_numbe-Aufruf erforderlich. Ist das nicht viel einfacher und greift im Grunde nicht in den Originalcode ein?

Nun, jeder hat bemerkt, dass als Dekorateur jedes Mal nur zwei Parameter akzeptiert werden: Funktionen und Funktionsparameter, aber das Schreibformat ist im Grunde das gleiche. Gibt es eine Möglichkeit, diese Art des Schreibens zu vereinfachen?

Ja, Python bietet ein Dekoratorpaket, das das Schreiben von Dekoratoren erheblich vereinfachen kann.

Die dritte Implementierungsmethode lautet also:

from decorator import decorator
@decorator
def wrapper(func,arg):
return func(arg)+100
@wrapper
def f(x):
return x
print f(20)

Oh, es ist tatsächlich einfacher~

Above The Beispiele akzeptieren alle einen Parameter. Tatsächlich kann die Funktion selbst variable Parameter akzeptieren.

Zum Beispiel:

@decorator
def wrapper(f,arg1,*args,**kwargs):
print "I am just a wrapper~"
return f(arg1,*args,**kwargs)
@wrapper
def f(arg1,*args,**kwargs):
print arg1
for eacheArg in args:
print 'non-keyword arg:',eacheArg
for eachKw in kwargs.keys():
print 'keyword arg: %s:%d' % (eachKw,kwargs[eachKw])
args=('Joy','Steve')
kwargs={"age":20}
f('China',*args,**kwargs)

Das Ausgabeergebnis ist:

I am just a wrapper~
China
non-keyword arg: Joy
non-keyword arg: Steve
keyword arg: age:20

Über *args ,* Der Unterschied zwischen *kwargs, beide können zur Darstellung von Parametern variabler Länge verwendet werden. Ersteres wird lediglich durch Yuanzu dargestellt und hat keinen Schlüsselwert, während letzteres ein Wörterbuch mit Schlüsselwert ist. Beide können in derselben Funktion verwendet werden, allerdings müssen *args vor **kwargs stehen.

Zum Beispiel:

def test_var_args_call(arg1, arg2, arg3):
print "arg1:", arg1
print "arg2:", arg2
print "arg3:", arg3
args=(1,2,3)
kwargs ={"arg1":"1","arg3": 3, "arg2": "2"}
test_var_args_call(*args)
print '-----------------'
test_var_args_call(**kwargs)

Die beiden erzielen den gleichen Effekt.

Das letzte Beispiel besteht darin, eine Funktion zu dekorieren, indem die Ausführungszeit der Funktion angezeigt wird

import time
def log(func):
def wrapper(*args, **kw):
print '[%s] %s() was called...' % (time.ctime(),func.__name__)
return func(*args, **kw)
return wrapper
@log
def foo():
pass
for i in range(4):
foo()
time.sleep(1)

Das Ausgabeergebnis lautet wie folgt:

[Wed Jul 27 09:17:23 2016] foo() was called...
[Wed Jul 27 09:17:24 2016] foo() was called...
[Wed Jul 27 09:17:25 2016] foo() was called...
[Wed Jul 27 09:17:26 2016] foo() was called...

Das Obige ist das vom Herausgeber vorgestellte detaillierte Verständnis der Python-Dekoratoren. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht Der Herausgeber wird Ihnen rechtzeitig antworten. Ich möchte mich auch bei Ihnen allen für Ihre Unterstützung der chinesischen PHP-Website bedanken!

Für ein tieferes Verständnis der Artikel zum Thema Python-Dekorateure beachten Sie bitte die chinesische PHP-Website!