Python 9.5 : Nombre variable de paramètres

Jusqu'à présent, nos fonctions Python prenaient un nombre fixe de paramètres. Mais comment faire si l'on ne connaît pas à l'avance combien d'arguments seront passés ? C'est exactement le rôle de *args et **kwargs, deux mécanismes Python très pratiques pour rendre une fonction flexible.

Différences entre *args et **kwargs

*args : reçoit un nombre variable d'arguments positionnels sous forme de tuple.
**kwargs : reçoit un nombre variable d'arguments nommés sous forme de dictionnaire.
On peut itérer avec une boucle for sur args.
On peut « dépacker » une liste avec * lors de l'appel.

Imaginons que nous voulions calculer la somme des notes d'un étudiant sans connaître le nombre de matières. Au lieu d'écrire somme(a, b, c, d, e, f...) avec un nombre fixe d'arguments, nous écrivons somme(*notes). À l'intérieur, notes se comporte comme un tuple parcourable avec for. Cela permet de gérer 3, 10 ou 100 valeurs sans changer la signature de la fonction.

def somme(*notes):
    total = 0
    for n in notes:
        total += n
    return total

print(somme(12, 10, 14))            # 36
print(somme(12, 10, 14, 8, 11))     # 55

notes = [12, 10, 14, 8, 11]
print(somme(*notes))                # déballage de la liste

Avec **kwargs (double étoile), on peut aussi passer des paires clé/valeur comme physique=12, maths=15. Pour les itérer, il faut utiliser .values() sur le dictionnaire. Dans notre cas pratique, *args suffit. Cette flexibilité est une grande force de Python et sera très utile dans la prochaine section consacrée aux collections (listes, tuples, dictionnaires).

En résumé

Cette leçon explique comment créer des fonctions Python acceptant un nombre variable de paramètres. On découvre comment utiliser `*args` pour passer plusieurs arguments sans les déclarer individuellement, puis on explore `**kwargs` pour manipuler des dictionnaires avec clés et valeurs. Des exemples pratiques montrent comment calculer la somme de notes d'un étudiant quel que soit le nombre de matières.

Points clés

Utiliser `*args` pour accepter un nombre indéfini d'arguments positionnels dans une fonction
Itérer sur les arguments avec une boucle (ex: `for note in notes`) pour les traiter collectivement
Distinguer `*` (qui crée un tuple) et `**` (qui crée un dictionnaire) selon le type de données attendu
Adapter une fonction pour calculer dynamiquement une somme ou une opération sans redéfinir les paramètres à chaque appel
Appeler la fonction avec autant d'arguments que nécessaire : `somme(12, 10, 8, 11)` plutôt que de redéfinir la signature

Questions fréquentes

Quelle est la différence entre `*args` et `**kwargs` en Python ?

`*args` (une étoile) accepte un nombre variable d'arguments positionnels et les regroupe dans un tuple, tandis que `**kwargs` (deux étoiles) accepte des paires clé-valeur et les regroupe dans un dictionnaire. Dans l'exemple du cours, `*args` permet de passer plusieurs notes et `**kwargs` permettrait de passer des données structurées comme `{'physique': 12, 'math': 15}`.

Pourquoi utiliser `*args` plutôt qu'une liste en paramètre ?

Avec `*args`, l'appel de la fonction est plus naturel et lisible : `somme(12, 10, 8)` au lieu de `somme([12, 10, 8])`. De plus, `*args` offre une flexibilité pour ajouter des arguments à chaque appel sans modifier la structure du code.

Comment récupérer les valeurs d'un dictionnaire passé avec `**kwargs` dans la fonction ?

On utilise `.values()` pour accéder aux valeurs du dictionnaire, par exemple `for valeur in kwargs.values()`. Dans le cours, cela permet de traiter les données du dictionnaire comme dans l'exemple avec les matières et leurs notes.