Le typage en Python

# Typage de variables simples
age: int = 25
nom: str = "Patrick"
est_admin: bool = False

# Typage d'une fonction
def saluer(nom: str) -> str:
    return f"Bonjour {nom}"

from typing import List, Dict

scores: List[int] = [10, 20, 30]
utilisateurs: Dict[str, int] = {"Patrick": 1, "Sebastien": 2}

scores: list[int] = [10, 20, 30]
utilisateurs: dict[str, int] = {"Patrick": 1, "Sebastien": 2}

from typing import Union, Optional

def traiter_id(id_user: Union[str, int]) -> None:
    print(f"ID traité : {id_user}")

def chercher_nom(id_user: int) -> Optional[str]:
    if id_user == 1:
        return "Patrick"
    return None

def traiter_id(id_user: str | int) -> None:
    print(f"ID traité : {id_user}")

def chercher_nom(id_user: int) -> str | None:
    if id_user == 1:
        return "Patrick"
    return None

from typing import Callable

# On définit notre alias : toute fonction valide devra prendre (int, float) et renvoyer un bool
ActionType = Callable[[int, float], bool]

# 1. On crée une vraie fonction
def verifier_seuil(score: int, multiplicateur: float) -> bool:
    return (score * multiplicateur) > 50.0

# 2. Notre fonction principale exige une fonction respectant la signature ActionType
def executer_action(action: ActionType, utilisateur: str) -> None:
    resultat = action(10, 2.5)
    if resultat:
        print(f"L'action de {utilisateur} a réussi !")

# 3. On appelle executer_action en lui passant notre fonction (sans les parenthèses)
executer_action(verifier_seuil, "Patrick")

from typing import Literal

# On définit un type qui n'accepte que ces trois chaînes de caractères exactes
Role = Literal["admin", "editeur"]

def assigner_role(nom: str, role: Role) -> None:
    print(f"Le rôle {role} a été assigné à {nom}.")

# Ceci est tout à fait valide :
assigner_role("Sebastien", "admin")

# "dictateur bienveillant" n'est pas autorisé par notre Literal :
# assigner_role("Patrick", "dictateur bienveillant")

from typing import TypedDict

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


user_valide: Utilisateur = {
    "nom": "Sebastien", 
    "age": 30, 
    "actif": True
}

# Erreur pour ce dictionnaire car :
# 1. Il manque la clé "actif"
# 2. Le type de l'âge est mauvais (str au lieu de int)
user_invalide: Utilisateur = {"nom": "Patrick", "age": "trente"}

from typing import Self

class RequeteAPI:
    def __init__(self) -> None:
        self.url = ""
        self.headers: dict[str, str] = {}

    def set_url(self, url: str) -> Self:
        self.url = url
        return self

    def ajouter_header(self, cle: str, valeur: str) -> Self:
        self.headers[cle] = valeur
        return self

    def envoyer(self) -> None:
        print(f"Envoi de la requête à {self.url} avec les headers : {self.headers}")

# L'auto-complétion de votre éditeur fonctionne après chaque point !
requete = (
    RequeteAPI()
    .set_url("https://api.monsite.com/utilisateurs/patrick")
    .ajouter_header("Authorization", "Bearer jeton123")
    .ajouter_header("Accept", "application/json")
)

requete.envoyer()

from typing import overload

# 1. Promesse n°1 pour l'analyseur : si on donne un entier, on récupère un entier.
@overload
def doubler(valeur: int) -> int: ...

# 2. Promesse n°2 pour l'analyseur : si on donne une chaîne, on récupère une chaîne.
@overload
def doubler(valeur: str) -> str: ...

# 3. La VÉRITABLE fonction, celle qui sera exécutée par Python.
# Sa signature englobe tous les cas possibles, et elle contient le code réel.
def doubler(valeur: int | str) -> int | str:
    return valeur * 2 if isinstance(valeur, int) else valeur + valeur

# Grâce aux promesses @overload au-dessus, votre éditeur de code 
# sait désormais avec 100% de certitude que resultat_1 est un entier.
resultat_1 = doubler(10)

# Et il sait avec 100% de certitude que resultat_2 est une chaîne.
resultat_2 = doubler("Patrick")

Coordonnees = tuple[float, float]
Identifiant = int | str

type Coordonnees = tuple[float, float]
type Identifiant = int | str

from typing import TypeVar

# Python évalue à droite en premier : TypeVar('T') est créé AVANT d'être assigné à T.
# On doit donc lui passer son propre nom en chaîne, pour qu'il puisse l'afficher
# dans les messages d'erreur de Pyright/mypy.
T = TypeVar('T')

def premier_element(liste: list[T]) -> T:
    return liste[0]

# On annonce "Element" entre crochets, puis on l'utilise dans la signature
def premier_element[Element](liste: list[Element]) -> Element:
    return liste[0]


nombres = [10, 20, 30]
# L'analyseur voit qu'on passe list[int]. Il remplace mentalement "Element" par "int", 
# et sait donc que resultat_nombre sera de type "int" !
resultat_nombre = premier_element(nombres) 

mots = ["Patrick", "Sebastien"]
# Ici, il remplace "Element" par "str".
resultat_mot = premier_element(mots)

from typing import TypeGuard

def est_chaine(valeur: object) -> TypeGuard[str]:
    return isinstance(valeur, str)

def traiter(donnee: str | int) -> None:
    if est_chaine(donnee):
        print(donnee.upper())  # ✅ L'analyseur sait que c'est un str
    else:
        # L'analyseur ne sait pas... str ou int ?
        resultat = donnee + 10

from typing import TypeIs

def est_chaine(valeur: object) -> TypeIs[str]:
    return isinstance(valeur, str)

def traiter(donnee: str | int) -> None:
    if est_chaine(donnee):
        # True → l'analyseur sait que c'est un str
        print(donnee.upper())
    else:
        # False → l'analyseur sait que ce n'est PAS un str.
        # Comme le type de départ était "str | int",
        # par déduction logique, ce ne peut être qu'un int.
        resultat = donnee + 10
        print(resultat)

from typing import TypedDict, ReadOnly

class Configuration(TypedDict):
    # Le nom de l'utilisateur ne doit JAMAIS changer en cours de route
    utilisateur: ReadOnly[str]
    # Le mode debug, en revanche, peut être activé ou désactivé
    debug: bool

# On initialise notre configuration avec notre ami Patrick
config: Configuration = {"utilisateur": "Patrick", "debug": True}

# Modifier le mode debug est autorisé :
config["debug"] = False

# MAIS si vous essayez de modifier une clé ReadOnly...
# config["utilisateur"] = "Sebastien"  
# L'analyseur de code (Mypy/Pyright) signalera une erreur de type, car "utilisateur" est en lecture seule.

# Python lit la ligne ci-dessous et voit "User". 
# Il ne sait pas encore ce qu'est un "User" !
def create_user(name: str) -> User:
    return User(name)

# La définition de la classe arrive après dans le fichier
class User:
    def __init__(self, name: str) -> None:
        self.name = name

user = create_user("Patrick")
print(user.name)

"""
Traceback (most recent call last):
  File "/Users/gabrieltrouve/Pro/sandbox/main.py", line 3, in <module>
    def create_user(name: str) -> User:
                                  ^^^^
NameError: name 'User' is not defined
"""

def create_user(name: str) -> User:
    return User(name)


class User:
    def __init__(self, name: str) -> None:
        self.name = name

user = create_user("Patrick")
print(user.name)

class Cercle:
    def dessiner(self):
        print("Je dessine un cercle.")

class BoutonWeb:
    def dessiner(self):
        print("J'affiche un bouton.")

def afficher(element):
    element.dessiner()  # Python s'en fiche de la classe, il cherche juste la méthode

afficher(Cercle())
afficher(BoutonWeb())

from abc import ABC, abstractmethod

class Dessinable(ABC):
    @abstractmethod
    def dessiner(self) -> None:
        ...

# Ta propre classe : tu peux modifier son code, pas de problème
class Cercle(Dessinable):  # ← héritage obligatoire
    def dessiner(self) -> None:
        print("Patrick dessine un cercle.")

# BoutonWeb vient d'une librairie externe (ui_lib)
# Son code source :
#
#   class BoutonWeb:
#       def dessiner(self) -> None:
#           print("Sébastien affiche un bouton.")
#
# Elle a bien une méthode dessiner(), mais elle n'hérite pas de Dessinable.
# L'analyseur statique se plaint, même si le code fonctionne parfaitement à l'exécution.

from ui_lib import BoutonWeb

def afficher_element(element: Dessinable) -> None:
    element.dessiner()

afficher_element(Cercle())     # OK
afficher_element(BoutonWeb())  # Pylance se plaint : BoutonWeb n'est pas un Dessinable

from typing import Protocol
from ui_lib import BoutonWeb  # toujours la même lib externe, rien n'a changé de son côté

# Le contrat : "avoir une méthode dessiner()"
class Dessinable(Protocol):
    def dessiner(self) -> None:
        ...

# Ta propre classe, sans héritage forcé
class Cercle:
    def dessiner(self) -> None:
        print("Patrick dessine un joli cercle.")

# La fonction attend un Dessinable
def afficher_element(element: Dessinable) -> None:
    element.dessiner()

afficher_element(Cercle())     # L'analyseur statique est content
afficher_element(BoutonWeb())  # L'analyseur statique est content aussi et pourtant on n'a rien changé dans ui_lib