Fonctions avancées : paramètres et annotations

Fonctions avancées : paramètres et annotations

Vous savez écrire une fonction avec des paramètres et un return. Voyons les outils qui rendent les fonctions plus souples, plus sûres et plus lisibles.

Un nombre variable d’arguments : *args

def total(*montants):
    """Additionne autant de montants que l'on veut."""
    # montants est un tuple contenant tous les arguments positionnels
    return sum(montants)

print(total(10, 20))          # 30
print(total(5, 5, 5, 5))      # 20
valeurs = [1, 2, 3]
print(total(*valeurs))        # 6 : * déballe la liste en arguments

Le nom args est une convention ; c’est l’étoile qui compte.

Des options nommées : **kwargs

def creer_utilisateur(nom, **infos):
    # infos est un dictionnaire des arguments nommés supplémentaires
    fiche = {"nom": nom}
    fiche.update(infos)
    return fiche

print(creer_utilisateur("Lina", ville="Lille", age=31))
# {'nom': 'Lina', 'ville': 'Lille', 'age': 31}
options = {"ville": "Brest"}
print(creer_utilisateur("Yanis", **options))   # ** déballe un dictionnaire

L’ordre dans une signature est toujours : paramètres normaux, *args, paramètres nommés, **kwargs.

Forcer les arguments nommés

Un * seul dans la signature oblige à nommer les paramètres qui suivent. C’est précieux pour les options booléennes, illisibles en positionnel :

def exporter(donnees, *, separateur=";", entete=True):
    ...

exporter(lignes, separateur=",")   # clair
# exporter(lignes, ",", False)     # TypeError : arguments nommés obligatoires

Le piège des valeurs par défaut mutables

Une valeur par défaut est créée une seule fois, au moment où la fonction est définie. Avec une liste, elle est donc partagée entre les appels :

def ajouter(article, panier=[]):      # À ÉVITER
    panier.append(article)
    return panier

print(ajouter("pomme"))   # ['pomme']
print(ajouter("poire"))   # ['pomme', 'poire'] : surprise !

def ajouter(article, panier=None):    # version correcte
    if panier is None:
        panier = []
    panier.append(article)
    return panier

Les annotations de type

Les annotations indiquent les types attendus. Python ne les vérifie pas à l’exécution, mais votre éditeur et des outils comme mypy s’en servent pour détecter des erreurs, et elles documentent le code :

def moyenne(valeurs: list[float], arrondi: int = 2) -> float | None:
    """Renvoie la moyenne, ou None si la liste est vide."""
    if not valeurs:
        return None
    return round(sum(valeurs) / len(valeurs), arrondi)

Depuis Python 3.9, on écrit list[float] ou dict[str, int] directement ; depuis 3.10, float | None signifie « un float ou None ». Depuis Python 3.14, les annotations ne sont évaluées que lorsqu’on les consulte : une fonction peut être annotée avec une classe définie plus bas dans le fichier, sans guillemets (avant 3.14, cela provoquait une NameError).

À retenir

• *args → tuple, **kwargs → dictionnaire ; * et ** déballent aussi à l’appel.
• * seul rend les paramètres suivants obligatoirement nommés.
• Utilisez None comme valeur par défaut pour les objets modifiables.
• Annotez vos fonctions : c’est de la documentation vérifiable par les outils.