Formations — 1 037 leçons en français

Accueil › Python › Annotations de type

Annotations de type

Modules, environnements et typageintermediaire

Une annotation dit quel type une valeur est censée avoir. Elle ne change rien à l'exécution.

def total_ttc(prix: list[float], taux: float = 0.20) -> float:
    return round(sum(prix) * (1 + taux), 2)

Les formes utiles tiennent en quelques lignes :

noms: list[str]                 # une liste de chaînes
stock: dict[str, int]           # référence -> quantité
point: tuple[float, float]      # exactement deux flottants
client: Client | None           # un client, ou rien

Le | sert à dire « l'un ou l'autre ». Client | None est la façon moderne d'annoter une valeur éventuellement absente.

Ce que le typage apporte : un vérificateur de types lit votre code sans l'exécuter et signale les incohérences — un None jamais testé, un argument oublié, un retour mal utilisé. Votre éditeur s'appuie sur les mêmes informations pour l'autocomplétion.

Ce qu'il ne garantit pas : rien à l'exécution.

def prix(montant: int) -> int:
    return montant

prix("bonjour")     # s'exécute sans broncher, et renvoie "bonjour"

Une annotation est une affirmation vérifiable par un outil, pas une barrière. Un code annoté mais jamais passé au vérificateur n'a gagné que de la documentation — utile, mais sans garantie.

Deux conséquences pratiques. Les données venues de l'extérieur — un JSON, un formulaire, une ligne de CSV — se valident toujours à l'exécution : annoter un paramètre ne contrôle rien à la frontière. Et commencez par annoter les signatures publiques, celles que d'autres modules appellent : c'est là que le vérificateur a le plus à dire pour le moins d'effort.

Les termes à connaître

Annotation de type

Indication écrite dans le code (prix: float) qui dit quel type une variable, un paramètre ou un retour est censé avoir. Python l'enregistre mais ne la vérifie pas à l'exécution.

Vérificateur de types

Outil externe qui lit les annotations et signale les incohérences avant l'exécution, sans lancer le programme. C'est lui, et lui seul, qui donne sa valeur au typage.

Génériques natifs

list[str], dict[str, int], tuple[int, ...] : la forme moderne, directement sur les types intégrés. Les anciens équivalents List, Dict du module typing n'ont plus de raison d'être dans du code récent.

Type union (`|`)

int | str signifie « l'un ou l'autre ». str | None décrit une valeur éventuellement absente — ce que l'on écrivait avant Optional[str], qui en est l'exact synonyme.

Any

Le type qui accepte tout et se laisse utiliser n'importe comment. Il désactive la vérification là où il apparaît, et se propage en silence aux valeurs qui en dérivent. À réserver aux frontières réellement dynamiques.

__annotations__

Dictionnaire où une fonction ou une classe conserve ses annotations. C'est la preuve que Python les enregistre sans jamais s'en servir pour contrôler quoi que ce soit.

Protocol

Du module typing : décrit un type par les méthodes qu'il possède plutôt que par son héritage. C'est la mise en forme typée du duck typing — « tout objet qui a une méthode total() convient ».

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.