Python -Dekoratoren

In diesem Artikel werden wir Python -Dekoratoren diskutieren.

Definition: Dekorateur ist ein Designmuster in Python. Es handelt sich um eine Funktion, die eine andere Funktion als Argument nimmt, eine Funktionalität hinzufügt, ohne sie zu ändern, und gibt eine andere Funktion zurück.

Dies wird mit „(@)“ bezeichnet und vor dem Definieren einer Funktion platziert, die wir dekorieren möchten.

Syntax:

@Decorator Name
Funktionsdefinition

Für das Verständnis der Dekorateure müssen wir die folgenden Konzepte kennenlernen.
Funktionen sind erstklassige Objekte. Dies bedeutet, dass eine Funktion als Argument übergeben werden kann, kann von einer anderen Funktion zurückgegeben, einer Variablen zugeordnet werden, kann in einer anderen Funktion definiert werden. Für ein besseres Verständnis finden Sie die folgenden Beispiele.

1. Eine Funktion kann als Argument übergeben werden
   Beispiel: Def Increment (n):
   Return N + 1
   Def Demo_Funcall (Funktion):
   Num = 5
   Rückgabefunktion (Num)
   Demo_Funcall (Inkrement)

   Hier übergebene Inkrementfunktion als Argument

   Beispiel 1.PY:
   

   Ausgang:

   >> Python Beispiel1.py
   

2. Die Funktion kann von einer anderen Funktion zurückgegeben werden
   Beispiel: def wish ():
   Def Say_wish ():
   Rückkehr "Alles Gute zum Geburtstag"
   Return say_wish
   hallo = wish ()
   Hallo()

   Beispiel2.PY:
   

   Ausgang:

   >> Python Beispiel2.py
   
   Hier kehrte Say_Wish -Funktion aus der Wunschfunktion zurück

3. Funktion kann geändert und einer Variablen zugeordnet werden
   Beispiel: def Add (a, b):
   Return a +b
   sum2nos = add # hier function add add add zugewiesen zugewiesener variable
   sum2nos (5,11)

   Beispiel3.PY:
   

   Ausgang:
   >> Python Beispiel3.py
   

4. Funktionen in einer anderen Funktion definieren
   Beispiel: def Add (a, b):
   def sum2 (a, b):
   Return a + b
   res = sum2 (a, b)
   return res
   Add (10,15)

   Beispiel4.PY:
   

   Ausgang:
   >> Python Beispiel4.py
   

Schließung:

Python ermöglicht es einer verschachtelten Funktion, auf den äußeren Umfang der beigefügten Funktion zuzugreifen.

Def Greeting (Nachricht):
"Gehäusefunktion"
Def send_greeting ():
"Verschachtelte Funktion"
Druck (Nachricht)
sende Grüße()
Gruß ("Guten Morgen")

Beispiel5.PY:

Ausgang:

>> Python Beispiel5.py

Nachdem wir jetzt die oben genannten Konzepte verstanden haben, werden wir einen Dekorationsbeispiel schreiben.

EX1: Hier dekorieren wir die Nachrichtenfunktion. Drucken der MSG in **** ohne die ursprüngliche Funktion zu modifizieren, i, ich.e., Nachrichtenfunktion.

#Decorator Start
Def print_msg (Funktion):
Def -Wraper ():
Funktion()
Wrapper zurückgeben
#Decorator Ende
Def Message ():
Druck („Dies ist das erste Beispiel zum Demonstrationsdekorator“)
Hallo = print_msg (Nachricht)
Hallo()

Beispiel6.PY:

Ausgang:

>> Python Beispiel6.py

In der einfachsten Form können wir Dekorateur über die Funktionsdefinition platzieren und die unten gezeigte Funktion aufrufen:

Hier, welche Saite wir in *** dekorieren möchten, verwenden Sie diesen Dekorateur.

Ausgang:

Multiple Dekorateur:

Wir können mehrere Dekorateure für eine einzelne Funktion haben. Hier wird der Dekorateur in der Reihenfolge aufgetragen, die wir angerufen haben.
Syntax:
@Decorator2
@Decorator1
Funktionsdefinition

Hier wird der 1. Dekorateur angewendet, dann der 2. Dekorateur.

Übergeben von Argumenten an Dekorationsfunktionen:

Wir können Argumente an die Wrapper -Funktion weitergeben. Die Argumente übergeben an die Funktion, für die wir dekorieren wollen.

Ex:

Def deco_wish (Funktion):
DEF -WRAPPER (Arg1, Arg2):
print ('Die bestandenen Argumente sind', arg1, arg2)
drucken ('*********************')
Funktion (arg1, arg2)
drucken ('*********************')
Wrapper zurückgeben
@deco_wish
Def Wish (A1, A2):
Druck (A1, A2)
Wish ('gut', 'Morgen')
Wish ('gut', 'Nachmittag')

Beispiel7.PY:

Ausgang:

>> Python Beispiel7.py

Übergeben Sie die variable Anzahl von Argumenten an die Dekorationsfunktion:

Wir können eine beliebige Anzahl von Argumenten mit *args (Nicht-Keyword-Argumente wie Zahlen) und ** KWARGS (Keyword-Argumente wie ein Wörterbuch) übergeben. Beide sind Positionsargumente und speichern die Argumente in Argumenten und KWARGS -Variablen.

Hinweis: Hier können wir einen beliebigen Namen anstelle von Args und KWARGs verwenden, aber diese Namen werden empfohlen, um sie zu verwenden.

Ex:

DEF DEC_VAR_ARGS (FUNKTIONISION):
Def -Wraper (*args, ** kwargs):
print ('Die Nicht -Schlüsselwort -Argumente sind', Args))
print ('Die Keyword -Argumente sind', Kwargs)
Funktion (*args)
Wrapper zurückgeben
@ dec_var_args
def fun_non_key_args (*args):
Denn 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 = 'math')

Beispiel8.PY:

Ausgang:

>> Python Beispiel8.py

EX2: Angenommen, wir haben 2 Funktionen
Funktion1: Berechnen Sie die Summe der Zahlen aus der angegebenen Liste
Funktion2: Multiplizieren Sie jede Zahl mit 2 und fügen Sie sie der angegebenen Liste der Zahlen hinzu
Wenn wir die von jeweils für die Ausführung dauernde Zeit berechnen wollen, kann dies auf 2 Arten tun

1. Platzieren Sie den Code zwischen Start und Endzeit in jeder Funktion
2. Schreiben Sie Dekorateur zur Berechnung der Zeit

Siehe unten mit Dekorateur gelöste Code:

#Decorator Start
exe_time_calc (func):
DEF -WRAPPER (ARG):
start_time = datetime.Terminzeit.Jetzt()
func (arg)
end_time = datetime.Terminzeit.Jetzt()
Print ("Die Zeit für die Ausführung von Funktion" + Func.__name__ + "ist" + str (end_time - end_time))
Wrapper zurückgeben
#Decorator Ende
@exe_time_calc
Def Cal_avg (Daten):
sum = 0
Denn ich in Daten:
sum += i
print ("Der Durchschnitt der angegebenen Liste von Zahlen ist", Summe // len (Daten))
@exe_time_calc
Def mul_by_2 (Daten):
sum = 0
Denn ich in Daten:
sum + = + (i*2)
drucken ("Die Sume aller Zahlen nach dem Multiplizieren mit 2 ist", Summe)
CAL_AVG ([10,20,30,40,50])
mul_by_2 ([10,20,30,40,50])

Beispiel9.PY:

Ausgang:

>> Python Beispiel9.py

Der obige Dekorateur kann zur Berechnung der Ausführungszeit für eine der Funktionen verwendet werden. Durch die Verwendung eines Dekorateur können wir wiederholten Code vermeiden, wenn wir die Ausführungszeit berechnen, um den Dekorateur über die Funktionsdefinition zu legen.

Abschluss:

Dekorateure ändern die Funktionalität einer Funktion/Methode, ohne den ursprünglichen Code der Funktion zu ändern, wird dekoriert. Mit diesem Fall können wir vermeiden, wiederholten Code zu schreiben. Wenn wir das Konzept des Dekorationskonzepts in Python stark machen. Wir können Dekorateur in den folgenden Fällen verwenden:

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