Decoratori di pitone

In questo articolo, discuteremo di decoratori di pitone.

Definizione: il decoratore è un modello di design in Python. È una funzione che prende un'altra funzione come argomento, aggiungi alcune funzionalità senza modificarla e restituisce un'altra funzione.

Questo si chiama usando "(@)" e posizionato prima di definire una funzione che vogliamo decorare.

sintassi:

@Nome del decoratore
Definizione della funzione

Per comprendere i decoratori, dobbiamo conoscere i concetti di seguito.
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 di seguito.

1. Una funzione può essere passata come argomento
   Es: def increment (n):
   restituire n + 1
   def demo_funcall (funzione):
   Num = 5
   Funzione di ritorno (num)
   Demo_FunCall (incremento)

   Qui la funzione di incremento è passata come argomento

   Esempio 1.PY:
   

   Produzione:

   >> Python Esempio1.Py
   

2. La funzione può essere restituita da un'altra funzione
   Es: def Wish ():
   def say_wish ():
   ritorna "buon compleanno"
   return Say_wish
   ciao = desiderio ()
   Ciao()

   Esempio2.PY:
   

   Produzione:

   >> Esempio Python2.Py
   
   Qui la funzione Say_wish è tornata dalla funzione dei desideri

3. La funzione può essere modificata e assegnata a una variabile
   Es: def aggiungi (a, b):
   restituire a +b
   sum2nos = aggiungi # funzione qui aggiunta assegnata alla variabile
   sum2nos (5,11)

   Esempio3.PY:
   

   Produzione:
   >> Python Esempio3.Py
   

4. Definisci la funzione all'interno di un'altra funzione
   Es: def aggiungi (a, b):
   def sum2 (a, b):
   restituire a + b
   res = sum2 (a, b)
   Resto Res
   Aggiungi (10,15)

   Esempio4.PY:
   

   Produzione:
   >> Python Esempio4.Py
   

Chiusura:

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

Def Greeting (Messaggio):
"Funzione di recinto"
def send_greeting ():
"Funzione nidificata"
Stampa (messaggio)
Send_Greeting ()
saluto ("buongiorno")

Esempio5.PY:

Produzione:

>> Esempio Python5.Py

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

Ex1: Qui, decoramo la funzione del messaggio. Stampa il msg all'interno **** senza modificare la funzione originale, i.e., funzione messaggio.

#DECORATOR Avvio
def print_msg (funzione):
def wrapper ():
funzione()
restituzione wrapper
#Decoratore End
DEF Message ():
Stampa ("Questo è il primo esempio per dimostrare il decoratore")
ciao = print_msg (messaggio)
Ciao()

Esempio6.PY:

Produzione:

>> Python Esempio6.Py

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

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

Produzione:

Decoratore multiplo:

Possiamo avere un decoratore multiplo per una singola funzione. Qui il decoratore viene applicato nell'ordine che abbiamo chiamato.
sintassi:
@decoratore2
@decorator1
Definizione della funzione

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

Passando argomenti alle funzioni del decoratore:

Possiamo passare argomenti alla funzione Wrapper. Gli argomenti passati alla funzione per la quale vogliamo decorare.

Ex:

def deco_wish (funzione):
DEF Wrapper (Arg1, Arg2):
Print ("Gli argomenti passati sono", arg1, arg2)
stampa ('*********************')
funzione (arg1, arg2)
stampa ('*********************')
restituzione wrapper
@deco_wish
Def Wish (A1, A2):
Stampa (A1, A2)
Wish ("buono", "mattina")
Wish ("buono", "pomeriggio")

Esempio7.PY:

Produzione:

>> Python Esempio7.Py

Passa il numero variabile di argomenti alla funzione del decoratore:

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

Nota: qui, possiamo usare qualsiasi nome anziché Args e Kwargs, ma questi nomi sono consigliati di utilizzare.

Ex:

def dec_var_args (funzioni):
DEF Wrapper (*Args, ** Kwargs):
Print ("Gli argomenti non per parole chiave sono", args)
Print ("Gli argomenti della parola chiave sono", kwargs)
funzione (*args)
restituzione wrapper
@ Dec_var_args
def fun_non_key_args (*args):
per me in args:
Stampa (i)
@ Dec_var_args
def fun_key_args ():
Stampa ("Argomenti di parole chiave")
fun_non_key_args ((4,5,6))
fun_key_args (fname = 'anand', lname = 'matematica')

Esempio8.PY:

Produzione:

>> Python Esempio8.Py

Ex2: supponiamo di avere 2 funzione
Function1: calcola la somma dei numeri dall'elenco dato
Funzione2: moltiplicare ogni numero per 2 e aggiungerli all'elenco dato di numeri
Se vogliamo calcolare il tempo impiegato da ciascuno per l'esecuzione, possiamo farlo in 2 modi

1. Posizionare il codice tra l'ora di inizio e fine in ciascuna funzione
2. Scrivi il decoratore per il calcolo del tempo

Vedi il codice di seguito risolto usando il decoratore:

#DECORATOR Avvio
exe_time_calc (func):
DEF Wrapper (Arg):
start_time = datetime.appuntamento.Ora()
func (arg)
end_time = datetime.appuntamento.Ora()
Stampa ("The Time Take per l'esecuzione della funzione" + func.__Name__ + "è" + str (end_time - end_time))
restituzione wrapper
#Decoratore End
@exe_time_calc
def cal_avg (dati):
somma = 0
per me in dati:
somma += i
Stampa ("La media dell'elenco dei numeri è", Sum // len (dati))
@exe_time_calc
def mul_by_2 (dati):
somma = 0
per me in dati:
Sum + = + (i*2)
Stampa ("Il SUME di tutti i numeri dopo moltiplicati per 2 è", somma)
cal_avg ([10,20,30,40,50])
MUL_BY_2 ([10,20,30,40,50])

Esempio9.PY:

Produzione:

>> Esempio Python9.Py

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

Conclusione:

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

• Autorizzazione in framework Python Ex: Flask e Django
• Registrazione
• Misurare il tempo di esecuzione