Décorateurs Python

Dans cet article, nous allons discuter des décorateurs Python.

Définition : Decorator est un modèle de conception en Python. C'est une fonction qui prend une autre fonction comme argument, lui ajoute des fonctionnalités sans la modifier et renvoie une autre fonction.

Ceci est appelé en utilisant "(@)" et placé avant de définir une fonction que nous voulons décorer.

syntaxe:

@nom du décorateur
Définition de la fonction

Pour comprendre les décorateurs, nous devons connaître les concepts ci-dessous.
Les fonctions sont des objets de première classe. Cela signifie qu'une fonction peut être passée en argument, peut être renvoyée par une autre fonction, peut être affectée à une variable, peut être définie dans une autre fonction. Pour une meilleure compréhension, voir les exemples ci-dessous.

1. Une fonction peut être passée en argument
   Ex:
   def incrément(n):
   retour n+1
   def demo_funcall (fonction):
   nombre = 5
   fonction de retour (nombre)
   demo_funcall (incrémenter)

   Ici la fonction d'incrémentation passée en argument

   Exemple 1.py :
   

   Production:

   >> exemple python1.py
   

2. La fonction peut être renvoyée par une autre fonction
   Ex:
   def wish() :
   def say_wish() :
   retour "Joyeux anniversaire"
   retourner say_wish
   bonjour = souhaite()
   Bonjour()

   exemple2.py :
   

   Production:

   >>exemple python2.py
   
   Voici la fonction say_wish renvoyée par la fonction wish

3. La fonction peut être modifiée et affectée à une variable
   Ex:
   def ajouter(a,b):
   retourner a + b
   sum2nos = add # Ici la fonction add affectée à la variable
   somme2nos(5,11)

   exemple3.py :
   

   Production:
   >> exemple python3.py
   

4. Définir une fonction dans une autre fonction
   Ex:
   def ajouter(a,b):
   def sum2(a,b):
   retourner a + b
   res = somme2(a,b)
   retour res
   ajouter (10,15)

   exemple4.py :
   

   Production:
   >> exemple python4.py
   

Fermeture:

Python permet à une fonction imbriquée d'accéder à la portée extérieure de la fonction englobante.

def salutation (message):
"Fonction Enclos"
def send_greeting() :
"Fonction imbriquée"
imprimer (message)
envoyer des voeux()
salutation ("Bonjour")

exemple5.py :

Production:

>> exemple python5.py

Après avoir compris les concepts ci-dessus maintenant, nous allons écrire un exemple de décorateur.

Ex1 : Ici, nous allons décorer la fonction message. Impression du msg à l'intérieur de **** sans modifier la fonction d'origine, je.e., fonction de message.

#décorateur début
def print_msg (fonction):
def wrapper() :
une fonction()
emballage de retour
#décorateur fin
def message() :
print(« Ceci est le premier exemple de démonstration du décorateur »)
bonjour = print_msg(message)
Bonjour()

exemple6.py :

Production:

>> exemple python6.py

Dans la forme la plus simple, nous pouvons placer le décorateur au-dessus de la définition de la fonction et appeler la fonction comme indiqué ci-dessous :

Ici quelle que soit la ficelle que nous voulons décorer à l'intérieur ***, utilisez ce décorateur.

Production:

Décorateur multiple :

Nous pouvons avoir plusieurs décorateurs pour une seule fonction. Ici, le décorateur est appliqué dans l'ordre que nous avons appelé.
syntaxe:
@ décorateur2
@ décorateur1
Définition de la fonction

Ici le 1er décorateur sera appliqué, puis le 2ème décorateur.

Passer des arguments aux fonctions du décorateur :

Nous pouvons passer des arguments à la fonction wrapper. Les arguments passés à la fonction pour laquelle on veut décorer.

Ex:

def deco_wish (fonction):
def wrapper (arg1, arg2) :
print ('Les arguments passés sont ',arg1, arg2)
imprimer ('*********************')
fonction (arg1, arg2)
imprimer ('*********************')
emballage de retour
@deco_wish
def souhait(a1, a2) :
imprimer(a1,a2)
souhait ("Bon", "Bonjour")
souhait ('Bon', 'Après-midi')

exemple7.py :

Production:

>> exemple python7.py

Passez un nombre variable d'arguments à la fonction décorateur :

Nous pouvons passer n'importe quel nombre d'arguments en utilisant *args (arguments non-clés comme les nombres) et **kwargs (arguments clés comme un dictionnaire). Les deux sont des arguments positionnels et stockent les arguments dans les variables args et kwargs.

Remarque : Ici, nous pouvons utiliser n'importe quel nom au lieu de args et kwargs, mais il est recommandé d'utiliser ces noms.

Ex:

def dec_var_args (fonction) :
def wrapper(*args, **kwargs):
print('Les arguments sans mot-clé sont', args)
print('Les arguments des mots-clés sont', kwargs)
fonction(*args)
emballage de retour
@ dec_var_args
def fun_non_key_args(*args):
pour I dans args :
imprimer(i)
@ dec_var_args
def fun_key_args() :
print(« arguments du mot clé »)
fun_non_key_args((4,5,6))
fun_key_args(fname='Anand', lname='Math')

exemple8.py :

Production:

>> exemple python8.py

Ex2 : Supposons que nous ayons 2 fonctions
Function1: Calculer la somme des nombres de la liste donnée
Fonction2 : Multipliez chaque nombre par 2 et ajoutez-les à la liste de nombres donnée
Si on veut calculer le temps mis par chacun pour l'exécution, on peut le faire de 2 manières

1. Placez le code entre l'heure de début et de fin dans chaque fonction
2. Décorateur d'écriture pour calculer le temps

Voir ci-dessous le code résolu à l'aide du décorateur :

#décorateur début
exe_time_calc(func):
def wrapper(arg):
start_time = datetime.dateheure.à présent()
fonction(arg)
end_time = datetime.dateheure.à présent()
print ("Le temps d'exécution de la fonction " + func.__name__ + " est " + str(end_time - end_time))
emballage de retour
#décorateur fin
@exe_time_calc
def cal_moy(données) :
somme = 0
pour i dans les données :
somme += je
print ("La moyenne d'une liste de nombres donnée est ", sum//len(data))
@exe_time_calc
def mul_by_2(données) :
somme = 0
pour i dans les données :
somme += + (i*2)
print ("La somme de tous les nombres après multiplication par 2 est ", somme)
cal_moy ([10,20,30,40,50])
mul_by_2([10,20,30,40,50])

exemple9.py :

Production:

>> exemple python9.py

Le décorateur ci-dessus peut être utilisé pour calculer le temps d'exécution de l'une des fonctions. En utilisant un décorateur, nous pouvons éviter la répétition de code lorsque nous avons besoin de calculer le temps d'exécution pour placer le décorateur au-dessus de la définition de la fonction.

Conclusion:

Les décorateurs modifient la fonctionnalité d'une fonction/méthode sans modifier le code d'origine de la fonction en cours de décoration. En utilisant cela, nous pouvons éviter d'écrire du code répété. Connaître le concept de décorateur nous rendra forts en python. Nous pouvons utiliser le décorateur dans les cas ci-dessous :

• Autorisation dans les frameworks Python Ex : Flask et Django
• Enregistrement
• Mesurer le temps d'exécution