Lorsque l'on apprend à coder en Python, la question du typage est une question que l'on ne considère que très rarement alors que celle-ci est incontournable avec un langage comme Java. D'où vient donc cet "oubli" de la part d'un des langages de programmation les plus utilisés de la dernière décennie ?
Pour répondre à cette question, il est important de creuser quelques notions de base. Le développement de logiciels nécessite une compréhension claire du typage des données et de la façon dont elles sont utilisées dans différents contextes. Le typage en programmation définit la nature des valeurs que peuvent prendre les données que nous manipulons. Pour tester le type d’une variable en Python, on fait appel à la fonction type() qui retourne, sans surprise, le type de l’objet entré en paramètre de la fonction.
La fonction s’utilise comme suit :
>> <class ‘int’>
Dans l’exemple ci-dessus, on teste une variable numérique entière, le type correspondant est int. En Python, il existe une multitude de types dits natifs, vous trouverez la liste exhaustive sur le site de la documentation officielle. Python, étant un langage dynamiquement typé, est assez flexible dans la gestion des types de données, mais cette flexibilité peut parfois entraîner des confusions et des erreurs. C’est là que les annotations de type entrent en jeu, ajoutant une couche supplémentaire de clarté et de vérification de type au code Python.Typage en programmation
Il existe principalement deux types de typage en programmation : le typage statique et le typage dynamique.
1. Typage statique
Dans un langage à typage statique, chaque variable doit être assignée à un type précisé par le programmeur. Des langages tels que Java, C et C++ adoptent cette approche. Prenons l’exemple de Java pour la définition d’une variable numérique, la syntaxe est la suivante :
int a = 2;
float b = 3.;
String c = ‘Hello World’;
Pas besoin d’avoir une maîtrise de Java pour comprendre cette syntaxe. Chaque variable a, b ou c est introduite par le type de celle-ci et est suivie par la valeur attribuée. L’aspect statique du typage apparaît nettement et pour le vérifier, il suffit simplement de voir ce qu’il se passerait si l’on essayait d’assigner une nouvelle valeur à une des variables. Vous pouvez tentez par vous même sur ce compiler en ligne.
Un avantage important de cette approche est la rigueur qu’elle impose dans la définition des variables : il n’y a pas de doute sur la nature des variables, et il devient plus facile pour le compilateur de repérer les erreurs liées au type. De plus, la vérification des types est généralement effectuée lors de la compilation, ce qui permet une exécution plus rapide.
2. Typage dynamique
À l’inverse, Python opte pour un typage dynamique. Cela signifie que le typage est réalisé et vérifié après l’exécution du code, et non avant. Ainsi, lorsqu’on définit une variable en Python, on n’est pas obligé de préciser son type, il est déduit par l’interpréteur. De plus, une fois une variable définie, on peut lui assigner une nouvelle valeur, quel que soit son type, sans provoquer d’erreur.
Exemple :
En conclusion, quel typage choisir ? À cette question, il n’y a pas de réponse fixe: c’est défini par le cadre de programmation. Si la mission exige une rigueur et une transparence absolue dans le code, alors on optera pour un typage statique. Si le programmeur se voit laisser la main libre sur le code alors privilégier la flexibilité et la rapidité d’écriture d’un typage dynamique peut s’avérer être la solution intéressante.
Mais alors, si l’on veut un typage statique, faut-il nécessairement éviter Python ?
Annotations de type en Python
Pour simuler un typage statique, Python propose un système d’annotations de type. Les annotations de type permettent au programmeur de préciser le type des arguments d’une fonction et le type de sa valeur de retour. Par exemple :
- La première annotation correspond au type de la variable souhaitée en argument, a : str. Ici, on indique que l’argument a entré par l’utilisateur de notre fonction doit être de type str.
- La deuxième annotation indique le type de la valeur en sortie de notre fonction, -> None. Ici, on indique que la fonction ne retourne rien, ce qui est cohérent avec son objectif d’afficher uniquement un résultat.
Il est important de noter que ces annotations sont des indications, et non des contraintes strictes. Python n’empêche pas l’exécution du code si les types réels ne correspondent pas aux types annotés. Cependant, ces annotations peuvent être très utiles pour comprendre l’intention du programmeur et pour détecter les erreurs potentielles de typage.
MyPy : un vérificateur de types pour Python
Bien que les annotations de type soient utiles, elles ne fournissent pas de vérification de type réelle en Python. Pour combler ce manque, on peut utiliser des outils tiers comme MyPy.
MyPy est une bibliothèque Python qui permet de vérifier le typage statique d’un code Python et qui aide à trouver des bugs avant l’exécution de votre programme. Elle travaille de pair avec les annotations de type et s’assure qu’elles sont bien respectées. MyPy ne rend pas le code invalide si le typage n’est pas respecté, mais il fournit un rapport détaillé des erreurs de typage rencontrées. Cela permet au développeur de corriger ces erreurs avant qu’elles ne provoquent des problèmes dans l’exécution du code.
La façon la plus courante de l’utiliser est de l’employer comme un débugger selon le schéma suivant :
- Rédiger son code Python et l’enregistrer comme un fichier .py.
- Sur un terminal, entrer la commande suivante : mypy mon_fichier.py
Si des erreurs sont détectées elles seront renvoyées par MyPy précisant le type de l’erreur, sa position dans le code ainsi que la cause de l’erreur.
En conclusion, bien que Python soit un langage à typage dynamique, l’utilisation d’annotations de type et de vérificateurs de type comme MyPy peut grandement améliorer la clarté et la robustesse du code Python. Ces outils peuvent être particulièrement utiles dans les grands projets de développement de logiciels, où une compréhension claire du typage des données est essentielle pour maintenir un code de haute qualité.
