Typage statique avec mypy

Introduction aux annotations de type : indiquez le type de vos variables, arguments et valeurs de retour

Python est un langage à typage dynamique, ce qui signifie que le type d'une variable n'est pas vérifié à la compilation, mais à l'exécution. Cela rend Python flexible et facile à utiliser, mais cela peut aussi entraîner des erreurs de type qui ne sont détectées que tardivement.

Depuis Python 3.5, vous pouvez ajouter des annotations de type à votre code. Les annotations de type sont des indications sur le type attendu des variables, des arguments de fonction, et des valeurs de retour de fonction. Elles sont optionnelles, et elles n'affectent pas l'exécution de votre programme (l'interpréteur Python les ignore).

Les annotations de type sont utilisées par des outils externes, comme mypy, pour effectuer une vérification statique des types (c'est-à-dire une vérification des types à la compilation, sans exécuter le code).

Vous ajoutez une annotation de type à une variable en utilisant deux-points (`:`) suivi du type, après le nom de la variable. Par exemple : `nom: str = 'Alice'`. Vous ajoutez une annotation de type à un argument de fonction de la même manière. Vous ajoutez une annotation de type à la valeur de retour d'une fonction en utilisant une flèche (`->`) suivie du type, après la liste des arguments et avant les deux-points. Par exemple : `def saluer(nom: str) -> str: return 'Bonjour ' + nom`.

Python fournit des types de base comme `int`, `float`, `str`, `bool`, mais aussi des types plus complexes comme `List`, `Tuple`, `Dict`, `Set`, `Optional`, `Union`, etc. (vous devez les importer depuis le module `typing`).

Nous verrons comment utiliser les annotations de type, comment annoter différents types de données, et comment utiliser les types du module `typing`.

Utilisation de `mypy` pour vérifier les types : détectez les erreurs avant l'exécution

`mypy` est un vérificateur de types statique pour Python. Il analyse votre code (sans l'exécuter) et vérifie que les types que vous avez annotés sont cohérents. Si `mypy` détecte une erreur de type, il affiche un message d'erreur.

Vous pouvez installer `mypy` avec `pip` : `pip install mypy`. Vous pouvez ensuite exécuter `mypy` sur un fichier Python ou sur un répertoire : `mypy mon_fichier.py` ou `mypy mon_repertoire`.

`mypy` est un outil puissant pour détecter les erreurs de type avant qu'elles ne se produisent à l'exécution. Il peut vous aider à écrire du code plus sûr et plus fiable.

Cependant, `mypy` n'est pas parfait. Il peut parfois signaler des erreurs qui ne sont pas de vraies erreurs (faux positifs), ou ne pas détecter des erreurs réelles (faux négatifs). Il est important de comprendre les limitations de `mypy`, et de l'utiliser en conjonction avec d'autres outils de qualité du code (comme les tests unitaires).

Nous verrons comment utiliser `mypy`, comment interpréter ses messages d'erreur, et comment configurer `mypy` (par exemple, pour ignorer certaines erreurs, ou pour ajuster le niveau de sévérité des erreurs).

Avantages et limites du typage statique en Python : un compromis entre flexibilité et sécurité

Le typage statique offre plusieurs avantages :

• Détection précoce des erreurs : les erreurs de type sont détectées à la compilation, avant que le programme ne soit exécuté. Cela vous permet de corriger les erreurs plus tôt, et d'éviter qu'elles ne se produisent en production.
• Meilleure lisibilité du code : les annotations de type servent de documentation pour votre code. Elles indiquent clairement le type attendu des variables, des arguments et des valeurs de retour.
• Facilite la refactorisation : les outils de refactorisation peuvent utiliser les annotations de type pour effectuer des modifications de code plus sûres et plus précises.
• Amélioration des performances : dans certains cas, les annotations de type peuvent permettre à des outils comme Cython ou Numba d'optimiser votre code.

Cependant, le typage statique a aussi quelques inconvénients :

• Plus de code à écrire : vous devez ajouter des annotations de type à votre code, ce qui peut prendre du temps.
• Moins de flexibilité : le typage statique peut rendre votre code moins flexible, car vous devez spécifier les types à l'avance. Dans certains cas, cela peut rendre votre code plus difficile à écrire ou à modifier.
• Courbe d'apprentissage : il faut apprendre à utiliser les annotations de type et les outils de vérification de types.

Le typage statique en Python est optionnel. Vous pouvez choisir d'utiliser les annotations de type et `mypy` dans certains projets, et pas dans d'autres. Vous pouvez également annoter une partie de votre code, et laisser le reste non annoté.

Nous discuterons des avantages et des limites du typage statique en Python, et nous vous aiderons à décider si et quand l'utiliser.