Annotations de type — Laisse ton intention dans le code avec : int et -> str

Cet article couvre les annotations de type — un outil pour laisser l'intention « ce qui va ici » dans le code. Introduites en Python 3.5, elles sont devenues plus expressives à chaque version.

Le problème du « c'est quoi le type ? » dans un langage dynamique

Python est un langage typé dynamiquement. Écris value = 10 et c'est int ; écris value = "HELLO" et le même nom est maintenant str. La même variable peut basculer de type à tout moment — c'est de la flexibilité. L'inconvénient est que quand ton code grandit ou qu'une équipe commence à y toucher, « qu'est-ce que cette variable contient ? » / « qu'est-ce que cette fonction retourne ? » devient impossible à répondre depuis le code seul.

Les annotations de type laissent cette information sous forme d'annotations. Elles ne changent pas le comportement à l'exécution. Ce qu'elles font, c'est donner aux lecteurs humains un indice fort et permettre aux IDE et analyseurs statiques d'attraper les erreurs de type à l'avance.

Annoter les signatures de fonction

Les signatures de fonction sont la scène principale pour les annotations de type. Annote les arguments comme name: type (deux-points puis type après le nom) et le type de retour comme -> type (flèche puis type à la fin de la ligne def).

# ❌ pas d'annotations — la signature ne te dit pas ce qu'il faut passer
def calc_tax(price, rate):
    return int(price * (1 + rate))


# ✅ avec annotations — « int en entrée, int en sortie » est évident
def calc_tax(price: int, rate: float) -> int:
    return int(price * (1 + rate))


print(calc_tax(price=1000, rate=0.1))   # 1100

Ajoute des annotations de type pour les arguments et le retour à calc_tax, le calculateur de taxe style e-commerce.

① Sur def calc_tax(price, rate):, ajoute les annotations price: int et rate: float.

② Ajoute -> int avant le : pour déclarer le type de retour.

③ Garde le corps comme return int(price * (1 + rate)).

④ Vérifie avec print(calc_tax(price=1000, rate=0.1)) (attendu 1100).

(Une fois que ça tourne correctement, l'explication apparaîtra.)

Annotations de variables — Quand les écrire et quand non

Les annotations de type marchent aussi sur les variables — même forme : name: type = value. Mais les annotations de variables deviennent vite bruyantes si tu en abuses, et le bruit réduit la lisibilité.

# ❌ bruyant — la valeur te dit déjà le type
name: str = "Alice"
age:  int = 30

# ✅ vaut la peine d'annoter — conteneur vide, init différée, ou type pas clair
results: list = []                       # liste vide, on ajoutera plus tard
cache:   dict = {}                       # on voudra peut-être détailler le type de valeur plus tard
user_id: int  = fetch_id_from_session()  # rend explicite le type attendu au site d'appel

En cas de doute : « toujours pour les fonctions, parcimonieusement pour les variables »

Dans les vrais projets, annote toujours les signatures de fonction et de méthode, mais annote les variables seulement quand le type n'est pas évident. age = 30 n'a pas besoin de : int — l'ajouter est juste du bruit.

Les annotations de type ne sont pas appliquées à l'exécution

Les annotations de type sont juste des indications. Python ne les vérifie ni ne les applique à l'exécution. Une fonction déclarée def f(x: int) accepte joyeusement f("abc") — la fonction tourne comme d'habitude. Seulement plus tard, quand un calcul profond dans le corps échoue sur la non-correspondance de type, tu vois un TypeError ou similaire — et c'est une erreur à l'exécution du calcul, pas de l'annotation elle-même.

Alors pourquoi s'embêter ? Parce qu'avant que la fonction ne tourne, les éditeurs et analyseurs statiques peuvent détecter les non-correspondances de type. Pylance de VS Code, PyCharm, mypy, pyright — tous lisent tes annotations et soulignent les erreurs en rouge, attrapant les bugs avant l'exécution.

Les runners Python en navigateur ne montrent pas les avertissements IDE

La console sur cette page exécute seulement ton code — elle n'a pas de facilité de vérification de type statique comme VS Code. Donc écrire ou violer des annotations de type ne produit jamais de soulignements rouges ou d'avertissements pré-exécution ici. Le vrai bénéfice des annotations de type — le filet de sécurité des avertissements d'éditeur avant exécution — n'apparaît que localement avec VS Code, PyCharm, etc.

Ajoute des annotations de type à la fois à une classe User et à une fonction describe_user qui la consomme.

① Définis class User: avec __init__(self, name: str, age: int) affectant self.name = name et self.age = age (annote aussi les arguments du constructeur).

② Ajoute une méthode d'instance greet(self) -> str retournant f"Hello, {self.name}" (n'oublie pas l'annotation de retour).

③ Hors de la classe, définis describe_user(user: User) -> str qui prend une instance User et retourne f"{user.name} ({user.age})".

④ Crée user = User("Alice", 30) et vérifie avec print(user.greet()) et print(describe_user(user)).

Trois endroits où les annotations de type paient