1. Paramètres formels et réels

Les paramètres formels sont les variables définies dans la signature de la fonction. Les paramètres réels correspondent aux valeurs effectivement transmises lors de l'appel de la fonction. Lors de l'exécution, une liaison est établie entre les paramètres formels et réels, puis rompue à la fin de l'appel.

def afficher_infos(nom, age):
    print(f"Nom : {nom}, Âge : {age}")

afficher_infos("Alice", 30)

2. Arguments positionnels

Les arguments positionnels respectent l'ordre de définition des paramètres. Chaque argument réel est assigné au paramètre formel correspondant selon sa position. Le nombre d'arguments doit correspondre exactement au nombre de paramètres définis.

def calculer_surface(longueur, largeur):
    return longueur * largeur

surface = calculer_surface(10, 5)

3. Arguments clés

Lors de l'appel, on peut spécifier explicitement la valeur de chaque paramètre en utilisant son nom. Cela permet de ne pas respecter l'ordre des paramètres. Les arguments clés doivent être placés après les arguments positionnels, et chaque paramètre ne peut recevoir qu'une seule valeur.

def creer_profil(utilisateur, email, role="membre"):
    print(f"{utilisateur} - {email} - {role}")

creer_profil(role="administrateur", utilisateur="Martin", email="martin@example.com")

4. Paramètres par défaut

On peut assigner une valeur par défaut à un paramètre lors de sa définition. Ce paramètre devient optionnel lors de l'appel. Les paramètres avec valeurs par défaut doivent être déclarés après les paramètres sans valeur par défaut. La valeur par défaut est évaluée une seule fois à la définition de la fonction.

def connecter(host="localhost", port=8080):
    print(f"Connexion à {host}:{port}")

connecter()
connecter("serveur.example.com", 9090)

5. Paramètres de longueur variable

Pour accepter un nombre variable d'arguments, on utilise *args pour les arguments positionnels supplémentaires (stockés dans un tuple) et **kwargs pour les arguments clés supplémentaires (stockés dans un dictionnaire). Ces mécanismes augmentent la flexibilité des fonctions.

def journaliser(*messages, niveau="info"):
    for msg in messages:
        print(f"[{niveau}] {msg}")

journaliser("Démarrage", "Initialisation", niveau="débogage")

def configurer(**options):
    for cle, valeur in options.items():
        print(f"{cle} = {valeur}")

configurer(timeout=30, retry=3)

Lorsqu'on combine *args avec des paramètres positionnels, les arguments restants après les premiers paramètres sont capturés par *args. Les paramètres entre *args et **kwargs sont des arguments clés nommés qui doivent être passés explicitement.

def traiter_donnees(principal, *valeurs, mode="défaut"):
    print(f"Traitement {principal}, mode {mode}, valeurs : {valeurs}")

traiter_donnees("base", 1, 2, 3, mode="rapide")

Pour transmettre tous les arguments d'une fonction à une autre sans modification, on peut utiliser le déballage avec * et **. Cette technique préserve la structure des arugments et améliore la réutilisabilité du code.

def interne(a, b, c=0):
    print(a, b, c)

def wrapper(*args, **kwargs):
    interne(*args, **kwargs)

wrapper(1, 2, c=3)