TOC

Comment utiliser * args et ** kwargs en Python 3

introduction

Dansfunction definitions,parameters sont des entités nommées qui spécifient un argument qu'une fonction donnée peut accepter.

Lors de la programmation, il est possible que vous ne soyez pas au courant de tous les cas d'utilisation possibles de votre code et que vous souhaitiez offrir davantage d'options aux futurs programmeurs travaillant avec le module ou aux utilisateurs interagissant avec le code. Nous pouvons passer un nombre variable d'arguments à une fonction en utilisant*args et**kwargs dans notre code.

Comprendre * args

En Python, la forme à astérisque unique de*args peut être utilisée comme paramètre pour envoyer une liste d'arguments de longueur variable sans mot-clé aux fonctions. Il est à noter que l'astérisque (*) est l'élément important ici, car le motargs est l'idiome conventionnel établi, bien qu'il ne soit pas imposé par le langage.

Regardons une fonction typique qui utilise deux arguments:

lets_multiply.py

def multiply(x, y):
    print (x * y)

Dans le code ci-dessus, nous avons construit la fonction avecx ety comme arguments, puis lorsque nous appelons la fonction, nous devons utiliser des nombres pour correspondre àx ety. Dans ce cas, nous passerons l'entier5 pourx et l'entier4 poury:

lets_multiply.py

def multiply(x, y):
    print (x * y)

multiply(5, 4)

Maintenant, nous pouvons exécuter le code ci-dessus: 

python lets_multiply.py

Nous recevrons le résultat suivant, montrant que les entiers 5 et 4 ont été multipliés selon la fonctionmultiply(x,y): 

Output20

Et si, plus tard, nous décidions que nous voudrions multiplier trois nombres plutôt que deux? Si nous essayons d’ajouter un nombre supplémentaire à la fonction, comme indiqué ci-dessous, nous recevrons une erreur.

lets_multiply.py

def multiply(x, y):
    print (x * y)

multiply(5, 4, 3)
OutputTypeError: multiply() takes 2 positional arguments but 3 were given

Donc, si vous pensez que vous pourriez avoir besoin d'utiliser plus d'arguments plus tard, vous pouvez utiliser*args comme paramètre à la place.

Nous pouvons essentiellement créer la même fonction et le même code que ceux que nous avons montrés dans le premier exemple, en supprimantx ety comme paramètres de fonction, et en les remplaçant à la place par*args:

lets_multiply.py

def multiply(*args):
    z = 1
    for num in args:
        z *= num
    print(z)

multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)

Lorsque nous exécutons ce code, nous recevons le produit pour chacun des appels de fonction suivants: 

Output20
90
24
900

Parce que nous avons utilisé*args pour envoyer une liste d'arguments de longueur variable à notre fonction, nous avons pu passer autant d'arguments que nous le souhaitions dans les appels de fonction.

Avec*args, vous pouvez créer un code plus flexible qui accepte une quantité variée d'arguments non mot-clé dans votre fonction.

Comprendre ** kwargs

La forme double astérisque de**kwargs est utilisée pour passer un argument mot-clé de longueur variabledictionary à une fonction. Encore une fois, les deux astérisques (**) sont l'élément important ici, car le motkwargs est conventionnellement utilisé, bien que non imposé par le langage.

Comme*args,**kwargs peut prendre le nombre d'arguments que vous souhaitez lui fournir. Cependant,**kwargs diffère de*args en ce que vous devrez attribuer des mots-clés.

Tout d'abord, imprimons simplement les arguments**kwargs que nous transmettons à une fonction. Nous allons créer une fonction courte pour faire ceci:

print_kwargs.py

def print_kwargs(**kwargs):
        print(kwargs)

Ensuite, nous appellerons la fonction avec des arguments à mots clés passés dans la fonction:

print_kwargs.py

def print_kwargs(**kwargs):
        print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

Lançons le programme ci-dessus et regardons le résultat: 

python print_kwargs.py
Output{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Selon la version de Python 3 que vous utilisez actuellement, le type de données du dictionnaire peut ne pas être ordonné. Dans Python 3.6 et les versions ultérieures, vous recevrez les paires clé-valeur dans l'ordre, mais dans les versions précédentes, les paires seront sorties dans un ordre aléatoire.

Ce qu'il est important de noter, c'est qu'un dictionnaire appelékwargs est créé et que nous pouvons travailler avec lui comme nous pouvons travailler avec d'autres dictionnaires.

Créons un autre programme court pour montrer comment nous pouvons utiliser**kwargs. Ici, nous allons créer une fonction pour accueillir un dictionnaire de noms. Premièrement, nous commencerons par un dictionnaire de deux noms:

print_values.py

def print_values(**kwargs):
    for key, value in kwargs.items():
        print("The value of {} is {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

Nous pouvons maintenant exécuter le programme et regarder le résultat: 

python print_values.py
OutputThe value of your_name is Casey
The value of my_name is Sammy

Encore une fois, comme les dictionnaires peuvent ne pas être ordonnés, votre sortie peut être avec le nomCasey en premier ou avec le nomSammy en premier.

Passons maintenant des arguments supplémentaires à la fonction pour montrer que**kwargs acceptera le nombre d'arguments que vous souhaitez inclure:

print_values.py

def print_values(**kwargs):
    for key, value in kwargs.items():
        print("The value of {} is {}".format(key, value))

print_values(
            name_1="Alex",
            name_2="Gray",
            name_3="Harper",
            name_4="Phoenix",
            name_5="Remy",
            name_6="Val"
        )

Lorsque nous exécuterons le programme à ce stade, nous recevrons la sortie suivante, qui peut à nouveau être non ordonnée: 

OutputThe value of name_2 is Gray
The value of name_6 is Val
The value of name_4 is Phoenix
The value of name_5 is Remy
The value of name_3 is Harper
The value of name_1 is Alex

L'utilisation de**kwargs nous offre la flexibilité d'utiliser des arguments de mots-clés dans notre programme. Lorsque nous utilisons**kwargs comme paramètre, nous n’avons pas besoin de savoir combien d’arguments nous souhaiterions éventuellement passer à une fonction.

Arguments de commande

Lorsque vous commandez des arguments dans une fonction ou un appel de fonction, les arguments doivent apparaître dans un ordre particulier:

  1. Arguments de position formels

  2. *args

  3. Arguments de mots clés

  4. **kwargs

En pratique, lorsque vous travaillez avec des paramètres de position explicites avec*args et**kwargs, votre fonction ressemblerait à ceci: 

def example(arg_1, arg_2, *args, **kwargs):
...

Et, lorsque vous travaillez avec des paramètres de position avec des paramètres de mots-clés nommés en plus de*args et**kwargs, votre fonction ressemblerait à ceci: 

def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...

Il est important de garder à l'esprit l'ordre des arguments lors de la création de fonctions afin de ne pas recevoir d'erreur de syntaxe dans votre code Python.

Utilisation de * args et ** kwargs dans les appels de fonction

Nous pouvons également utiliser*args et**kwargs pour passer des arguments dans les fonctions.

Voyons d'abord un exemple avec*args.

some_args.py

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")
some_args(*args)

Dans la fonction ci-dessus, il existe trois paramètres définis commearg_1,arg_ etarg_3. La fonction affichera chacun de ces arguments. Nous créons ensuite une variable qui est définie sur un itérable (dans ce cas, untuple), et pouvons passer cette variable dans la fonction avec la syntaxe astérisque.

Lorsque nous exécutons le programme avec la commandepython some_args.py, nous recevrons le résultat suivant: 

Outputarg_1: Sammy
arg_2: Casey
arg_3: Alex

Nous pouvons également modifier le programme ci-dessus en unlist data type itérable avec un nom de variable différent. Combinons également la syntaxe*args avec unnamed parameter:

some_args.py

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

my_list = [2, 3]
some_args(1, *my_list)

Si nous exécutons le programme ci-dessus, il produira le résultat suivant: 

Outputarg_1: 1
arg_2: 2
arg_3: 3

De même, les arguments**kwargs mot-clés peuvent être utilisés pour appeler une fonction. Nous allons configurer une variable égale à un dictionnaire avec 3 paires clé-valeur (nous allons utiliserkwargs ici, mais elle peut être appelée comme vous le souhaitez), et la passer à une fonction avec 3 arguments:

some_kwargs.py

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
    print("kwarg_1:", kwarg_1)
    print("kwarg_2:", kwarg_2)
    print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}
some_kwargs(**kwargs)

Exécutons le programme ci-dessus avec la commandepython some_kwargs.py: 

Outputkwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Lors de l'appel d'une fonction, vous pouvez utiliser*args et**kwargs pour passer des arguments.

Conclusion

Nous pouvons utiliser la syntaxe spéciale de*args et**kwargs dans une définition de fonction afin de passer un nombre variable d'arguments à la fonction.

La création de fonctions qui acceptent*args et**kwargs est mieux utilisée dans les situations où vous prévoyez que le nombre d'entrées dans la liste d'arguments restera relativement petit. L'utilisation de*args et**kwargs est principalement pour assurer la lisibilité et la commodité, mais doit être faite avec précaution.

Related