Decoratori di pitone

In questo articolo parleremo di Python Decorators.

Definizione: Decorator è un modello di progettazione in Python. È una funzione che prende un'altra funzione come argomento, aggiunge alcune funzionalità senza modificarla e restituisce un'altra funzione.

Questo è chiamato usando "(@)" e posto prima di definire una funzione che vogliamo decorare.

sintassi:

@nome decoratore
Definizione della funzione

Per comprendere i decoratori, dobbiamo conoscere i concetti seguenti.
Le funzioni sono oggetti di prima classe. Significa che una funzione può essere passata come argomento, può essere restituita da un'altra funzione, può essere assegnata a una variabile, può essere definita in un'altra funzione. Per una migliore comprensione, vedere gli esempi seguenti.

1. Una funzione può essere passata come argomento
   Ex:
   def incremento(n):
   ritorna n + 1
   def demo_funcall (funzione):
   numero = 5
   funzione di ritorno (num)
   demo_funcall (incremento)

   Qui funzione di incremento passata come argomento

   Esempio 1.pi:
   

   Produzione:

   >> esempio di pitone1.pi
   

2. La funzione può essere restituita da un'altra funzione
   Ex:
   def desiderio():
   def say_wish():
   ritorna "Buon Compleanno"
   ritorna say_wish
   ciao = desiderio()
   Ciao()

   esempio2.pi:
   

   Produzione:

   >>esempio pitone2.pi
   
   Qui la funzione say_wish restituita dalla funzione wish

3. La funzione può essere modificata e assegnata a una variabile
   Ex:
   def add(a,b):
   restituire a +b
   sum2nos = add # Qui la funzione add assegnata alla variabile
   sum2nos(5,11)

   esempio3.pi:
   

   Produzione:
   >> esempio di pitone3.pi
   

4. Definisci la funzione all'interno di un'altra funzione
   Ex:
   def add(a,b):
   def somma2(a,b):
   ritorna a + b
   re = somma2(a,b)
   ritorno res
   aggiungi(10,15)

   esempio4.pi:
   

   Produzione:
   >> esempio pitone4.pi
   

Chiusura:

Python consente a una funzione nidificata di accedere all'ambito esterno della funzione di inclusione.

def saluto(messaggio):
"Funzione di inclusione"
def send_greeting():
"Funzione annidata"
stampa (messaggio)
invia_saluto()
saluto ("Buongiorno")

esempio5.pi:

Produzione:

>> esempio di pitone5.pi

Dopo aver compreso i concetti di cui sopra ora, scriveremo un esempio di decoratore.

Es1: Qui, decoreremo la funzione del messaggio. Stampare il messaggio all'interno **** senza modificare la funzione originale, i.e., funzione di messaggio.

#inizio decoratore
def print_msg(funzione):
def wrapper():
funzione()
involucro di ritorno
#fine decoratore
def messaggio():
print(“Questo è il primo esempio per dimostrare il decoratore”)
ciao = print_msg(messaggio)
Ciao()

esempio6.pi:

Produzione:

>> esempio di pitone6.pi

Nella forma più semplice, possiamo posizionare decoratore sopra la definizione della funzione e chiamare la funzione come mostrato di seguito:

Qui qualunque stringa vogliamo decorare all'interno ***, usa questo decoratore.

Produzione:

Decoratore multiplo:

Possiamo avere più decoratori per una singola funzione. Qui il decoratore è applicato nell'ordine che abbiamo chiamato.
sintassi:
@decoratore2
@decoratore1
Definizione della funzione

Qui verrà applicato il 1° decoratore, quindi il 2° decoratore.

Passaggio di argomenti alle funzioni del decoratore:

Possiamo passare argomenti alla funzione wrapper. Gli argomenti passati alla funzione per cui vogliamo decorare.

Ex:

def deco_wish (funzione):
def wrapper (arg1, arg2):
print('Gli argomenti passati sono ',arg1, arg2)
Stampa ('*********************')
funzione (arg1, arg2)
Stampa ('*********************')
involucro di ritorno
@deco_wish
def desiderio(a1, a2):
stampa(a1,a2)
desiderio ('Buongiorno', 'Buongiorno')
desiderio ('Buono', 'Pomeriggio')

esempio7.pi:

Produzione:

>> esempio di pitone7.pi

Passa un numero variabile di argomenti alla funzione decoratore:

Possiamo passare qualsiasi numero di argomenti usando *args (argomenti non di parole chiave come i numeri) e **kwargs (argomenti di parole chiave come un dizionario). Entrambi sono argomenti posizionali e memorizzano gli argomenti nelle variabili args e kwargs.

Nota: qui possiamo usare qualsiasi nome invece di args e kwargs, ma si consiglia di utilizzare questi nomi.

Ex:

def dec_var_args(funzione):
def wrapper(*args, **kwargs):
print('Gli argomenti senza parole chiave sono', args)
print('Gli argomenti della parola chiave sono', kwargs)
funzione(*argomenti)
involucro di ritorno
@ dec_var_args
def fun_non_key_args(*args):
per io in argomenti:
stampa(i)
@ dec_var_args
def fun_key_args():
print(“Argomenti della parola chiave”)
fun_non_key_args((4,5,6))
fun_key_args(fname='Anand', lname='Math')

esempio8.pi:

Produzione:

>> esempio di pitone8.pi

Es2: supponiamo di avere 2 funzioni
Funzione 1: calcola la somma dei numeri dalla lista data
Funzione 2: moltiplica ogni numero per 2 e aggiungili all'elenco di numeri indicato given
Se vogliamo calcolare il tempo impiegato da ciascuno per l'esecuzione, possiamo farlo in 2 modi

1. Inserisci il codice tra l'ora di inizio e quella di fine in ogni funzione
2. Scrivi decoratore per calcolare il tempo

Vedi sotto il codice risolto usando decoratore:

#inizio decoratore
exe_time_calc(func):
def wrapper(arg):
start_time = datetime.appuntamento.adesso()
funzione(argomento)
end_time = datetime.appuntamento.adesso()
print ("Il tempo impiegato per l'esecuzione della funzione " + func.__name__ + " è " + str(end_time - end_time))
involucro di ritorno
#fine decoratore
@exe_time_calc
def cal_avg(data):
somma = 0
per i dati:
somma += i
print ("La media di un dato elenco di numeri è ", sum//len(data))
@exe_time_calc
def mul_by_2(data):
somma = 0
per i dati:
somma += + (i*2)
print ("La somma di tutti i numeri dopo la moltiplicazione per 2 è ", sum)
cal_avg ([10,20,30,40,50])
mul_by_2([10,20,30,40,50])

esempio9.pi:

Produzione:

>> esempio di pitone9.pi

Il decoratore sopra può essere utilizzato per calcolare il tempo di esecuzione per una qualsiasi delle funzioni. Utilizzando un decoratore, possiamo evitare codice ripetuto quando abbiamo un requisito per calcolare il tempo di esecuzione per posizionare il decoratore sopra la definizione della funzione.

Conclusione:

I decoratori modificano la funzionalità di una funzione/metodo senza modificare il codice originale della funzione che viene decorata. Usando questo, possiamo evitare di scrivere codice ripetuto. Conoscere il concetto di decoratore ci renderà forti in Python. Possiamo usare decoratore nei seguenti casi:

• Autorizzazione in framework Python Es: Flask e Django
• Registrazione
• Misura il tempo di esecuzione