Lernprogramm: Ausführen von Code im Debugger in Visual Studio

Artikel
2025-02-03

In diesem Artikel wird Schritt 4 in der Tutorialreihe Arbeiten mit Python in Visual Studiovorgestellt.

Visual Studio bietet Funktionen für das Verwalten von Projekten, eine umfassende Bearbeitungsumgebung, das interaktive Fenster und ein vollständiges Debugging für Python-Code. In Schritt 4 dieser Tutorialreihe verwenden Sie den Debugger, um Ihren Code Schritt für Schritt auszuführen, einschließlich jeder Iteration einer Schleife. Im Debugger-können Sie das Programm anhalten, wenn bestimmte Bedingungen erfüllt sind. An jedem Punkt, an dem das Programm angehalten wird, können Sie den gesamten Programmzustand untersuchen und den Wert von Variablen ändern. Solche Aktionen sind für die Nachverfolgung von Programmfehlern unerlässlich und bieten auch hilfreiche Unterstützung für das Folgen des genauen Programmablaufs.

In Schritt 4 des Lernprogramms erfahren Sie, wie Sie:

Ausführen von Python-Code im Debugger- in Visual Studio
Festlegen von Haltepunkten und Bedingungen
Untersuchen des Programmstatus und Ändern von Variablen
Erkunden Sie Debugger Fenster und Aktionen

Voraussetzungen

Ein Python-Anwendungsprojekt mit einer Python-Datei (.py) mit Code, der in Schritt 2 erstellt wurde: Schreiben und Ausführen von Python-Code und Schritt 3: Verwenden Sie das interaktive REPL-Fenster dieses Lernprogramms.

Vorbereiten der Python-Datei

Führen Sie zum Vorbereiten der Debugübung die folgenden Schritte aus, um Ihre Python-Projektdatei so zu aktualisieren, dass sie robusteren Code enthält:

Öffnen Sie Ihre Python-Projektdatei (.py) im Editor.

Ersetzen Sie den Code in der Datei durch den folgenden Code. Diese Version des Codes erweitert die make_dot_string-Funktion, damit Sie die einzelnen Schritte im Debugger untersuchen können. Sie verschiebt die for Schleife in eine main-Funktion und führt sie explizit durch Aufrufen der main-Funktion aus:

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()

Debuggen starten

Jetzt können Sie den aktualisierten Python-Code im Debugger-überprüfen.

Vergewissern Sie sich, dass der Code ordnungsgemäß funktioniert, indem Sie Debuggen>Debuggen starten auf der Symbolleiste auswählen oder die tastenkombination F5 verwenden. Diese Befehle führen den Code im Debuggeraus.

Der Debugger- erkennt keine Probleme, sodass das Programm erfolgreich ausgeführt wird. Ein Ausgabefenster wird geöffnet, und Es werden einige Iterationen des Kosinuswellenmusters angezeigt. Wählen Sie einen beliebigen Schlüssel aus, um das Ausgabefenster zu schließen.

Tipp

Um das Ausgabefenster automatisch zu schließen, wenn das Programm abgeschlossen ist, wählen Sie Tools>Optionenaus, erweitern Sie die Registerkarte Python>Debuggen und deaktivieren Sie die Option Warten auf Eingabe, wenn der Prozess normal beendet wird.
Legen Sie einen Haltepunkt für die for Loop-Anweisung mithilfe einer der folgenden Methoden fest:
- Wählen Sie links in der Randspalte die Zeile mit dem Code aus.
- Klicken Sie mit der rechten Maustaste auf die Codezeile, und wählen Sie Haltepunkt>Haltepunkt einfügen aus.
- Setzen Sie die Einfügemarke in die Codezeile, und wählen Sie Debuggen>Haltepunkt ein/aus aus (oder verwenden Sie den Tastaturkurzbefehl F9).
Haltepunkte beenden die Ausführung von Code an einem markierten Punkt, damit Sie den Programmzustand überprüfen können. In jeder Zeile mit einem festgelegten Haltepunkt wird ein roter Punkt angezeigt.
Starten Sie den Debugger erneut (F5). Der ausgeführte Code für das Programm stoppt in der Zeile mit dem festgelegten Haltepunkt. Sie können nun den Aufrufstapel überprüfen und Variablen für diesen Zustand des ausgeführten Programmcodes untersuchen.

Visual Studio bietet viele Möglichkeiten zum Beobachten von Programmcode- und Ausführungsdaten, einschließlich der folgenden Fenster:
- Der Aufrufstapel zeigt den Verlauf der Funktions- und Methodenaufrufe durch den Programmcode an.
- Definierte Variablen, die berücksichtigt werden, werden im Fenster Auto angezeigt.
- Die ansicht Locals zeigt alle Variablen an, die Visual Studio im aktuellen Bereich (einschließlich Funktionen) findet, auch bevor sie im Code definiert sind.
Um die vollständige Liste der verfügbaren Fenster und Aktionen anzuzeigen, wählen Sie Debuggen>Windowsaus.

Sie können die Debugger-Fenster öffnen, um den Programmzustand anzuzeigen, wenn ein Haltepunkt gefunden wird:

Debugger-Aktionen verwenden

Wenn Visual Studio die Codeausführung an einem Haltepunkt stoppt, gibt es mehrere Befehle, mit denen Sie den Code schrittweise durchgehen oder Codeblöcke ausführen können, bevor die Ausführung erneut unterbrochen wird. Die Befehle sind an einigen Stellen in Visual Studio verfügbar, einschließlich der Symbolleiste Debugger-, dem Menü Debuggen, dem Kontextmenü im Code-Editor und über Tastenkombinationen.

Die symbolleiste Debugger- am oberen Rand des Visual Studio-Fensters bietet schnellen Zugriff auf die am häufigsten verwendeten Debugbefehle:

In der folgenden Tabelle werden diese Befehle zusammengefasst, da sie von links nach rechts auf der Symbolleiste angezeigt werden:

Handlung	Tastaturkurzbefehl	Beschreibung
fortsetzen	F5	Führen Sie Code aus, bis Sie den nächsten Haltepunkt erreichen oder bis zum Abschluss des Programms.
Alle unterbrechen	STRG+ALT+Unterbrechen	Ein länger laufendes Programm anhalten.
Debuggen beenden	UMSCHALT+F5	Stoppt das Programm am aktuellen Punkt, und beendet den Debugger.
neustarten	STRG+UMSCHALT+F5	Beenden Sie das Programm am aktuellen Punkt, und starten Sie die Programmausführung von Anfang an im Debugger-neu.
Nächste Anweisung anzeigen	ALT+NUM+\	Kehren Sie zur nächsten Anweisung zurück, die im Code ausgeführt werden soll. Mit diesem Befehl können Sie die Stelle im Code finden, an der der Debugger angehalten ist.
Treten Sie ein in	F11	Führt die nächste Anweisung aus, und hält den Vorgang an. Wenn es sich bei der nächsten Anweisung um einen Aufruf einer Funktion handelt, tritt der Debugger in die Funktion ein und hält an der ersten Zeile an.
Prozedurschritt	F10	Führen Sie die nächste Anweisung aus, einschließlich eines Aufrufs einer Funktion (ausführen des gesamten Codes), und wenden Sie einen beliebigen Rückgabewert an. Mit diesem Befehl können Sie Funktionen ganz einfach überspringen, die Sie nicht debuggen müssen.
Treten Sie heraus	UMSCHALT+F11	Führen Sie den Code bis zum Ende der aktuellen Funktion aus, gehen Sie dann zur aufrufenden Anweisung über und pausieren Sie. Dieser Befehl ist nützlich, wenn Sie den Rest der aktuellen Funktion nicht debuggen müssen.

Führen Sie die folgenden Schritte aus, um mit Debugger- Aktionen in Ihrem Python-Code zu arbeiten:

Überspringen Sie die for-Schleifenanweisung mithilfe der Aktion Schritt überspringen.

Schritt bewirkt, dass der Debugger die aktuelle Codezeile, einschließlich aller aufgerufenen Funktionen, ausführt und sofort wieder angehalten wird. Anschließend ist die Variable i in den Fenstern Lokale Variablen und Auto definiert.
Step Over die nächste Codezeile, die die make_dot_string-Funktion aufruft.

In diesem Fall bewirkt Schritt überspringen, dass der Debugger die komplette Funktion make_dot_string ausführt und nach der Rückgabe der Funktion pausiert. Der -Debugger hält nicht innerhalb der Funktion an, es sei denn, es gibt dort einen separaten Haltepunkt.
Überspringen Sie den Code einige Male und beobachten Sie, wie sich die Werte im Fenster Lokale Variablen bzw. Auto ändern.
Doppelklicken Sie im Fenster Locals oder Autos auf die Spalte Wert für eine Variable, um den Wert zu bearbeiten. Ändern Sie in diesem Beispiel den Wert für die variable s in 'Hello, Python Application'. Achten Sie darauf, den Wert in einfache Anführungszeichen einzuschließen. Wählen Sie Geben Sie oder einen beliebigen Bereich außerhalb des Werts ein, um Ihre Änderungen anzuwenden.
Führen Sie das Durchlaufen des Codes fort, indem Sie Step Into verwenden, bis der Aufruf der make_dot_string-Funktion erfolgt.

Bei einer Funktion bewirkt Schrittweise ausführen, dass der Debugger die Funktion aufrufen und den Funktionscode schrittweise ausführen kann. Wenn sich der Debuggingprozess in einer Funktion befindet, können Sie die lokalen Variablen untersuchen und den Code spezifisch durchlaufen. In diesem Beispiel wechselt die Aktion Schrittweise ausführen zur Funktion make_dot_string.
Führen Sie die Aktion Schrittweise ausführen bis die Funktion make_dot_string zurückgegeben wird.

Wenn Sie das Ende des Funktionscodes make_dot_string erreicht haben, wird beim nächsten Schritt der *Debugger mit dem neuen Rückgabewert in der Variable s an die Schleife for zurückgegeben.

Beim erneuten Ausführen der print-Anweisung gelangt die Aktion Schrittweise ausführen für die print-Anweisung nicht in diese Funktion. Dieses Verhalten liegt daran, dass die print-Funktion nicht in Python geschrieben ist. Es ist systemeigener Code innerhalb der Python-Laufzeit.
Verwenden Sie die Aktion Schrittweise ausführen, bis Sie wieder auf halbem Weg in die make_dot_string-Funktion sind. Verwenden Sie dann die Aktion Ausführen bis Rücksprung, sodass der Debugger zur for-Schleife zurückkehrt.

Mit Step Outführt der Debugger den Rest der Funktion aus und pausiert dann automatisch im aufrufenden Code. Diese Aktion ist hilfreich, nachdem Sie einen Teil einer langwierigen Funktion durchlaufen und Ihre Beobachtung der Funktion beenden möchten. Ausführen bis Rücksprung durchläuft den verbleibenden Code, oder stoppt, sobald ein expliziter Haltepunkt im aufrufenden Code erreicht wird.
Fahren Sie mit der Ausführung des Programms fort, bis der nächste Haltepunkt erreicht ist, indem Sie Continue (F5) verwenden. Da in der for-Schleife ein Haltepunkt festgelegt ist, unterbrechen Sie die nächste Iteration.

Sie können bestätigen, dass das Programm weiterhin ausgeführt wird, indem Sie den Änderungswert für die variable s im Fenster locals beobachten.

Verwenden von Haltepunktbedingungen

Die Ausführung von Hunderten von Iterationen einer Schleife ist recht aufwendig. Daher können Sie in Visual Studio einem Haltepunkt eine Bedingung hinzufügen. Wenn Sie eine Haltepunktbedingung festlegen, hält der Debugger das Programm nur an dem Haltepunkt an, wenn die Bedingung erfüllt ist.

Die folgenden Schritte zeigen, wie Sie eine Haltepunktbedingung für die for Loop-Anweisung definieren, sodass die Debugger- nur angehalten wird, wenn der Wert der i Variable 1600 überschreitet:

Um die Haltepunktbedingung festzulegen, klicken Sie mit der rechten Maustaste auf den roten Haltepunkt und wählen Sie Bedingungen aus oder verwenden Sie die Tastenkombination Alt+F9>C.
Konfigurieren Sie im Popupdialogfeld Haltepunkteinstellungen die folgenden Einstellungen, um die Bedingung zu erstellen:
1. Legen Sie den Bedingungstyp auf Bedingter Ausdruckfest.
2. Legen Sie die Bedingungsauswertung auf Is true fest.
3. Geben Sie i > 1600 als Bedingungswert ein.
4. Klicken Sie auf Schließen.
Wählen Sie F5- aus, um das Debuggen und die Programmausführung fortzusetzen. Beachten Sie, dass das Programm viele Iterationen ausführt, bevor es den bedingten Haltepunkt erreicht.

Sie können bestätigen, dass der Debugger die Programmausführung ordnungsgemäß anhält, wenn er den bedingten Haltepunkt erreicht. Wenn die Bedingung erfüllt ist, zeigt das Fenster Locals den Wert der i-Variablen als 1608an.
Um das Programm bis zum Ende auszuführen, können Sie den Breakpoint deaktivieren und die Programmausführung fortsetzen.
1. Zeigen Sie mit der Maus auf den roten Punkt, und wählen Sie Deaktivieren aus, oder klicken Sie mit der rechten Maustaste auf den roten Punkt, und wählen Sie Haltepunkt deaktivieren aus.
2. Wählen Sie Weiter (oder drücken Sie F5), um das Programm auszuführen.
Wenn das Programm beendet wird, beendet Visual Studio die Debugsitzung und kehrt zum Bearbeitungsmodus zurück.

Sie können einen Haltepunkt auch löschen. Wählen Sie den roten Punkt aus, oder klicken Sie mit der rechten Maustaste auf den Punkt, und wählen Sie Haltepunkt löschen aus. Diese Aktion löscht auch alle definierten Bedingungen.

Tipp

In einigen Situationen, z. B. bei einem Fehler beim Starten des Python-Interpreters selbst, kann es vorkommen, dass das Python-Ausgabefenster unmittelbar nach Abschluss des Programms geschlossen wird, ohne anzuhalten und die Eingabeaufforderung "Drücken Sie eine beliebige Taste, um fortzufahren" anzuzeigen. Um das Anhalten und die Eingabeaufforderung zu erzwingen, fügen Sie das Argument -i dem Feld Ausführen>Interpreterargumente auf der Registerkarte Debuggen hinzu. Mit diesem Argument wird der Python-Interpreter nach der Codeausführung in den interaktiven Modus versetzt. Das Programm wartet, bis Sie STRG+Z+EINGABETASTE zum Schließen des Fensters gedrückt haben.

Nächster Schritt

Schritt 5: Installieren von Paketen und Verwalten von Python-Umgebungen

Freigeben über