Réponse

Historique de la question : Les type hints sont apparus dans Python 3.5 (PEP 484) pour soutenir l'analyse statique du code, l'autocomplétion, le refactoring et l'auto-documentation. Auparavant, Python se débrouillait sans typage strict, mais avec la croissance des projets et des équipes, ils sont devenus nécessaires pour améliorer la qualité du code.

Problème : Les annotations de type ne sont que des indices pour les développeurs et les outils externes (mypy, Pyright, etc.), l'interpréteur lui-même les ignore pendant l'exécution. Les erreurs surviennent souvent si :

• Les annotations sont incorrectes ou ne correspondent pas aux types réels
• Les annotations échouent lors de la modification dynamique des types
• Erreurs avec des structures complexes utilisant des Generics (par exemple, List[Dict[str, int]])

Solution : Utilisez des annotations de type pour les fonctions et les variables pour la lisibilité, l'analyse par les linters et les IDE. Ne comptez pas uniquement sur les annotations - un vérificateur de type statique est nécessaire. Exemple :

def greeting(name: str) -> str:
    return f"Bonjour, {name}"

def sum_nums(nums: list[int]) -> int:
    return sum(nums)

Des exemples plus complexes utilisent le module typing :

from typing import List, Dict, Optional

def process(data: List[Dict[str, Optional[int]]]) -> None:
    ...

Caractéristiques clés :

• Les annotations n'influent pas sur le comportement du code à l'exécution
• Toujours combiner les type hints avec un analyseur externe
• Pour des structures complexes, utilisez typing.

Questions pièges.

L'interpréteur Python traite-t-il les types issus des annotations à l'exécution ?

Non. Les annotations sont accessibles via __annotations__, mais ne contrôlent pas le comportement à l'exécution.

Peut-on utiliser des variables sans annotations dans des fonctions annotées ?

Oui. Les annotations ne sont pas obligatoires, mais leur absence peut prêter à confusion.

Peut-on redéfinir le type d'une variable après l'annotation ?

Oui, mais cela va à l'encontre de l'analyse statique et dérange les linters. Il vaut mieux éviter cela :

x: int = 5
x = 'chaîne'  # Le linter se plaignera, mais le code s'exécutera.

Erreurs typiques et anti-patterns

• Non-conformité du type mis en œuvre avec la valeur d'annotation
• Non-utilisation d'un analyseur externe (linters, mypy)
• Type hints trop complexes ou excessifs, rendant la lecture difficile

Exemple de la vie réelle

Cas négatif : On annote une fonction, mais le type réellement retourné diffère de celui de l'annotation, à cause d'un changement de logique de la fonction. Avantages :

• Le code s'exécute Inconvénients :
• Risque de bugs difficiles à tester et à attraper

Cas positif : Toutes les fonctions et données sont annotées, le projet est vérifié par mypy lors du CI/CD. Avantages :

• Haute maintenabilité et lisibilité du code Inconvénients :
• Nécessite du temps pour la mise en œuvre et la formation de l'équipe