Formation Python | Typage (Type Hinting)

Python, un langage dynamique

Typage dynamique et explicite

Python est un langage dynamique, ce qui signifie que vous n’avez pas besoin de spécifier les types des variables.

Ceux ci sont définis automatiquement en fonction de la valeur affectée et peuvent changer au fur et à mesure de l’exécution du programme, comme l’illustre cet exemple simple :

x = 10
x = "texte"

Cependant, au fur et à mesure que les projets grandissent, il devient crucial de mieux organiser et documenter le code pour éviter des erreurs difficiles à détecter.

C’est là qu’intervient le typage, une fonctionnalité qui permet d’ajouter des annotations au code pour en améliorer la lisibilité et faciliter la détection des erreurs.

Vers un typage statique avec les type hints

Depuis la version 3.5 (PEP 484 puis PEP 526) de Python, il est possible d’ajouter des annotations de type aux fonctions et variables, permettant ainsi d’apporter plus de structure au code.

Les annotations ne sont pas utilisées par l’interpréteur Python en tant que tel, mais elles servent d’indication pour les développeurs et d’outil d’analyse statique via des outils comme mypy.

Utilisation des annotations de type

Vous trouverez ci-dessous quelques exemples d’annotations de type pour les structures de données courantes en Python.

Variables

Le typage des variables est simple et se fait à l’aide d’une annotation juste après la variable.

x: int = 10
y: str = "texte"

Bien que Python permette de changer le type de la variable durant l’exécution, ces annotations aident à mieux comprendre l’intention du développeur et rester cohérent dans le code.

Fonctions

Les annotations pour les fonctions permettent de spécifier les types des paramètres et du retour. Voici un exemple simple de fonction annotée :

def addition(a: int, b: int) -> int:
	return a + b

• Les annotations a: int et b: int indiquent que les paramètres doivent être des entiers.
• L’annotation -> int indique que la fonction renverra un entier.

Cela aide non seulement à clarifier la fonction, mais aussi à éviter des erreurs de types lors de l’appel.

Listes et dictionnaires

Les annotations peuvent aussi être appliquées aux listes et dictionnaires (depuis Python 3.9).

On peut ainsi spécifier que les éléments d’une liste sont d’un type donné :

liste: list[int] = [1, 2, 3]

Ici, on précise que liste est une liste d’entiers.

De même, pour les dictionnaires, on peut annoter les types des clés et des valeurs :

dictionnaire: dict[str, int] = {"a": 1, "b": 2}

Dans cet exemple, les clés sont des chaînes (str) et les valeurs des entiers (int).

Annotations de type avancées

Certaines annotations sont plus complexes et nécessitent l’import de modules supplémentaires comme typing.

C’est par exemple le cas pour les tuples et les unions (un type qui peut être l’un ou l’autre) de types.

from typing import Union
valeur: Union[int, float] = 10

Cet exemple permet à valeur d’être soit un entier soit un flottant.

Utilisation de vérificateur de types

Pour exploiter au mieux le typage, vous pouvez utiliser un outil comme mypy, qui permet d’analyser le code et de vérifier que les annotations sont cohérentes.

Installation de mypy

Commencez par installer mypy dans votre environnement virtuel :

pip install mypy

Utilisation de mypy

Ensuite, vous pouvez utiliser mypy pour vérifier votre script Python.

Par exemple, si vous avez un fichier main.py, il vous suffit de lancer la commande suivante dans le terminal :

mypy main.py

Cela analysera le fichier et signalera les erreurs de type potentielles.