Introduction

MyPy¹ est un vérificateur de type statique pour Python. Contrairement aux langages typés statiquement comme C ou Java, Python est typé dynamiquement. Cela signifie qu'en Python, vous n'avez pas besoin de déclarer explicitement le type d'une variable ; il est déduit au moment de l'exécution. Par exemple:

Python (typé dynamiquement)

num = 4                # `num` is inferred as an integer
newString = "new string"  # `newString` is inferred as a string

En revanche, les langages à typage statique nécessitent que vous spécifiiez le type de chaque variable au moment de la compilation. Cela permet de détecter les erreurs liées au type pendant le développement plutôt qu'au moment de l'exécution.

C (typé statiquement)

int num = 4;            // `num` is declared as an integer
std::string newString = "new string";  // `newString` is declared as a string

Pourquoi utiliser MyPy ?

Dans les langages typés dynamiquement comme Python, des erreurs de type peuvent se produire lors de l'exécution, ce qui peut conduire à des bogues plus difficiles à retracer. MyPy résout ce problème en vous permettant d'ajouter des indices de type à votre code Python, qui peuvent être vérifiés de manière statique avant l'exécution. Cela offre plusieurs avantages :

• Détection précoce des erreurs : identifiez les erreurs liées au type pendant le développement plutôt que de les rencontrer au moment de l'exécution.
• Lisibilité améliorée du code : les indications de type clarifient les types attendus de variables et d'arguments de fonction, améliorant ainsi la lisibilité du code.
• Meilleure prise en charge de l'IDE : fournit une complétion de code améliorée et une documentation en ligne dans les IDE qui prennent en charge les astuces de type.

Exemple avec MyPy

Voici un exemple simple illustrant l'utilisation des indices de type avec MyPy :

Sans indices de type

def add(a, b):
    return a   b

print(add(5, 3))      # Output: 8
print(add("hello", "world"))  # Output: helloworld

Dans le code ci-dessus, la fonction add peut accepter à la fois des entiers et des chaînes, ce qui peut ne pas être le comportement prévu.

Avec des indices de type

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

print(add(5, 3))      # Output: 8
# mypy will report an error for the following line:
# print(add("hello", "world"))  # TypeError: Expected int, got str

En incluant des indications de type (a: int, b: int), vous spécifiez que add doit fonctionner uniquement avec des entiers. MyPy vérifie le code par rapport à ces indices de type, détectant ainsi les problèmes potentiels liés au type.

Installer et exécuter MyPy

Pour démarrer avec MyPy :

1. Installation : installez MyPy à l'aide de pip :

   python3 -m pip install mypy

1. Exécuter MyPy : une fois installé, vous pouvez exécuter MyPy pour vérifier votre code pour les erreurs de type. Utilisez la commande suivante :

   mypy program.py

Cette commande vérifiera votre code de manière statique, de la même manière qu'un compilateur vérifie la syntaxe en C . Il signalera toutes les erreurs de type trouvées sans exécuter le code.

L'utilisation efficace de MyPy vous permet d'intégrer les avantages du typage statique dans Python, tout en bénéficiant de la flexibilité de sa nature dynamique.

Codons un exemple avec MyPy

Sans MyPy

def greeting(name):
    return 'Hello '   name

# These calls will fail when the program runs, but MyPy will not report an error
greeting(123)
greeting(b"Aniket")

Avec MyPy

En ajoutant des annotations de type (également appelées astuces de type), MyPy peut détecter des problèmes potentiels :

def greeting(name: str) -> str:
    return 'Hello '   name

greeting(3)         # mypy will report: Argument 1 to "greeting" has incompatible type "int"; expected "str"
greeting(b'Alice')  # mypy will report: Argument 1 to "greeting" has incompatible type "bytes"; expected "str"
greeting("World!")  # No error

Ici:

• name: l'annotation str spécifie que l'argument name doit être une chaîne.
• -> L'annotation str spécifie que la fonction de message d'accueil renverra une chaîne.

Quand utiliser MyPy

MyPy est utile dans plusieurs situations :

• Détecter les erreurs tôt : utilisez MyPy pour rechercher les erreurs liées au type avant d'exécuter votre code. Cela permet de détecter les erreurs plus tôt et d'améliorer la fiabilité du code.

• Rendre le code plus clair : l'ajout d'indices de type rend votre code plus facile à comprendre. Il montre quels types de valeurs sont attendus, ce qui aide les autres (et votre futur moi) à mieux comprendre votre code.

• Mettre à niveau l'ancien code : lors de la mise à jour de l'ancien code, MyPy vous aide à détecter les problèmes de type à mesure que vous ajoutez des indices de type, ce qui rend la transition plus fluide.

• Améliorer les prototypes : lors de la création de nouvelles fonctionnalités ou de nouveaux prototypes, MyPy permet de garantir que le nouveau code fonctionne correctement avec le code existant en appliquant des règles de type.

• Maintenir les grands projets : dans les grands projets avec de nombreux contributeurs, MyPy aide à maintenir la cohérence du code et évite les bogues liés au type.

• Boostez les fonctionnalités de l'IDE : si vous utilisez un IDE, MyPy améliore les fonctionnalités telles que la complétion de code et la navigation, facilitant ainsi le développement.

L'utilisation de MyPy vous aide à écrire du code Python meilleur et plus fiable tout en profitant de la flexibilité de Python.

Une aide-mémoire rapide officielle pour mypy

1. Documentation officielle ↩