Lernen Sie Python-Dekoratoren in einem Artikel kennen

Python ist eine anfängerfreundliche Sprache. Es verfügt jedoch auch über viele erweiterte Funktionen, die schwer zu beherrschen sind, z. B. Dekorateure. Viele Anfänger haben noch nie verstanden, wie Dekorateure arbeiten. In diesem Artikel stellen wir die Besonderheiten von Dekorateuren vor.

In Python ist eine Funktion eine sehr flexible Struktur. Wir können sie einer Variablen zuweisen, sie als Parameter an eine andere Funktion übergeben oder sie als Ausgabe einer Funktion verwenden. Ein Dekorator ist im Wesentlichen eine Funktion, die es anderen Funktionen ermöglicht, einige Funktionen ohne Änderungen hinzuzufügen.

Dies ist die Bedeutung von „Dekoration“. Diese „Dekoration“ selbst stellt eine Funktion dar. Wenn Sie sie verwenden, um verschiedene Funktionen zu ändern, bedeutet dies, dass diese Funktion zu diesen Funktionen hinzugefügt wird.

Im Allgemeinen können wir den vom Dekorateur bereitgestellten @-syntaktischen Zucker (Syntactic Sugar) verwenden, um andere Funktionen oder Objekte zu dekorieren. Wie unten gezeigt, verwenden wir den @dec-Dekorator, um die Funktion func() zu dekorieren:

@dec
def func():
 pass

Der beste Weg, den Dekorator zu verstehen, besteht darin, zu verstehen, welches Problem der Dekorator ausgehend von dem spezifischen Problem löst Problem und zeigen seine Eleganz und Kraft.

Einrichtungsprobleme

Um den Zweck von Dekoratoren zu verstehen, schauen wir uns ein einfaches Beispiel an. Angenommen, Sie haben eine einfache Additionsfunktion dec.py mit einem Standardwert von 10 für den zweiten Parameter:

# dec.py
def add(x, y=10):
 return x + y

Schauen wir uns diese Additionsfunktion genauer an:

>>> add(10, 20)
30
>>> add
<function add at 0x7fce0da2fe18>
>>> add.__name__
'add'
>>> add.__module__
'__main__'
>>> add.__defaults__ # default value of the `add` function
(10,)
>>> add.__code__.co_varnames # the variable names of the `add` function
('x', 'y')

Wir müssen nicht verstehen, was das ist, denken Sie nur daran Jede Funktion in Python ist ein Objekt und verfügt über verschiedene Eigenschaften und Methoden. Sie können den Quellcode der add()-Funktion auch über das Inspect-Modul anzeigen:

>>> from inspect import getsource
>>> print(getsource(add))
def add(x, y=10):
 return x + y

Jetzt verwenden Sie die Additionsfunktion auf irgendeine Weise, zum Beispiel verwenden Sie einige Operationen, um die Funktion zu testen:

# dec.py
from time import time
def add(x, y=10):
 return x + y
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))
Output: i
add(10) 20
add(20, 30) 50
add("a", "b") ab

Wenn Sie möchten Verstehen Sie die Funktion jeder Operation. Für die Zeit können Sie das Zeitmodul aufrufen:

# dec.py
from time import time
def add(x, y=10):
 return x + y
before = time()
print('add(10)', add(10))
after = time()
print('time taken: ', after - before)
before = time()
print('add(20, 30)', add(20, 30))
after = time()
print('time taken: ', after - before)
before = time()
print('add("a", "b")', add("a", "b"))
after = time()
print('time taken: ', after - before)
Output:
add(10) 20
time taken:6.699562072753906e-05
add(20, 30) 50
time taken:6.9141387939453125e-06
add("a", "b") ab
time taken:6.9141387939453125e-06

Als Programmierer juckt es Sie schließlich ein wenig? Der aktuelle Code ist nicht sehr lesbar. Wenn Sie etwas ändern möchten, müssen Sie alles dort ändern, wo es angezeigt wird. Es muss einen besseren Weg in Python geben.

Wir können die Laufzeit direkt in der Add-Funktion wie folgt erfassen:

# dec.py
from time import time
def add(x, y=10):
 before = time()
 rv = x + y
 after = time()
 print('time taken: ', after - before)
 return rv
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))

Diese Methode ist definitiv besser als die vorherige. Wenn Sie jedoch eine andere Funktion haben, erscheint dies unpraktisch. Wenn wir mehrere Funktionen haben:

# dec.py
from time import time
def add(x, y=10):
 before = time()
 rv = x + y
 after = time()
 print('time taken: ', after - before)
 return rv
def sub(x, y=10):
 return x - y
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))
print('sub(10)', sub(10))
print('sub(20, 30)', sub(20, 30))

Da add und sub beide Funktionen sind, können wir dies nutzen, um eine Timer-Funktion zu schreiben. Wir möchten, dass der Timer die Betriebszeit einer Funktion berechnet:

def timer(func, x, y=10):
 before = time()
 rv = func(x, y)
 after = time()
 print('time taken: ', after - before)
 return rv

Das ist schön, aber wir müssen verschiedene Funktionen mit Timer-Funktionen umschließen, wie folgt:

print('add(10)', timer(add,10)))

Ist der Standardwert jetzt immer noch 10? nicht unbedingt. Wie kann man es also besser machen?

Hier ist eine Idee: Erstellen Sie eine neue Timer-Funktion, umschließen Sie andere Funktionen und geben Sie die umschlossene Funktion zurück:

def timer(func):
 def f(x, y=10):
 before = time()
 rv = func(x, y)
 after = time()
 print('time taken: ', after - before)
 return rv
 return f

Jetzt verpacken Sie einfach die Add- und Sub-Funktionen mit dem Timer:

add = timer(add)

Das ist es! Das ist es! Hier ist der vollständige Code:

# dec.py
from time import time
def timer(func):
 def f(x, y=10):
 before = time()
 rv = func(x, y)
 after = time()
 print('time taken: ', after - before)
 return rv
 return f
def add(x, y=10):
 return x + y
add = timer(add)
def sub(x, y=10):
 return x - y
sub = timer(sub)
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))
print('sub(10)', sub(10))
print('sub(20, 30)', sub(20, 30))
Output:
time taken:0.0
add(10) 20
time taken:9.5367431640625e-07
add(20, 30) 50
time taken:0.0
add("a", "b") ab
time taken:9.5367431640625e-07
sub(10) 0
time taken:9.5367431640625e-07
sub(20, 30) -10

Fassen wir den Prozess zusammen: Wir haben eine Funktion (wie die Add-Funktion) und schließen diese Funktion dann mit einer Aktion (wie Timing) ein. Das Ergebnis der Verpackung ist eine neue Funktion, die bestimmte neue Funktionen implementieren kann.

Natürlich stimmt mit den Standardwerten etwas nicht, wir werden es später beheben.

Decorator

Die obige Lösung kommt der Idee eines Decorators sehr nahe. Sie verwendet gängige Verhaltensweisen, um eine bestimmte Funktion zu umschließen. Der Code nach der Verwendung des Dekorators lautet:

def add(x, y=10):
 return x + y
add = timer(add)
You write:
@timer
def add(x, y=10):
 return x + y

Sie haben den gleichen Effekt, das ist es, was Python-Dekoratoren tun. Die implementierte Funktion ähnelt add = timer (add), mit der Ausnahme, dass der Dekorateur die Syntax über der Funktion platziert und die Syntax einfacher ist: @timer.

# dec.py
from time import time
def timer(func):
 def f(x, y=10):
 before = time()
 rv = func(x, y)
 after = time()
 print('time taken: ', after - before)
 return rv
 return f
@timer
def add(x, y=10):
 return x + y
@timer
def sub(x, y=10):
 return x - y
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))
print('sub(10)', sub(10))
print('sub(20, 30)', sub(20, 30))

Parameter und Schlüsselwortparameter

Jetzt gibt es noch ein kleines Problem, das nicht gelöst wurde. In der Timer-Funktion codieren wir die Parameter x und y fest, das heißt, wir geben den Standardwert von y als 10 an. Es gibt eine Möglichkeit, Argumente und Schlüsselwortargumente an die Funktion zu übergeben, nämlich *args und **kwargs. Parameter sind die Standardparameter der Funktion (in diesem Fall ist x der Parameter) und Schlüsselwortparameter sind Parameter, die bereits einen Standardwert haben (in diesem Fall y=10). Der Code lautet wie folgt:

# dec.py
from time import time
def timer(func):
 def f(*args, **kwargs):
 before = time()
 rv = func(*args, **kwargs)
 after = time()
 print('time taken: ', after - before)
 return rv
 return f
@timer
def add(x, y=10):
 return x + y
@timer
def sub(x, y=10):
 return x - y
print('add(10)', add(10))
print('add(20, 30)', add(20, 30))
print('add("a", "b")', add("a", "b"))
print('sub(10)', sub(10))
print('sub(20, 30)', sub(20, 30))

Jetzt kann die Timer-Funktion jede Funktion, jeden Parameter und alle Standardwerteinstellungen verarbeiten, da sie diese Parameter einfach an die Funktion übergibt.

Dekoratoren höherer Ordnung

Sie fragen sich vielleicht: Wenn wir eine Funktion mit einer anderen Funktion umschließen können, um nützliches Verhalten hinzuzufügen, können wir dann noch einen Schritt weiter gehen? Umschließen wir eine Funktion mit einer anderen Funktion und werden wir von einer anderen Funktion umschlossen?

Ja! Tatsächlich kann die Funktion so tief sein, wie Sie möchten. Sie möchten beispielsweise einen Dekorator schreiben, der eine Funktion n-mal ausführt. Wie unten gezeigt:

def ntimes(n):
 def inner(f):
 def wrapper(*args, **kwargs):
 for _ in range(n):
 rv = f(*args, **kwargs)
 return rv
 return wrapper
 return inner

Dann können Sie die obige Funktion verwenden, um eine andere Funktion zu umschließen, z. B. die Add-Funktion im vorherigen Artikel:

@ntimes(3)
def add(x, y):
 print(x + y)
 return x + y

Die Ausgabeanweisung zeigt, dass der Code tatsächlich dreimal ausgeführt wird.

Das obige ist der detaillierte Inhalt vonLernen Sie Python-Dekoratoren in einem Artikel kennen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!