Type hints#

avancé

Indicatifs uniquement : non vérifiés à l'exécution par l'interpréteur (utiliser un outil comme mypy ou pyright pour la vérification statique).

Types de base#

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

nom: str = "Ana"
actif: bool = True

Génériques natifs (≥ 3.9)#

noms: list[str] = ["a", "b"]
scores: dict[str, int] = {"ana": 10}
coord: tuple[int, int] = (1, 2)
valeurs: set[float] = {1.0, 2.0}

Union et Optional#

def f(x: int | str) -> None:   # ≥ 3.10 : syntaxe native (remplace Union[int, str])
    ...

def g(x: int | None = None):    # équivalent à Optional[int]
    ...

Alias de type générique (≥ 3.12)#

type Vecteur = list[float]

def normaliser(v: Vecteur) -> Vecteur:
    ...

Fonctions génériques (≥ 3.12)#

def premier[T](elements: list[T]) -> T:
    return elements[0]

class Pile[T]:
    def __init__(self) -> None:
        self._items: list[T] = []

    def empiler(self, item: T) -> None:
        self._items.append(item)

Callable, Any#

from typing import Any, Callable

def appliquer(f: Callable[[int, int], int], a: int, b: int) -> int:
    return f(a, b)

def accepte_tout(x: Any) -> None:
    ...

TypedDict / Protocol avancé#

from typing import TypedDict, Protocol

class Utilisateur(TypedDict):
    nom: str
    age: int

class SupporteAire(Protocol):
    def aire(self) -> float: ...

Vérification statique#

Les annotations ne sont jamais vérifiées à l'exécution : def f(x: int) accepte sans broncher f("abc"). La vérification passe par un outil externe.

Hors bibliothèque standard

pip install mypy
mypy mon_module.py

Le module standard typing fournit les annotations ; le vérificateur (mypy, pyright) est un outil tiers.