Phenquestions
Definiție: Decorator este un model de design în Python. Este o funcție care ia o altă funcție ca argument, îi adaugă o anumită funcționalitate fără a o modifica și returnează o altă funcție.
Aceasta se numește folosind „(@)” și plasată înainte de a defini o funcție pe care dorim să o decorăm.
sintaxă:
@numele decoratorului
Definirea funcției
Pentru înțelegerea decoratorilor, trebuie să cunoaștem conceptele de mai jos.
Funcțiile sunt obiecte de primă clasă. Înseamnă că o funcție poate fi transmisă ca argument, poate fi returnată dintr-o altă funcție, poate fi atribuită unei variabile, poate fi definită într-o altă funcție. Pentru o mai bună înțelegere, consultați exemplele de mai jos.
- O funcție poate fi transmisă ca argument
Ex: increment def (n):
returnează n + 1
def demo_funcall (funcție):
num = 5
functie return (num)
demo_funcall (increment)Aici funcția de incrementare a trecut ca argument
exemplu1.py:
Ieșire:
>> python example1.py
- Funcția poate fi returnată dintr-o altă funcție
Ex: def wish ():
def say_wish ():
returnează „La mulți ani”
întoarce zice_vrea
salut = wish ()
Buna ziua()exemplu2.py:
Ieșire:
>> exemplu python2.py
Aici funcția say_wish a revenit din funcția de dorință - Funcția poate fi modificată și atribuită unei variabile
Ex: def add (a, b):
returnează a + b
sum2nos = add # Aici funcția add atribuită variabilei
sum2nos (5,11)exemplu3.py:
Ieșire:
>> exemplu python3.py
- Definiți funcția în interiorul altei funcții
Ex: def add (a, b):
def sum2 (a, b):
returnează a + b
res = sum2 (a, b)
întoarce res
adăugați (10,15)exemplu4.py:
Ieșire:
>> exemplu python4.py
Închidere:
Python permite unei funcții imbricate să acceseze sfera exterioară a funcției de închidere.
salut (mesaj):"Funcția de închidere"
def send_greeting ():
"Funcție imbricată"
print (mesaj)
Trimite felicitare()
salut („Bună dimineața”)
exemplu5.py:
Ieșire:
>> exemplu python5.py
După ce înțelegem acum conceptele de mai sus, vom scrie un exemplu de decorator.
Ex1: Aici vom decora funcția de mesaj. Tipărirea mesajului în interiorul **** fără a modifica funcția originală, i.e., funcția de mesaj.
#decorator startdef print_msg (funcție):
wrapper def ():
funcţie()
înveliș de întoarcere
#decorator end
mesaj def ():
print („Acesta este primul exemplu pentru demonstrarea decoratorului”)
salut = print_msg (mesaj)
Buna ziua()
exemplu6.py:
Ieșire:
>> exemplu python6.py
În cea mai simplă formă, putem plasa decoratorul deasupra definiției funcției și putem apela funcția așa cum se arată mai jos:
Aici orice șir vrei să decorăm în interior ***, folosește acest decorator.
Ieșire:
Decorator multiplu:
Putem avea decorator multiplu pentru o singură funcție. Aici decoratorul este aplicat în ordinea pe care am numit-o.
sintaxă:
@ decorator2
@ decorator1
Definirea funcției
Aici se va aplica primul decorator, apoi al 2-lea decorator.
Transmiterea argumentelor către funcțiile decoratorului:
Putem transmite argumente funcției wrapper. Argumentele au fost transmise funcției pentru care dorim să decorăm.
Ex:
def deco_wish (funcție):wrapper def (arg1, arg2):
print („Argumentele trecute sunt”, arg1, arg2)
imprimare ('*********************')
funcție (arg1, arg2)
imprimare ('*********************')
înveliș de întoarcere
@deco_wish
dorință def (a1, a2):
print (a1, a2)
wish („Bun”, „Dimineață”)
wish („Bun”, „După-amiază”)
exemplu7.py:
Ieșire:
>> exemplu python7.py
Treceți numărul variabil de argumente la funcția de decorator:
Putem transmite orice număr de argumente folosind * args (argumente care nu sunt cuvinte cheie cum ar fi numerele) și ** kwargs (argumente cheie ca un dicționar). Ambele sunt argumente poziționale și stochează argumentele în variabile args și kwargs.
Notă: Aici putem folosi orice nume în loc de args și kwargs, dar se recomandă utilizarea acestor nume.
Ex:
def dec_var_args (funcție):wrapper def (* args, ** kwargs):
print („Argumentele care nu sunt cuvinte cheie sunt”, args)
print („Argumentele cuvintelor cheie sunt”, kwargs)
funcție (* args)
înveliș de întoarcere
@ dec_var_args
def fun_non_key_args (* args):
pentru I în argumente:
print (i)
@ dec_var_args
def fun_key_args ():
print („Argumente ale cuvintelor cheie”)
fun_non_key_args ((4,5,6))
fun_key_args (fname = 'Anand', lname = 'Math')
exemplu8.py:
Ieșire:
>> python example8.py
Ex2: Să presupunem că avem 2 funcții
Funcția 1: Calculați suma numerelor din lista dată
Funcția 2: Înmulțiți fiecare număr cu 2 și adăugați-le la lista dată de numere
Dacă vrem să calculăm timpul necesar pentru fiecare execuție, o putem face în 2 moduri
- Plasați codul între ora de început și sfârșit în fiecare funcție
- Scrie decorator pentru calcularea timpului
Vezi mai jos codul rezolvat cu ajutorul decoratorului:
#decorator startexe_time_calc (func):
ambalaj def (arg):
start_time = datetime.datetime.acum()
func (arg)
time_ end = datetime.datetime.acum()
print ("Timpul necesar pentru executarea funcției" + func.__name__ + "is" + str (end_time - end_time))
înveliș de întoarcere
#decorator end
@exe_time_calc
def cal_avg (date):
sumă = 0
pentru i în date:
suma + = i
print ("Media listei date de numere este", suma // len (date))
@exe_time_calc
def mul_by_2 (date):
sumă = 0
pentru i în date:
sumă + = + (i * 2)
print ("Suma tuturor numerelor după multiplicare cu 2 este", sumă)
cal_avg ([10,20,30,40,50])
mul_by_2 ([10,20,30,40,50])
exemplu9.py:
Ieșire:
>> exemplu python9.py
Decoratorul de mai sus poate fi utilizat pentru calcularea timpului de execuție pentru oricare dintre funcții. Folosind un decorator, putem evita codul repetat atunci când avem o cerință pentru calcularea timpului de execuție pentru a plasa decoratorul deasupra definiției funcției.
Concluzie:
Decoratorii schimbă funcționalitatea unei funcții / metode fără a modifica codul original al funcției care este decorată. Folosind acest lucru, putem evita scrierea unui cod repetat. Cunoașterea conceptului de decorator ne va face puternici în python. Putem folosi decoratorul în cazurile de mai jos:
- Autorizare în cadrul Python Ex: Flask și Django
- Logare
- Măsurați timpul de execuție
