Python débutant : comprendre *args et **kwargs

Difficulté

Facile

Quand on débute en Python, on apprend vite à définir des fonctions avec un nombre fixe de paramètres. Pourtant, il existe des cas où l'on veut accepter un nombre variable de valeurs, sans réécrire une nouvelle fonction à chaque fois.

Les notations *args et **kwargs servent précisément à cela. Vous allez les manipuler pas à pas avec des exemples courts, pour comprendre quand les utiliser et comment éviter les erreurs fréquentes.

Prérequis

Vous devez connaître la définition simple d'une fonction en Python, savoir appeler une fonction et reconnaître une liste, un tuple et un dictionnaire. Aucun framework ni bibliothèque externe n'est nécessaire.

Matériel nécessaire

• Python 3 installé sur votre machine ou un interpréteur en ligne
• Un éditeur de texte ou un environnement comme IDLE, VS Code ou Thonny
• Un terminal ou une console Python pour exécuter les exemples

Étapes

1. 1

   Créer une première fonction avec *args

   

   Commencez par écrire une fonction qui additionne tous les nombres reçus, sans fixer leur quantité à l'avance.

   def additionner(*args):
       total = 0
       for nombre in args:
           total += nombre
       return total
   
   print(additionner(2, 4))
   print(additionner(2, 4, 6, 8))

   Ici, *args récupère tous les arguments positionnels supplémentaires. Vous pouvez alors les parcourir dans une boucle comme n'importe quelle collection.

2. 2

   Afficher le contenu reçu par *args

   Écrivez maintenant une fonction très simple pour voir exactement ce que Python place dans *args.

   def montrer(*args):
       print(args)
   
   montrer(10, 20, 30)
   montrer("a", "b")

   Vous verrez à l'écran un tuple contenant les valeurs passées à l'appel. Cela aide à comprendre que *args n'est pas magique : c'est un regroupement de plusieurs arguments en une seule variable.

3. 3

   Utiliser **kwargs pour accepter des arguments nommés

   Passez ensuite aux arguments nommés variables avec **kwargs. Créez une fonction qui affiche les informations reçues.

   def afficher_profil(**kwargs):
       print(kwargs)
   
   afficher_profil(nom="Lina", age=24)
   afficher_profil(ville="Lyon", metier="Dev")

   Cette fois, Python regroupe les arguments nommés dans un dictionnaire. Chaque nom devient une clé et chaque valeur associée devient la valeur du dictionnaire.

4. 4

   Parcourir les clés et valeurs de **kwargs

   Modifiez la fonction précédente pour exploiter réellement le dictionnaire reçu.

   def afficher_profil(**kwargs):
       for cle, valeur in kwargs.items():
           print(cle, ":", valeur)
   
   afficher_profil(nom="Lina", age=24, ville="Lyon")

   Cette forme est utile quand le nombre d'informations peut varier d'un appel à l'autre. La fonction reste souple, tout en conservant des noms explicites pour chaque donnée.

5. 5

   Mélanger paramètres classiques et *args

   Ajoutez maintenant un paramètre normal avant *args. Par exemple, imposez une valeur de départ puis acceptez autant de nombres supplémentaires que nécessaire.

   def additionner_depuis(depart, *args):
       total = depart
       for nombre in args:
           total += nombre
       return total
   
   print(additionner_depuis(10, 2, 3))
   print(additionner_depuis(5))

   Dans cet appel, la première valeur va dans depart, puis les suivantes sont placées dans args. Cette combinaison est fréquente quand une partie des paramètres doit rester obligatoire.

6. 6

   Combiner paramètres classiques, *args et **kwargs

   Écrivez une fonction plus complète pour voir l'ordre habituel des paramètres.

   def presenter(role, *args, **kwargs):
       print("role :", role)
       print("args :", args)
       print("kwargs :", kwargs)
   
   presenter("admin", 1, 2, nom="Lina", actif=True)

   Le paramètre classique reçoit d'abord la première valeur positionnelle. Ensuite, *args collecte les autres arguments positionnels, et **kwargs récupère les arguments nommés.

7. 7

   Déballer une liste avec * lors de l'appel

   

   Utilisez maintenant l'astérisque du côté de l'appel de fonction. Créez une liste, puis transmettez son contenu comme plusieurs arguments séparés.

   def multiplier(a, b, c):
       return a * b * c
   
   valeurs = [2, 3, 4]
   print(multiplier(*valeurs))

   Ici, *valeurs déballe la liste pour fournir trois arguments positionnels distincts. C'est le même symbole, mais employé cette fois à l'appel et non dans la définition.

8. 8

   Déballer un dictionnaire avec ** lors de l'appel

   

   Faites la même chose avec un dictionnaire pour alimenter des paramètres nommés.

   def saluer(nom, ville):
       print(f"Bonjour {nom}, depuis {ville} !")
   
   infos = {"nom": "Lina", "ville": "Lyon"}
   saluer(**infos)

   Le dictionnaire est déballé en arguments nommés. Les clés doivent correspondre exactement aux noms des paramètres de la fonction.

9. 9

   Tester un exemple concret de fonction flexible

   Terminez avec une fonction simple qui combine ce que vous avez vu. Elle reçoit un titre obligatoire, plusieurs tags éventuels, puis des options nommées.

   def creer_message(titre, *tags, **options):
       print("Titre :", titre)
       print("Tags :", tags)
       print("Options :", options)
   
   creer_message("Bienvenue", "python", "debutant", couleur="bleu", publie=True)

   Ce type de signature est utile pour écrire des fonctions réutilisables, sans fixer tous les cas d'usage dès le départ. Vous gardez un point d'entrée clair, tout en laissant de la souplesse sur les données supplémentaires.

Erreurs fréquentes & dépannage

L'erreur la plus fréquente consiste à confondre *args et **kwargs. Le premier récupère des arguments positionnels, tandis que le second récupère des arguments nommés.

Une autre erreur courante est de croire que args et kwargs sont des mots réservés. En réalité, c'est surtout la présence de * et ** qui compte, même si les noms conventionnels restent préférables.

Enfin, certains débutants oublient que le déballage à l'appel doit correspondre à la signature attendue. Une liste avec trop peu d'éléments, ou un dictionnaire avec de mauvaises clés, provoquera une erreur.

Astuces & pour aller plus loin

Commencez par afficher directement args et kwargs avec print() avant d'écrire une logique plus complexe. Cette habitude rend leur structure beaucoup plus concrète.

Quand une fonction a un comportement bien défini avec quelques paramètres obligatoires, gardez ces paramètres explicitement dans la signature. Utilisez ensuite *args ou **kwargs seulement pour la partie vraiment variable.

Questions fréquentes

Est-ce que *args doit obligatoirement s'appeler args ?

Non. Le nom est libre, comme pour n'importe quelle variable. En pratique, *args est une convention largement utilisée car elle rend le code plus lisible.

Est-ce que **kwargs doit obligatoirement s'appeler kwargs ?

Non. Là encore, le nom est libre. La convention **kwargs reste la plus courante pour indiquer clairement qu'il s'agit d'arguments nommés variables.

Peut-on utiliser *args sans **kwargs ?

Oui. Vous pouvez utiliser seulement *args, seulement **kwargs, ou les deux ensemble selon le besoin de la fonction.

Que contient exactement *args dans une fonction ?

*args contient un tuple regroupant les arguments positionnels supplémentaires reçus par la fonction.

Que contient exactement **kwargs dans une fonction ?

**kwargs contient un dictionnaire regroupant les arguments nommés supplémentaires transmis à la fonction.

À quoi sert l'étoile * lors de l'appel d'une fonction ?

Lors de l'appel, * sert à déballer une séquence comme une liste ou un tuple en plusieurs arguments positionnels.

À quoi sert le double astérisque ** lors de l'appel d'une fonction ?

Lors de l'appel, ** sert à déballer un dictionnaire en arguments nommés, à condition que ses clés correspondent aux paramètres attendus.

Conclusion

*args et **kwargs permettent d'écrire des fonctions plus flexibles, sans compliquer inutilement le code si vous les utilisez avec mesure. Pour bien les retenir, le plus efficace est de tester de petits appels, d'afficher ce que reçoit la fonction, puis de combiner progressivement paramètres classiques, déballage et arguments variables.