Python-Dekorateure

In diesem Artikel werden wir Python Decorators diskutieren.

Definition: Decorator ist ein Designmuster in Python. Es ist eine Funktion, die eine andere Funktion als Argument nimmt, einige Funktionalität hinzufügt, ohne sie zu ändern, und eine andere Funktion zurückgibt.

Dies wird mit „(@)“ aufgerufen und vor der Definition einer Funktion platziert, die wir dekorieren möchten.

Syntax:

@Dekorateurname
Funktionsdefinition

Um Dekorateure zu verstehen, müssen wir die folgenden Konzepte kennen.
Funktionen sind erstklassige Objekte. Es bedeutet, dass eine Funktion als Argument übergeben werden kann, von einer anderen Funktion zurückgegeben werden kann, einer Variablen zugewiesen werden kann, in einer anderen Funktion definiert werden kann. Zum besseren Verständnis sehen Sie sich die folgenden Beispiele an.

1. Eine Funktion kann als Argument übergeben werden
   Ex:
   def inkrement(n):
   zurück n + 1
   def demo_funcall (Funktion):
   Anzahl = 5
   Rückgabefunktion (Zahl)
   demo_funcall (erhöht)

   Hier wird die Inkrement-Funktion als Argument übergeben

   Beispiel 1.py:
   

   Ausgabe:

   >> Python-Beispiel1.py
   

2. Funktion kann von einer anderen Funktion zurückgegeben werden
   Ex:
   def Wunsch():
   def say_wish():
   zurück "Alles Gute zum Geburtstag"
   zurück say_wish
   hallo = wunsch()
   Hallo()

   Beispiel2.py:
   

   Ausgabe:

   >>Python-Beispiel2.py
   
   Hier wurde die Funktion say_wish von der Funktion Wish zurückgegeben

3. Funktion kann geändert und einer Variablen zugewiesen werden
   Ex:
   def add(a,b):
   ein +b zurückgeben
   sum2nos = add # Hier wird die Funktion add der Variablen zugewiesen
   sum2nos(5,11)

   Beispiel3.py:
   

   Ausgabe:
   >> Python-Beispiel3.py
   

4. Funktion innerhalb einer anderen Funktion definieren
   Ex:
   def add(a,b):
   def Summe2(a,b):
   a + b zurückgeben
   res = Summe2(a,b)
   zurück res
   hinzufügen(10,15)

   Beispiel4.py:
   

   Ausgabe:
   >> Python-Beispiel4.py
   

Schließung:

Python ermöglicht einer verschachtelten Funktion den Zugriff auf den äußeren Geltungsbereich der einschließenden Funktion.

def Gruß (Nachricht):
"Einschließungsfunktion"
def send_greeting():
"Verschachtelte Funktion"
drucken (Nachricht)
sende Grüße()
Gruß ("Guten Morgen")

Beispiel5.py:

Ausgabe:

>> Python-Beispiel5.py

Nachdem wir die obigen Konzepte jetzt verstanden haben, werden wir ein Dekorateur-Beispiel schreiben.

Beispiel 1: Hier werden wir die Nachrichtenfunktion dekorieren. Drucken der msg inside **** ohne die ursprüngliche Funktion zu ändern, i.e., Nachrichtenfunktion.

#dekorateurstart
def print_msg(Funktion):
def-Wrapper():
Funktion()
Rückverpackung
#dekorateur Ende
def Nachricht():
print("Dies ist das erste Beispiel für die Demonstration von Dekorateuren")
hallo = print_msg(Nachricht)
Hallo()

Beispiel6.py:

Ausgabe:

>> Python-Beispiel6.py

In der einfachsten Form können wir Decorator über der Funktionsdefinition platzieren und die Funktion wie unten gezeigt aufrufen:

Hier, egal welche Schnur wir innen dekorieren wollen ***, verwenden Sie diesen Dekorateur.

Ausgabe:

Mehrere Dekorateure:

Wir können mehrere Dekorateure für eine einzige Funktion haben. Hier wird der Dekorateur in der von uns aufgerufenen Reihenfolge aufgetragen.
Syntax:
@dekorator2
@dekorateur1
Funktionsdefinition

Hier wird der erste Dekorateur angewendet, dann der zweite Dekorateur.

Übergeben von Argumenten an Dekoratorfunktionen:

Wir können Argumente an die Wrapper-Funktion übergeben. Die Argumente, die an die Funktion übergeben werden, für die wir dekorieren möchten.

Ex:

def deco_wish(Funktion):
def-Wrapper (arg1, arg2):
print ('Die übergebenen Argumente sind ',arg1, arg2)
drucken ('*********************')
Funktion (arg1, arg2)
drucken ('*********************')
Rückverpackung
@deco_wish
def Wunsch(a1, a2):
drucken(a1,a2)
wünschen ('Gut', 'Morgen')
wünschen ('Gut', 'Nachmittag')

Beispiel7.py:

Ausgabe:

>> Python-Beispiel7.py

Übergeben Sie eine variable Anzahl von Argumenten an die Dekoratorfunktion:

Wir können eine beliebige Anzahl von Argumenten mit *args (Nicht-Schlüsselwortargumente wie Zahlen) und **kwargs (Schlüsselwortargumente wie ein Wörterbuch) übergeben. Beides sind Positionsargumente und speichert die Argumente in args- und kwargs-Variablen.

Hinweis: Hier können wir anstelle von args und kwargs einen beliebigen Namen verwenden, aber diese Namen werden empfohlen.

Ex:

def dec_var_args(Funktion):
def-Wrapper(*args, **kwargs):
print('Die Nicht-Schlüsselwortargumente sind', args)
print('Die Schlüsselwortargumente sind', kwargs)
Funktion(*Argumente)
Rückverpackung
@ dec_var_args
def fun_non_key_args(*args):
für ich in args:
drucken(i)
@ dec_var_args
def fun_key_args():
print("Schlüsselwortargumente")
fun_non_key_args((4,5,6))
fun_key_args(fname='Anand', lname='Mathe')

Beispiel8.py:

Ausgabe:

>> Python-Beispiel8.py

Bsp2: Angenommen, wir haben 2 Funktionen
Funktion1: Berechne die Summe der Zahlen aus der gegebenen Liste
Funktion 2: Multiplizieren Sie jede Zahl mit 2 und fügen Sie sie der angegebenen Zahlenliste hinzu
Wenn wir die Zeit berechnen möchten, die jeder für die Ausführung benötigt, können Sie dies auf 2 Arten tun

1. Platzieren Sie den Code zwischen der Start- und Endzeit in jeder Funktion
2. Schreibe Dekorateur zum Berechnen der Zeit

Siehe folgenden Code mit Decorator gelöst:

#dekorateurstart
exe_time_calc(funktion):
def-Wrapper(arg):
start_time = datetime.Terminzeit.jetzt()
funk(arg)
end_time = Datum/Uhrzeit.Terminzeit.jetzt()
print ("Die Zeit für die Ausführung der Funktion " + func.__name__ + " ist " + str(end_time - end_time))
Rückverpackung
#dekorateur Ende
@exe_time_calc
def cal_avg(Daten):
Summe = 0
für i in daten:
Summe += i
print ("Der Durchschnitt der gegebenen Zahlenliste ist ", sum//len(data))
@exe_time_calc
def mul_by_2(Daten):
Summe = 0
für i in daten:
Summe += + (i*2)
print ("Die Summe aller Zahlen nach der Multiplikation mit 2 ist ", Summe)
cal_avg ([10,20,30,40,50])
mul_by_2([10,20,30,40,50])

Beispiel9.py:

Ausgabe:

>> Python-Beispiel9.py

Der obige Dekorator kann zur Berechnung der Ausführungszeit für jede der Funktionen verwendet werden. Durch die Verwendung eines Dekorators können wir wiederholten Code vermeiden, wenn wir die Ausführungszeit berechnen müssen, um den Dekorator über der Funktionsdefinition zu platzieren.

Fazit:

Dekorateure ändern die Funktionalität einer Funktion/Methode, ohne den ursprünglichen Code der zu dekorierenden Funktion zu ändern. Dadurch können wir vermeiden, wiederholten Code zu schreiben. Die Kenntnis des Decorator-Konzepts macht uns stark in Python. Wir können Decorator in den folgenden Fällen verwenden:

• Autorisierung in Python-Frameworks Ex: Flask und Django
• Protokollierung
• Ausführungszeit messen