Débogage avec IDLE : recherchez et corrigez les bogues dans votre code Python

Cet article a été publié dans le cadre du Blogathon sur la science des données

Introduction

Tout le monde fait des erreurs - même les développeurs professionnels chevronnés, et Python et excellent pour les attraper. Voyons voir comment ça fonctionne.

L'identification des erreurs s'appelle le débogage, et un débogueur est un outil qui aide à comprendre la cause de leur apparition. La capacité à trouver et à corriger les erreurs dans le code est une compétence importante dans le travail d'un programmeur, ne la négligez pas.

IDLE (Integrated Development and Learning Environment) est un environnement de développement et d'apprentissage intégré multiplateforme pour Python, créé par Guido van Rossum.

Utiliser la fenêtre de contrôle de débogage

L'interface de débogage principale dans IDLE est la fenêtre Debug Control. Vous pouvez l'ouvrir en sélectionnant l'élément Déboguer → Débogueur dans le menu de la fenêtre interactive.

Remarque : si le débogage n'est pas dans la barre de menus, assurez-vous que la fenêtre interactive a le focus.

Présentation de la fenêtre de contrôle de débogage

Pour voir comment fonctionne le débogueur, écrivons un programme simple sans erreurs.

pour i dans la plage (1, 4) : j = i * 2 print(f"i est {i} et j est {j}")

Enregistrez tout, ouvrez une fenêtre de débogage et appuyez sur F5 - l'exécution n'est pas terminée.

La fenêtre de débogage ressemblera à ceci :

SOURCE

Notez que la barre en haut de la fenêtre contient le message :

> '__main__'.(), ligne 1 : pour i dans range(1, 4) :

Déchiffrons le code pour i dans range(1, 4) : n'a pas encore été lancé, mais '__main__'.module() rapporte qu'en ce moment nous sommes dans la section principale du programme, et non dans la définition du fonction.

Sous le volet de la pile se trouve le volet Locals, qui répertorie les choses étranges : __annotations__, __builtins__, __doc__, etc. sont des variables système internes qui peuvent être ignorées pour le moment. Au fur et à mesure de l'exécution du programme, les variables déclarées dans le code et affichées dans cette fenêtre vous aideront à garder une trace de leurs valeurs.

Dans le coin supérieur gauche de la fenêtre, il y a cinq boutons : Go, Step, Over, Out et Quit - ils contrôlent le mouvement du débogueur à travers le code.

Dans les sections suivantes, vous apprendrez à quoi sert chacun de ces boutons.

Bouton d'étape

Appuyez sur Step et la fenêtre de débogage ressemblera à ceci :

SOURCE

Notez deux différences. Tout d'abord, le message dans le volet de la pile a changé :

> '_main_'.(), ligne 2 : j = i * 2 :

À ce stade, la ligne 1 est exécutée et le débogueur s'arrête avant d'exécuter la ligne 2.

Deuxièmement, une nouvelle variable i avec une valeur de 1 dans le panneau Locals. La boucle for de la ligne 1 a créé une variable et lui a attribué cette valeur.

Continuez à appuyer sur le bouton Pas à pas pour parcourir le code ligne par ligne et observez ce qui se passe dans la fenêtre du débogueur. Lorsque vous arrivez à la ligne print(f" i est {i} et j est {j}"), vous pouvez voir la sortie affichée dans la fenêtre interactive un morceau à la fois.

L'important ici est que vous puissiez suivre les valeurs croissantes de i et j au fur et à mesure que vous parcourez la boucle for. C'est une fonctionnalité utile pour trouver la source des erreurs dans le code. Connaître la signification de chaque variable dans chaque ligne de code peut aider à identifier le problème.

Points d'arrêt et bouton Go

Souvent, vous savez qu'une erreur doit apparaître dans un certain morceau de code, mais vous ne savez pas où exactement. Les points d'arrêt indiquent au débogueur quand suspendre l'exécution du code afin que vous puissiez jeter un œil à l'état actuel du programme.

Pour définir un point d'arrêt, cliquez avec le bouton droit (Ctrl pour Mac) sur la ligne de code que vous souhaitez mettre en pause et choisissez Définir le point d'arrêt - IDLE mettra la ligne en surbrillance en jaune. Pour le supprimer, sélectionnez Effacer le point d'arrêt.

Définissez un point d'arrêt sur la ligne avec l'instruction print(). Maintenant, voyez la fenêtre de l'éditeur :

SOURCE

Enregistrez et exécutez. Comme précédemment, la barre empilée indique que le débogueur est en cours d'exécution et attend la ligne 1. Pour avancer, appuyez simplement sur le bouton Go :

SOURCE

Maintenant sur le panneau de la pile, il y a des informations sur l'exécution de la ligne 3 :

> '_main_'.(), ligne 3 : print(f"i est {i} et j est {j}")

Dans le panneau Locals, nous verrons que les variables i et j ont respectivement les valeurs 1 et quelques. Cliquez sur le bouton Go et demandez au débogueur d'exécuter le code jusqu'au point d'arrêt ou au début du programme. Appuyez sur retour - la fenêtre de débogage ressemble maintenant à ceci :

SOURCE

Le volet de la pile affiche le même message qu'avant – le débogueur attend la ligne 3. Cependant, les valeurs de i et j sont maintenant 2 et 4. Appuyez une troisième fois sur le bouton. Maintenant, i et j valent 3 et 6. Appuyez à nouveau sur Go pour quitter le programme.

Over and Out

Le bouton Over fonctionne comme une combinaison de Step and Go — il parcourt une fonction ou une boucle. En d'autres termes, si vous allez entrer dans une fonction à l'aide du débogueur, vous n'avez pas besoin d'exécuter le code de cette fonction – le bouton Over conduira directement au résultat de son exécution.

De même, si vous êtes déjà à l'intérieur d'une fonction ou d'une boucle, le bouton Out exécute le reste du code à l'intérieur du corps de la fonction ou de la boucle, puis s'arrête.

Dans la section suivante, nous allons explorer certaines des erreurs et apprendre comment les corriger en utilisant IDLE.

Combattre les bogues

Prenons l'exemple d'un programme facile et bogué.

La méthode add_underscores() définit ci-dessous comme acceptant une chaîne comme argument et renvoyant une nouvelle chaîne composée de traits de soulignement avant et après chaque caractère. Par exemple, add_underscores("python") renverra "_p_y_t_h_o_n_".

Voici le code cassé :

def add_underscores(word): new_word = "_" for i in range(len(word)): new_word = word[i] + "_" return new_word phrase = "hello" print(add_underscores(phrase))

Entrez ce code dans l'éditeur, enregistrez et appuyez sur F5. La sortie attendue est _h_e_l_l_o_, mais o_ est imprimé à la place.

Si vous trouvez quel est le problème, ne le résolvez pas. Notre objectif est d'apprendre à utiliser IDLE pour cela.

Considérons 4 étapes de recherche de bogues :

• devinez où se trouve l'erreur ;

• définir un point d'arrêt et vérifier la ligne de code à la fois ;

• définir la ligne et apporter des modifications ;

• répétez les étapes 1 à 3 jusqu'à ce que le code fonctionne.

Étape 1 : Devinez

Vous ne pourrez pas identifier l'emplacement exact de l'erreur au début, mais il est généralement plus facile d'imaginer logiquement quelle section du code regarder.

Notez que le programme est divisé en deux sections : la définition de la fonction add_underscores() et le bloc principal, qui définit une variable avec la valeur « hello » et affiche le résultat.

Voyons maintenant le code de la section principale :

phrase = "hello" print(add_underscores(phrase)) Évidemment, tout va bien ici et le problème devrait être dans la définition de la fonction : def add_underscores(word) : new_word = "_" for i in range(len(word) ): nouveau_mot = mot[i] + "_" renvoie nouveau_mot

La première ligne crée la variable new_word avec la valeur « _ ». Mademoiselle, le problème se situe quelque part dans le corps de la boucle for a.

Étape 2 : point d'arrêt

Une fois que vous avez identifié où se trouve l'erreur, définissez un point d'arrêt au début de la boucle for pour suivre ce qui se passe dans le code :

SOURCE

Commençons. L'exécution s'arrête à la ligne avec la définition de la fonction.

Cliquez sur le bouton Go pour exécuter le code jusqu'au point d'arrêt :

SOURCE

Le code s'arrête avant la boucle for dans la fonction add_underscores (). Notez que le panneau Locals affiche deux variables locales - un mot avec la valeur "hello" et new_word avec la valeur "_"

Cliquez sur le bouton Pas pour entrer dans la boucle for. La fenêtre de débogage change et donc la nouvelle variable i avec une valeur de 0 est affichée dans le panneau Locals :

La variable i est un compteur pour la boucle for que vous pouvez utiliser pour suivre l'itération actuellement active.

SOURCE

Appuyez à nouveau sur le bouton Step et regardez le panneau Locals - la variable new_word est définie sur "h_":

SOURCE

C'est faux et la raison en est qu'au début new_word la valeur est « _ », à la deuxième itération la valeur est « _h_ ». Si nous appuyons sur Step plusieurs fois, nous verrons que new_word contient la valeur e_, puis l_, et ainsi de suite.

Étape 3 : Identifiez l'erreur et corrigez-la

Comme nous l'avons déjà découvert, à chaque itération de la boucle, new_word est écrasé par le caractère suivant de la ligne « hello » et un trait de soulignement. Puisqu'il n'y a qu'une seule ligne de code à l'intérieur de la boucle, le problème devrait être là :

new_wor = mot[i] + "_"

Le code indique à Python d'obtenir le caractère de mot suivant, d'attacher un trait de soulignement et d'affecter le saut de ligne à la variable new_word. C'est exactement le mauvais comportement que nous avons observé.

Pour tout réparer, vous devez combiner le mot [i] + " _ " avec la valeur existante new_word. Cliquez sur le bouton Quitter dans la fenêtre de débogage, mais ne la fermez pas. Ouvrez une fenêtre d'éditeur et modifiez la ligne à l'intérieur de la boucle for comme suit :

nouveau_mot = nouveau_mot + mot[i] + "_"

Le débogueur n'est basculé qu'en cas d'inactivité !

Appuyez toujours sur le bouton Go ou Quit lorsque vous avez terminé le débogage, sinon vous risquez d'avoir des problèmes pour le redémarrer.

Étape 4 : Répétez les étapes 1 à 3 jusqu'à ce que l'erreur disparaisse

Enregistrez les modifications dans le programme et exécutez-le à nouveau. Dans la fenêtre de débogage, cliquez sur le bouton Go pour exécuter le code jusqu'au point d'arrêt. Appuyez plusieurs fois sur Step et voyez ce qui arrive à la variable new_word à chaque itération - tout fonctionne, il va sans dire. Parfois, il est nécessaire de répéter ce processus plusieurs fois avant que l'erreur ne soit corrigée.

Méthodes alternatives pour trouver les erreurs

L'utilisation du débogueur peut être délicate et longue, mais c'est le moyen le plus fiable de trouver des bogues dans votre code. Cependant, les débogueurs ne sont pas toujours disponibles. Dans des situations comme celle-ci, vous utiliserez le débogage d'impression pour rechercher des bogues dans votre code. PD utilise la fonction print() pour afficher du texte sur la console indiquant où le programme s'exécute et l'état des variables.

À titre d'exemple, le code ci-dessous peut être ajouté à la fin de la boucle, pour le débogage :

print(f"i = {i} ; new_wor = {new_wor}")

Le code modifié ressemblera à ceci :

def add_underscores(word): new_wor = "_" for i in range(len(word)): new_wor = word[i] + "_" print(f"i = {i}; new_word = {new_wor}") return new_wor phrase = "bonjour" print(add_underscores(phrase))

La sortie devrait ressembler à ceci:

je = 0 ; new_wor = h_ i = 1 ; new_wor = e_ i = 2 ; new_wor = l_ i = 3; nouveau_wor = l_ i = 4; new_wor = o_ o_

PD fonctionne mais présente plusieurs inconvénients par rapport au débogage avec un débogueur. Vous devez exécuter l'intégralité du programme chaque fois que vous souhaitez vérifier les valeurs des variables et n'oubliez pas de supprimer les appels aux fonctions print().

Une façon d'améliorer notre boucle est d'itérer sur les caractères d'un mot :

def add_underscores(word): new_wor = "_" pour la lettre dans le mot: new_wor = new_wor + letter + "_" return new_wor

Conclusion

Vous savez maintenant tout sur le débogage DLE. Vous pouvez utiliser ce principe avec différents débogueurs.

Dans ce texte, nous avons abordé les sujets suivants :

• en utilisant la fenêtre de contrôle de débogage ;

• définir un point d'arrêt pour une compréhension approfondie du fonctionnement du code ;

• utilisation des boutons Step, Go, Over et Out ;

N'arrêtez pas d'apprendre et de vous entraîner au débogage – c'est amusant ! et contactez-moi sur LinkedIn à https://www.linkedin.com/in/shivani-sharma-aba6141b6/

Les médias présentés dans cet article ne sont pas la propriété d'Analytics Vidhya et sont utilisés à la discrétion de l'auteur.

Services Connexes

Source : https://www.analyticsvidhya.com/blog/2021/08/debugging-with-idle-find-and-fix-bugs-in-your-python-code/