0Pricing
Python Academy · Leçon

Annotations de types de base

Annotez les variables, les paramètres de fonction et les types de retour.

Annotations de types de base est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Que sont les annotations de type ?

Les annotations de type sont des indications qui déclarent le type attendu des variables, des paramètres et des valeurs de retour. Elles ne sont pas appliquées à l'exécution : elles sont lues par des vérificateurs de types comme mypy.

def greet(name: str) -> str:
    return f"Hello, {name}"

result: str = greet("Alice")
print(result)

Annotations de variables

Annotez les variables au niveau du module, de la classe ou dans une fonction avec deux-points suivis du type.

count: int = 0
pi: float = 3.14159
name: str = "Python"
flag: bool = True

# Annotation without assignment (declaration only)
future_value: int

Annotations des paramètres de fonction

Annotez chaque paramètre dans la signature de la fonction. Utilisez -> type pour annoter le type de retour.

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

def repeat(text: str, times: int = 1) -> str:
    return text * times

def no_return() -> None:
    print("side effect only")

Types de collections intégrés (Python 3.9+)

Depuis Python 3.9, utilisez directement les types intégrés en minuscules comme types génériques : list[int], dict[str, int] et tuple[int, ...].

def total(numbers: list[int]) -> int:
    return sum(numbers)

def config() -> dict[str, str]:
    return {"host": "localhost", "port": "8080"}

def coords() -> tuple[float, float]:
    return (1.0, 2.0)

Optional et Union

X | None (Python 3.10+) ou Optional[X] signifie qu'une valeur peut être X ou None. X | Y signifie qu'elle peut être X ou Y.

from typing import Optional

def find(items: list[int], target: int) -> int | None:
    return next((x for x in items if x == target), None)

# Older style:
# def find(...) -> Optional[int]:

Types Union

int | str (Python 3.10+) ou Union[int, str] annote une valeur qui peut être de plusieurs types.

from typing import Union

def process(value: int | str) -> str:
    return str(value)

# Older style:
# def process(value: Union[int, str]) -> str:

Alias de types

Affectez une expression de type à un nom pour créer un alias réutilisable et améliorer la lisibilité.

from typing import TypeAlias

Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[Vector]

def dot(a: Vector, b: Vector) -> float:
    return sum(x * y for x, y in zip(a, b))

Annotations Callable

Utilisez Callable[[arg_types], return_type] pour annoter les fonctions transmises comme arguments.

from typing import Callable

def apply(func: Callable[[int, int], int], x: int, y: int) -> int:
    return func(x, y)

result = apply(lambda a, b: a + b, 3, 4)
print(result)  # 7

Annoter *args et **kwargs

Annotez *args avec le type des éléments, et non celui d'un tuple, et **kwargs avec le type des valeurs.

def log(*messages: str, level: str = "INFO") -> None:
    for msg in messages:
        print(f"[{level}] {msg}")

def configure(**options: int) -> None:
    for key, val in options.items():
        print(f"{key}: {val}")

from __future__ import annotations

Ajoutez cette importation en haut du fichier pour activer l'évaluation différée des annotations et permettre les références anticipées sans guillemets.

from __future__ import annotations

class Node:
    def __init__(self, value: int, next: Node | None = None):
        self.value = value
        self.next = next   # forward ref to Node works here

Garde TYPE_CHECKING

Importez les types uniquement lors de la vérification des types, et non à l'exécution, afin d'éviter les importations circulaires ou lourdes.

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from mymodule import HeavyClass

def process(obj: HeavyClass) -> None:
    ...   # HeavyClass not imported at runtime

Vérification rapide

Quelle syntaxe d'annotation indique qu'une fonction ne renvoie aucune valeur ?

Récapitulatif

Annotez les variables avec name: Type, les paramètres avec param: Type et les valeurs de retour avec -> Type. Utilisez list[T], dict[K,V] (Python 3.9+), X | None (3.10+) et from __future__ import annotations pour les références anticipées.

Questions Fréquemment Posées

La leçon « Annotations de types de base » est-elle gratuite ?

Oui — le texte complet de « Annotations de types de base » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Annotations de types de base » ?

Annotez les variables, les paramètres de fonction et les types de retour. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Annotations de types de base » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Annotations de types de base
  2. Types complexes : List, Dict, Optional, Union
  3. TypeVar, classes génériques et Protocol
  4. Exécuter mypy et corriger les erreurs de types
← Retour à Python Academy