Tutoriel : Exécuter du code dans le débogueur dans Visual Studio

Article
02/03/2025

Cet article présente l’étape 4 de la série de didacticiels Utiliser Python dans Visual Studio.

Visual Studio offre des fonctionnalités pour gérer des projets, une expérience d’édition enrichie, la fenêtre interactiveet le débogage complet pour le code Python. À l’étape 4 de cette série de didacticiels, vous utilisez le débogueur pour exécuter votre code pas à pas, y compris chaque itération d’une boucle. Dans le débogueur , vous pouvez interrompre votre programme chaque fois que certaines conditions sont remplies. À tout moment, lorsque le programme est suspendu, vous pouvez examiner l’état complet du programme et modifier la valeur des variables. Ces actions sont essentielles pour le suivi des bogues du programme et fournissent également des aides utiles pour suivre le flux exact du programme.

À l’étape 4 du didacticiel, vous allez apprendre à :

Exécuter du code Python dans le débogueur dans Visual Studio
Définir des points d’arrêt et des conditions
Examiner l’état du programme et modifier les variables
Explorez les fenêtres et les actions du débogueur

Conditions préalables

Projet d’application Python doté d’un fichier Python (.py) avec du code créé à l’étape 2 : écrire et exécuter du code Python et étape 3 : utilisez la fenêtre REPL interactive de ce didacticiel.

Préparer le fichier Python

Pour préparer l’exercice de débogage, procédez comme suit pour mettre à jour votre fichier projet Python afin d’inclure du code plus robuste :

Ouvrez votre fichier projet Python (.py) dans l’éditeur.

Remplacez le code dans le fichier par le code suivant. Cette version du code développe la fonction make_dot_string afin de pouvoir examiner ses étapes discrètes dans le débogueur. Il déplace la boucle for dans une fonction main et l’exécute explicitement en appelant la fonction main :

from math import cos, radians

# Create a string with spaces proportional to a cosine of x in degrees
def make_dot_string(x):
    rad = radians(x)                             # cos works with radians
    numspaces = int(20 * cos(rad) + 20)          # Scale to 0-40 spaces
    st = ' ' * numspaces + 'o'                   # Place 'o' after the spaces
    return st

def main():
    for i in range(0, 1800, 12):
        s = make_dot_string(i)
        print(s)

main()

Démarrer le débogage

Vous êtes maintenant prêt à vérifier votre code Python mis à jour dans le débogueur .

Vérifiez que le code fonctionne correctement en sélectionnant Déboguer>démarrer le débogage dans la barre d’outils ou utilisez le raccourci clavier F5. Ces commandes exécutent le code dans le débogueur .

Le débogueur ne détecte aucun problème. Par conséquent, le programme s’exécute correctement. Une fenêtre de sortie s’ouvre et vous voyez quelques itérations du modèle d’onde cosinus. Sélectionnez n’importe quelle clé pour fermer la fenêtre de sortie.

Conseil

Pour fermer automatiquement la fenêtre Sortie à la fin de l’exécution du programme, sélectionnez Outils>Options, développez l’onglet Python>Débogage, puis désactivez l’option Attendre une entrée lorsque le processus quitte de manière habituelle.
Définissez un point d’arrêt sur l’instruction de boucle for à l’aide de l’une des méthodes suivantes :
- Sélectionnez la marge de gauche pour la ligne de code.
- Cliquez avec le bouton droit sur la ligne de code et sélectionnez Point d’arrêt>Insérer un Point d’arrêt.
- Placez le point d’insertion dans la ligne de code et sélectionnez Déboguer>Activer/désactiver le Point d'arrêt (ou utilisez le raccourci clavier F9).
Les points d’arrêt arrêtent l’exécution du code à un point marqué pour vous permettre d’inspecter l’état du programme. Un point rouge apparaît sur chaque ligne qui a un point d’arrêt défini.
Démarrez à nouveau le débogueur (F5). Le code en cours d’exécution pour le programme s’arrête sur la ligne avec le point d’arrêt défini. Vous pouvez maintenant inspecter la pile des appels et examiner les variables pour cet état du code du programme en cours d’exécution.

Visual Studio fournit de nombreuses façons d’observer le code et les données d’exécution de votre programme, notamment les fenêtres suivantes :
- La pile d’appels affiche l’historique des appels de fonction et de méthode dans le code du programme.
- Les variables définies qui sont dans le périmètre apparaissent dans la fenêtre Autos.
- La vue Locals affiche toutes les variables que Visual Studio trouve dans l’étendue actuelle (y compris les fonctions), même avant qu’elles ne soient définies dans le code.
Pour afficher la liste complète des fenêtres et actions disponibles, sélectionnez Déboguer>Windows.

Vous pouvez ouvrir les fenêtres du débogueur pour afficher l’état de votre programme quand un point d'arrêt est rencontré :

Utiliser des actions de débogueur

Lorsque Visual Studio arrête l’exécution du code à un point d’arrêt, il existe plusieurs commandes que vous pouvez utiliser pour parcourir votre code ou exécuter des blocs de code avant de rompre à nouveau. Les commandes sont disponibles à quelques endroits dans Visual Studio, notamment la barre d’outils du débogueur, le menu de débogage, le menu contextuel en cliquant avec le bouton droit dans l’éditeur de code et via les raccourcis clavier.

La barre d'outils du débogueur en haut de la fenêtre Visual Studio fournit un accès rapide aux commandes de débogage les plus courantes :

Le tableau suivant récapitule ces commandes, car elles apparaissent de gauche à droite dans la barre d’outils :

Action	Raccourci	Description
Continue	F5	Exécutez le code jusqu’à atteindre le point d’arrêt suivant ou jusqu’à la fin du programme.
Interrompre tout	Ctrl+Alt+Arrêt	Suspendre un programme de longue durée.
Arrêter le débogage	Shift+F5	Arrêtez le programme à ce point précis, et quittez le débogueur.
redémarrer	Ctrl+Shift+F5	Arrêtez le programme au point actuel et redémarrez l’exécution du programme à partir du début dans le débogueur .
Afficher l’instruction suivante	Alt+Num+\	Revenez à l’instruction suivante à exécuter dans le code. Cette commande vous aide à localiser l’emplacement dans votre code où le débogueur est arrêté.
Entrez dans	F11	Exécutez l’instruction suivante et arrêtez. Si l’instruction suivante est un appel à une fonction, le Débogueur entre dans la fonction et s’arrête à la première ligne.
Pas à pas principal	F10	Exécutez l’instruction suivante, notamment en effectuant un appel à une fonction (exécutant tout son code) et en appliquant n’importe quelle valeur de retour. Cette commande vous permet d’ignorer facilement les fonctions que vous n’avez pas besoin de déboguer.
Pas à pas sortant	Shift+F11	Exécutez le code jusqu’à la fin de la fonction active, puis passez à l’instruction appelante et suspendez. Cette commande est utile lorsque vous n’avez pas besoin de déboguer le reste de la fonction actuelle.

Procédez comme suit pour utiliser débogueur actions dans votre code Python :

Utilisez l’action Pas à pas pour parcourir l’instruction de boucle for.

Pas à pas entraîne l’exécution immédiate du débogueur pour exécuter la ligne de code actuelle, y compris toute fonction appelée, puis s’interrompre immédiatement. Après avoir effectué un pas à travers, notez que la variable i est maintenant définie dans les fenêtres Variables locales et Automatique.
Dépassez la ligne de code suivante, qui appelle la fonction make_dot_string.

Dans cette instance, pas à pas entraîne l’exécution du de débogueur pour exécuter la fonction make_dot_string complète et suspendre après le retour de la fonction. Le débogueur ne s’arrête pas à l’intérieur de la fonction, sauf si un point d’arrêt distinct s’y trouve.
Continuez à passer le code en revue pas à pas quelques fois de plus et observez comment les valeurs dans les fenêtres Locals ou Autos changent.
Dans la fenêtre Locals ou dans la fenêtre automatique, double-cliquez sur la colonne Valeur d’une variable pour modifier la valeur. Dans cet exemple, remplacez la valeur de la variable s par 'Hello, Python Application'. Veillez à placer la valeur entre guillemets simples. Sélectionnez Entrez ou n’importe quelle zone en dehors de la valeur pour appliquer vos modifications.
Continuez à parcourir le code en utilisant Effectuer un pas à pas détaillé jusqu’à ce que l’appel à la fonction make_dot_string.

Pour une fonction, Effectuer un pas à pas détaillé permet au débogueur d’appeler la fonction et pas à pas dans le code de la fonction. Lorsque le processus de débogage se trouve à l’intérieur d’une fonction, vous pouvez examiner ses variables locales et parcourir son code spécifiquement. Dans cet exemple, l’action Effectuer un pas à pas détaillé dans passe à la fonction make_dot_string.
Continuez l'exécution avec Effectuer un pas à pas détaillé jusqu'au retour de la fonction make_dot_string.

Lorsque vous atteignez la fin du code de la fonction make_dot_string, l’étape suivante renvoie le *débogueur à la boucle for avec la nouvelle valeur de retour dans la variable s.

Lorsque vous passez à nouveau à l’instruction print, notez que l’action Pas à pas dans de l’instruction print n’entre pas dans cette fonction. Ce comportement est dû au fait que la fonction print n’est pas écrite en Python. Il s’agit d’un code natif à l’intérieur du runtime Python.
Continuez à utiliser Effectuer un pas à pas détaillé jusqu’à ce que vous reveniez dans la fonction make_dot_string, puis utilisez Sortir en pas à pas et remarquez que le Débogueur retourne à la boucle for.

Avec Pas à pas sortant, le débogueur exécute le reste de la fonction, puis s’interrompt automatiquement dans le code appelant. Cette action est utile après avoir parcouru une partie d’une longue fonction et que vous souhaitez mettre fin à votre observation de la fonction. Pas à pas exécute pas à pas dans le code restant ou jusqu’à ce qu’il atteigne un point d’arrêt explicite défini dans le code appelant.
Continuez à exécuter le programme jusqu’à ce que le point d’arrêt suivant soit atteint à l’aide de Continuer (F5). Étant donné que vous avez un point d’arrêt défini dans la boucle for, vous arrêtez sur l’itération suivante.

Vous pouvez confirmer que le programme continue à s’exécuter en observant la valeur de modification de la variable s dans la fenêtre Locals.

Utiliser des conditions de point d’arrêt

L’exécution de centaines d’itérations d’une boucle peut être fastidieuse. Visual Studio vous permet donc d’ajouter une condition à un point d’arrêt. Lorsque vous définissez une condition de point d’arrêt, le débogueur interrompt le programme au point d’arrêt uniquement lorsque la condition est remplie.

Les étapes suivantes montrent comment définir une condition de point d’arrêt sur l’instruction de boucle for afin que le débogueur s’interrompt uniquement lorsque la valeur de la variable i dépasse 1600 :

Pour définir la condition de point d’arrêt, cliquez avec le bouton droit sur le point d’arrêt rouge et sélectionnez Conditions ou utilisez le raccourci clavier Alt+F9>C.
Dans la fenêtre contextuelle Paramètres du Point d'Arrêt, configurez les paramètres suivants pour créer la Condition :
1. Définissez le type de condition sur Expression Conditionnelle.
2. Définissez l’évaluation de la condition sur Est true.
3. Entrez i > 1600 comme valeur de condition.
4. Sélectionnez Fermer.
Sélectionnez F5 pour poursuivre le débogage et l’exécution du programme. Notez que le programme exécute de nombreuses itérations avant d’atteindre le point d’arrêt conditionnel.

Vous pouvez confirmer que le débogueur suspend correctement l’exécution du programme lorsqu’il atteint le point d’arrêt conditionnel. Lorsque la condition est remplie, la fenêtre Locals affiche la valeur de la variable i comme 1608.
Pour exécuter le programme à la fin, vous pouvez désactiver le point d’arrêt et poursuivre l’exécution du programme.
1. Pointez sur le point rouge et sélectionnez Désactiver, ou cliquez avec le bouton droit sur le point rouge, puis sélectionnez Désactiver le point d’arrêt.
2. Sélectionnez Continuer (ou appuyez sur F5) pour exécuter le programme.
Lorsque le programme se termine, Visual Studio arrête la session de débogage et retourne en mode édition.

Vous pouvez également supprimer un point d’arrêt. Sélectionnez le point rouge ou cliquez avec le bouton droit sur le point, puis sélectionnez Supprimer le point d’arrêt. Cette action supprime également toutes les conditions définies.

Conseil

Dans certaines situations, comme un échec de lancement de l'interpréteur Python lui-même, la fenêtre de sortie Python peut se fermer immédiatement après la fin du programme sans pause et sans afficher l'invite Appuyez sur une touche pour continuer. Pour forcer la pause et l’invite, ajoutez l’argument -i au champ Exécuter>arguments d’interpréteur sous l’onglet Déboguer. Cet argument place l’interpréteur Python en mode interactif après l’exécution du code. Le programme attend que vous deviez sélectionner Ctrl+Z+Entrée pour fermer la fenêtre.

Étape suivante

Étape 5 : Installer des packages et gérer des environnements Python

Partage via