Décorateurs de python

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

Définition: le décorateur est un motif de conception en python. C'est une fonction qui prend une autre fonction comme un argument, ajoutez-y des fonctionnalités sans la modifier et renvoie une autre fonction.

Ceci est appelé à l'aide de «(@)» et placé avant de définir une fonction que nous voulons décorer.

syntaxe:

Nom @decorator
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 adoptée comme argument, peut être renvoyée d'une autre fonction, peut être affectée à une variable, peut être définie dans une autre fonction. Pour une meilleure compréhension, consultez les exemples ci-dessous.

1. Une fonction peut être adoptée comme un argument
   Ex: incrément de défaite (n):
   retourner n + 1
   DEF DEMO_FUNCALL (FONCTION):
   num = 5
   Fonction de retour (NUM)
   Demo_funcall (incrément)

   Ici, la fonction d'incrément est passée comme un argument

   Exemple 1.py:
   

   Sortir:

   >> Python Exemple1.py
   

2. La fonction peut être renvoyée d'une autre fonction
   Ex: Def Wish ():
   def Say_wish ():
   Retour "Joyeux anniversaire"
   Retour Say_wish
   Bonjour = souhait ()
   Bonjour()

   exemple2.py:
   

   Sortir:

   >> Python Exemple2.py
   
   Ici la fonction Say_wish est retournée de la fonction de souhait

3. La fonction peut être modifiée et affectée à une variable
   Ex: Def add (a, b):
   retourner un + b
   sum2NOS = Add # Fonction Ici Ajouter Ajouter à la variable
   sum2nos (5,11)

   Exemple3.py:
   

   Sortir:
   >> Python Exemple3.py
   

4. Définissez la fonction dans une autre fonction
   Ex: Def add (a, b):
   def sum2 (a, b):
   retourner un + b
   res = sum2 (a, b)
   Retour Res
   ajouter (10,15)

   exemple4.py:
   

   Sortir:
   >> Python Exemple4.py
   

Fermeture:

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

Def Greeting (Message):
"Fonction en enclosong"
def send_greeting ():
"Fonction imbriquée"
Imprimer (message)
envoyer des voeux()
salutation ("bonjour")

exemple5.py:

Sortir:

>> Python Exemple5.py

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

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

#Decorator Start
def print_msg (fonction):
def wrapper ():
fonction()
wrapper de retour
#decorator end
Def message ():
Imprimer («Ceci est le premier exemple pour démontrer le décorateur»)
bonjour = print_msg (message)
Bonjour()

exemple6.py:

Sortir:

>> Python Exemple6.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 chaîne que nous voulons décorer à l'intérieur ***, utilisez ce décorateur.

Sortir:

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.

Arguments de passage aux fonctions du décorateur:

Nous pouvons transmettre des arguments à la fonction de wrapper. Les arguments transmis à la fonction pour laquelle nous voulons décorer.

Ex:

def deco_wish (fonction):
Def Wrapper (Arg1, Arg2):
imprimer («les arguments passés sont», arg1, arg2)
imprimer ('*********************')
fonction (arg1, arg2)
imprimer ('*********************')
wrapper de retour
@deco_wish
Def Wish (A1, A2):
Imprimer (A1, A2)
souhait («bon», «matin»)
souhait («bon», «après-midi»)

Exemple7.py:

Sortir:

>> Python Exemple7.py

Passer le nombre variable d'arguments à la fonction du décorateur:

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

Remarque: Ici, nous pouvons utiliser n'importe quel nom au lieu des args et kwargs, mais ces noms sont recommandés pour utiliser.

Ex:

DEC DEC_VAR_ARGS (FURTION):
def wrapper (* args, ** kwargs):
imprimer («les arguments de mots clés sont», args)
imprimer («les arguments de mots clés sont», Kwargs)
fonction (* args)
wrapper de retour
@ dec_var_args
def fun_non_key_args (* args):
pour je dans args:
Imprimer (i)
@ dec_var_args
def fun_key_args ():
imprimer («arguments de mots clés»)
fun_non_key_args ((4,5,6))
fun_key_args (fname = 'anand', lname = 'math')

exemple8.py:

Sortir:

>> Python Exemple8.py

Ex2: Supposons que nous ayons 2 fonction
Fonction1: Calculez la somme des nombres de la liste donnée
FONCTION2: Multipliez chaque numéro par 2 et ajoutez-les à la liste donnée des nombres
Si nous voulons calculer le temps pris par chacun pour exécuter, peut le faire de 2 manières

1. Placer le code entre le début et l'heure de fin de chaque fonction
2. Écrivez le décorateur pour calculer le temps

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

#Decorator Start
exe_time_calc (func):
def wrapper (arg):
start_time = datetime.DateTime.maintenant()
func (arg)
end_time = datetime.DateTime.maintenant()
imprimer ("l'heure à prendre pour l'exécution de la fonction" + func.__Name__ + "Is" + str (end_time - end_time)))
wrapper de retour
#decorator end
@exe_time_calc
DEF CAL_AVG (DATA):
sum = 0
pour i dans les données:
sum + = i
imprimer ("La moyenne de la liste donnée des nombres est", sum // len (data))
@exe_time_calc
DEF MUL_BY_2 (DATA):
sum = 0
pour i dans les données:
sum + = + (i * 2)
Print ("Le sume de tous les nombres après multiplier par 2 est", sum)
CAL_AVG ([10,20,30,40,50])
MUL_BY_2 ([10,20,30,40,50])

exemple9.py:

Sortir:

>> Python Exemple9.py

Le décorateur ci-dessus peut être utilisé pour calculer le temps d'exécution pour l'une des fonctions. En utilisant un décorateur, nous pouvons éviter le code répété lorsque nous avons une exigence de calcul du 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 décorée. En utilisant cela, nous pouvons éviter d'écrire du code répété. Connaître le concept de décorateur nous rendra fort à Python. Nous pouvons utiliser le décorateur dans les cas ci-dessous:

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