Arguments et Kwargs en Python

Introduction

Dans ce laboratoire, vous apprendrez ce que sont *args et **kwargs en Python. Ces syntaxes spéciales peuvent sembler intimidantes au premier abord, mais elles sont simples à comprendre et offrent un moyen puissant de rendre vos fonctions plus flexibles. Vous apprendrez à définir des fonctions capables d'accepter un nombre variable d'arguments, ce qui est une fonctionnalité courante et utile dans de nombreux programmes et bibliothèques Python.

Args et Kwargs

Dans cette étape, vous apprendrez la syntaxe de base de *args et **kwargs. Celles-ci sont utilisées dans les définitions de fonctions pour permettre de passer un nombre indéfini d'arguments. *args est destiné aux arguments positionnels non-nommés (non-keyword), tandis que **kwargs est destiné aux arguments nommés (keyword arguments).

Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez d'abord vous familiariser avec celui-ci dans ce lab.

Tout d'abord, voyons comment définir une fonction capable d'accepter n'importe quelle combinaison d'arguments. Dans l'explorateur de fichiers à gauche, trouvez le fichier main.py situé dans le répertoire ~/project et ouvrez-le dans l'éditeur.

Ajoutez le code suivant à main.py:

## Define a function that accepts any number of positional and keyword arguments
def some_function(*args, **kwargs):
    print("This function can accept any arguments.")
    print(f"Received positional arguments: {args}")
    print(f"Received keyword arguments: {kwargs}")
    print("-" * 20)

## Call with any number of positional arguments
some_function('arg1', 'arg2', 'arg3')

## Call with any number of keyword arguments
some_function(key1='arg1', key2='arg2', key3='arg3')

## Call with both positional and keyword arguments
some_function('positional_arg', key1='keyword_arg')

## Or call with no arguments at all
some_function()

Il est important de noter que args et kwargs ne sont que des conventions de nommage. L'astérisque simple (*) et l'astérisque double (**) constituent la syntaxe réelle qui effectue le travail. Cependant, suivre la convention est considéré comme une bonne pratique dans la communauté Python.

Maintenant, exécutez le script en ouvrant un terminal dans le WebIDE et en exécutant la commande suivante :

python3 main.py

Vous devriez voir la sortie suivante, démontrant comment la fonction gère les différents appels :

This function can accept any arguments.
Received positional arguments: ('arg1', 'arg2', 'arg3')
Received keyword arguments: {}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {'key1': 'arg1', 'key2': 'arg2', 'key3': 'arg3'}
--------------------
This function can accept any arguments.
Received positional arguments: ('positional_arg',)
Received keyword arguments: {'key1': 'keyword_arg'}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {}
--------------------

Ceci montre que *args collecte les arguments positionnels dans un tuple et que **kwargs collecte les arguments nommés dans un dictionnaire.

args

Dans cette étape, vous vous concentrerez spécifiquement sur *args. Cette syntaxe permet à une fonction d'accepter un nombre arbitraire d'arguments positionnels. Ces arguments sont collectés dans un tuple.

Effacez le contenu précédent de main.py et ajoutez le code suivant. Cet exemple définit une fonction qui prend *args et imprime les arguments qu'elle reçoit, ainsi que leur type.

## *args collects positional arguments into a tuple
def some_function(*args):
    print(f'Arguments passed: {args} as {type(args)}')

## Pass multiple arguments - they'll be collected into the args tuple
some_function('arg1', 'arg2', 'arg3')

Dans ce code, *args dans la signature de la fonction indique à Python de rassembler tous les arguments positionnels supplémentaires passés à some_function et de les placer dans un tuple nommé args.

Maintenant, exécutez le script depuis le terminal :

python3 main.py

La sortie confirmera que les arguments ont été passés sous forme de tuple :

Arguments passed: ('arg1', 'arg2', 'arg3') as <class 'tuple'>

Ceci démontre comment *args fournit un moyen simple de gérer un nombre variable d'entrées sans avoir à définir chacune d'elles comme un paramètre distinct.

kwargs

Dans cette étape, vous apprendrez à utiliser **kwargs. Cette syntaxe est utilisée pour collecter un nombre arbitraire d'arguments par mot-clé (keyword arguments) dans un dictionnaire. Ceci est utile lorsque vous souhaitez gérer des arguments nommés que vous n'avez pas définis à l'avance.

Effacez le contenu de main.py et ajoutez le code suivant. Cet exemple définit une fonction qui accepte **kwargs et imprime les arguments par mot-clé collectés ainsi que leur type.

## **kwargs collects keyword arguments into a dictionary
def some_function(**kwargs):
    print(f'keywords: {kwargs} as {type(kwargs)}')

## Pass keyword arguments - they'll be collected into the kwargs dict
some_function(key1='arg1', key2='arg2')

Ici, **kwargs dans la signature de la fonction indique à Python de collecter tous les arguments par mot-clé passés à some_function dans un dictionnaire nommé kwargs. Les clés du dictionnaire sont les noms des arguments, et les valeurs sont les valeurs des arguments.

Exécutez le script depuis le terminal :

python3 main.py

La sortie montrera que les arguments par mot-clé ont été collectés dans un dictionnaire :

keywords: {'key1': 'arg1', 'key2': 'arg2'} as <class 'dict'>

Cette fonctionnalité est largement utilisée en Python pour les fonctions qui doivent transmettre des options ou des configurations, permettant des appels de fonction clairs et lisibles.

Résumé

Dans ce laboratoire, vous avez appris à utiliser *args et **kwargs en Python pour créer des fonctions plus flexibles.

Vous avez appris que :

• *args collecte un nombre variable d'arguments positionnels dans un tuple.
• **kwargs collecte un nombre variable d'arguments par mot-clé dans un dictionnaire.
• args et kwargs sont des noms conventionnels, mais c'est la syntaxe * et ** qui active cette fonctionnalité.

Maîtriser *args et **kwargs est une étape clé dans l'écriture de code Python plus avancé et réutilisable. Vous pouvez désormais créer des fonctions plus adaptables à différents types d'entrées.