0Pricing
Python Academy · Leçon

Exécuter mypy et corriger les erreurs de types

Configurez mypy, interprétez les erreurs et ajoutez progressivement le typage à une base de code.

Exécuter mypy et corriger les erreurs de types est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Installer et exécuter mypy

Installez mypy avec pip et exécutez-le sur un fichier ou un paquet. Il signale les erreurs de type sans exécuter votre code.

# pip install mypy

# Check a single file:
# mypy script.py

# Check a package:
# mypy mypackage/

# Strict mode (recommended for new code):
# mypy --strict script.py

Votre première erreur mypy

mypy détecte les types incompatibles, les valeurs de retour manquantes et les arguments de fonction non annotés.

# script.py
def add(a, b):   # mypy: Missing type annotation
    return a + b

result: int = add("hello", 1)  # str, not int

# mypy output:
# error: Returning Any from function declared to return "int"

Option --strict

--strict active de nombreuses vérifications supplémentaires : annotations manquantes, utilisation de Any, importations non typées, etc. Commencez sans cette option, puis ajoutez progressivement ces vérifications.

# Most important strict flags individually:
# --disallow-untyped-defs
# --disallow-any-generics
# --warn-return-any
# --no-implicit-reexport

# Or all at once:
# mypy --strict mypackage/

Ignorer les erreurs

Ajoutez # type: ignore à la fin d'une ligne pour supprimer une erreur précise. Utilisez cette possibilité avec parcimonie et ajoutez un commentaire expliquant pourquoi.

import third_party  # type: ignore[import]  # no stub available

x: int = get_dynamic_value()  # type: ignore[assignment]

Configuration de mypy.ini / pyproject.toml

Stockez les paramètres de mypy dans mypy.ini ou pyproject.toml afin de ne pas avoir à transmettre les options à chaque exécution.

# mypy.ini
[mypy]
python_version = 3.11
strict = True
ignore_missing_imports = True

[mypy-third_party.*]
ignore_errors = True

Mode incrémental

mypy met en cache les résultats entre les exécutions. Seuls les fichiers modifiés sont vérifiés à nouveau, ce qui accélère les exécutions suivantes.

# First run:
# mypy mypackage/   — full analysis, ~5 s

# Second run (nothing changed):
# mypy mypackage/   — Success: no issues in 0 source files (0.3 s)

Erreur courante : types incompatibles

L'erreur la plus fréquente : affecter ou transmettre une valeur du mauvais type.

# error: Incompatible types in assignment
# (expression has type "str", variable has type "int")

count: int = 0
count = "five"   # error

# Fix:
count = 5

Erreur courante : types d'arguments incompatibles

Transmettre à une fonction des arguments dont le type est incorrect.

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

# error: Argument 1 to "greet" has incompatible type "int"
greet(42)   # error

# Fix:
greet(str(42))

Erreur courante : None renvoyé de manière inattendue

Une fonction déclarée comme renvoyant une valeur autre que None possède un chemin d'exécution qui renvoie None.

# error: Missing return statement
def find(items: list[int], target: int) -> int:
    for item in items:
        if item == target:
            return item
    # Missing: no return if not found!

# Fix:
def find2(items: list[int], target: int) -> int | None:
    for item in items:
        if item == target:
            return item
    return None

Affinement avec isinstance

Utilisez isinstance pour affiner un type Union dans une branche. mypy le comprend et affine le type.

def process(value: int | str) -> str:
    if isinstance(value, int):
        return str(value * 2)   # mypy knows value is int here
    return value.upper()         # mypy knows value is str here

Utiliser cast

typing.cast(Type, value) indique à mypy de traiter une valeur comme étant d'un type donné, sans effet à l'exécution. Utilisez-le uniquement lorsque vous êtes certain d'avoir raison contre mypy.

from typing import cast

def get_value() -> object:
    return 42

result = cast(int, get_value())   # mypy treats result as int
print(result + 1)   # 43

Vérification rapide

Que fait l'ajout de # type: ignore à une ligne ?

Récapitulatif

Exécutez mypy script.py pour vérifier les types. Corrigez les affectations incompatibles, les incompatibilités d'arguments et les retours manquants. Utilisez isinstance pour affiner les unions, # type: ignore avec parcimonie, et configurez mypy dans mypy.ini. Activez progressivement --strict.

Questions Fréquemment Posées

La leçon « Exécuter mypy et corriger les erreurs de types » est-elle gratuite ?

Oui — le texte complet de « Exécuter mypy et corriger les erreurs de types » 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 « Exécuter mypy et corriger les erreurs de types » ?

Configurez mypy, interprétez les erreurs et ajoutez progressivement le typage à une base de code. 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 4 sur 4.

Combien de temps prend la leçon « Exécuter mypy et corriger les erreurs de types » ?

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