Python-Debugging in VS Code

Die Python-Erweiterung unterstützt das Debugging über die Python-Debugger-Erweiterung für verschiedene Arten von Python-Anwendungen. Eine kurze Einführung in grundlegende Debugging-Schritte finden Sie unter Tutorial – Konfigurieren und Ausführen des Debuggers. Sehen Sie sich auch das Flask-Tutorial an. Beide Tutorials demonstrieren Kernkompetenzen wie das Setzen von Haltepunkten und das schrittweise Durchlaufen von Code.

Für allgemeine Debugging-Funktionen wie das Inspizieren von Variablen, das Setzen von Haltepunkten und andere Aktivitäten, die nicht sprachabhängig sind, lesen Sie VS Code Debugging.

Dieser Artikel behandelt hauptsächlich Python-spezifische Debugging-Konfigurationen, einschließlich der notwendigen Schritte für spezifische App-Typen und Remote-Debugging.

Python-Debugger-Erweiterung

Die Python-Debugger-Erweiterung wird automatisch zusammen mit der Python-Erweiterung für VS Code installiert. Sie bietet Debugging-Funktionen mit debugpy für verschiedene Arten von Python-Anwendungen, einschließlich Skripten, Webanwendungen, Remote-Prozessen und mehr.

Um zu überprüfen, ob sie installiert ist, öffnen Sie die Ansicht Erweiterungen (⇧⌘X (Windows, Linux Ctrl+Shift+X)) und suchen Sie nach @installed python debugger. Die Python-Debugger-Erweiterung sollte in den Ergebnissen aufgeführt sein.

Auf der README-Seite der Erweiterung finden Sie Informationen zu unterstützten Python-Versionen.

Konfigurationen initialisieren

Eine Konfiguration steuert das Verhalten von VS Code während einer Debugging-Sitzung. Konfigurationen werden in einer launch.json-Datei definiert, die in einem .vscode-Ordner in Ihrem Arbeitsbereich gespeichert wird.

Hinweis: Um die Debugging-Konfiguration zu ändern, muss Ihr Code in einem Ordner gespeichert sein.

Um Debugging-Konfigurationen zu initialisieren, wählen Sie zuerst die Ansicht Ausführen in der Seitenleiste aus

Wenn Sie noch keine Konfigurationen definiert haben, sehen Sie eine Schaltfläche Ausführen und Debuggen und einen Link zum Erstellen einer Konfigurationsdatei (launch.json)

Gehen Sie wie folgt vor, um eine launch.json-Datei mit Python-Konfigurationen zu generieren:

1. Wählen Sie den Link Eine launch.json-Datei erstellen (im obigen Bild umrandet) oder verwenden Sie den Menübefehl Ausführen > Konfigurationen öffnen.

2. Wählen Sie Python Debugger aus der Liste der Debugger-Optionen.

3. Ein Konfigurationsmenü wird über die Befehlspalette geöffnet und ermöglicht Ihnen die Auswahl des Typs der Debug-Konfiguration, die Sie für Ihre Python-Projektdatei verwenden möchten. Wenn Sie ein einzelnes Python-Skript debuggen möchten, wählen Sie Python-Datei im Menü Debug-Konfiguration auswählen aus, das erscheint.

   

   Hinweis: Das Starten einer Debugging-Sitzung über das Debug-Panel, F5 oder Ausführen > Debugging starten, wenn keine Konfiguration vorhanden ist, öffnet ebenfalls das Menü der Debug-Konfiguration, erstellt jedoch keine launch.json-Datei.

4. Die Python-Debugger-Erweiterung erstellt und öffnet dann eine launch.json-Datei, die eine vordefinierte Konfiguration enthält, die auf Ihrer vorherigen Auswahl basiert, in diesem Fall Python-Datei. Sie können Konfigurationen ändern (z. B. um Argumente hinzuzufügen) und auch benutzerdefinierte Konfigurationen hinzufügen.

   

Die Details der Konfigurationseigenschaften werden später in diesem Artikel unter Standardkonfiguration und Optionen behandelt. Andere Konfigurationen werden ebenfalls in diesem Artikel unter Debugging spezifischer App-Typen beschrieben.

Zusätzliche Konfigurationen

Standardmäßig zeigt VS Code nur die gängigsten Konfigurationen an, die von der Python-Debugger-Erweiterung bereitgestellt werden. Sie können andere Konfigurationen auswählen, die in launch.json enthalten sein sollen, indem Sie den Befehl Konfiguration hinzufügen in der Liste und im launch.json-Editor verwenden. Wenn Sie den Befehl verwenden, fordert VS Code Sie mit einer Liste aller verfügbaren Konfigurationen auf (stellen Sie sicher, dass Sie die Option Python auswählen).

Die Auswahl von Anhängen mit Prozess-ID ergibt folgendes Ergebnis:

Weitere Informationen zu all diesen Konfigurationen finden Sie unter Debugging spezifischer App-Typen.

Während des Debuggings zeigt die Statusleiste die aktuelle Konfiguration und den aktuellen Debugging-Interpreter an. Die Auswahl der Konfiguration öffnet eine Liste, aus der Sie eine andere Konfiguration auswählen können

Standardmäßig verwendet der Debugger denselben Interpreter, der für Ihren Arbeitsbereich ausgewählt ist, genau wie andere Funktionen der Python-Erweiterung für VS Code. Um einen anderen Interpreter speziell für das Debugging zu verwenden, legen Sie den Wert für python in launch.json für die entsprechende Debugger-Konfiguration fest. Alternativ können Sie den Python-Interpreter-Indikator in der Statusleiste verwenden, um einen anderen auszuwählen.

Grundlegendes Debugging

Wenn Sie nur ein Python-Skript debuggen möchten, ist der einfachste Weg, auf den Pfeil nach unten neben der Schaltfläche "Ausführen" im Editor zu klicken und Python Debugger: Python-Datei debuggen auszuwählen.

Wenn Sie eine Webanwendung mit Flask, Django oder FastAPI debuggen möchten, bietet die Python-Debugger-Erweiterung dynamisch erstellte Debug-Konfigurationen basierend auf Ihrer Projektstruktur unter der Option Alle automatischen Debug-Konfigurationen anzeigen über die Ansicht Ausführen und Debuggen.

Wenn Sie jedoch andere Arten von Anwendungen debuggen möchten, können Sie den Debugger über die Ansicht Ausführen starten, indem Sie auf die Schaltfläche Ausführen und Debuggen klicken.

Wenn keine Konfiguration eingerichtet wurde, erhalten Sie eine Liste mit Debugging-Optionen. Hier können Sie die entsprechende Option auswählen, um Ihren Code schnell zu debuggen.

Zwei gängige Optionen sind die Verwendung der Python-Datei-Konfiguration zum Ausführen der aktuell geöffneten Python-Datei oder die Verwendung der Anhängen mit Prozess-ID-Konfiguration zum Anhängen des Debuggers an einen bereits laufenden Prozess.

Informationen zum Erstellen und Verwenden von Debugging-Konfigurationen finden Sie in den Abschnitten Konfigurationen initialisieren und Zusätzliche Konfigurationen. Sobald eine Konfiguration hinzugefügt wurde, kann sie aus der Dropdown-Liste ausgewählt und mit der Schaltfläche Debugging starten (F5) gestartet werden.

Kommandozeilen-Debugging

Der Debugger kann auch von der Kommandozeile aus gestartet werden, wenn debugpy in Ihrer Python-Umgebung installiert ist.

Debugpy installieren

Sie können debugpy mit python -m pip install --upgrade debugpy in Ihrer Python-Umgebung installieren.

Tipp: Obwohl die Verwendung einer virtuellen Umgebung nicht erforderlich ist, ist sie eine empfohlene Vorgehensweise. Sie können eine virtuelle Umgebung in VS Code erstellen, indem Sie die Befehlspalette öffnen (⇧⌘P (Windows, Linux Ctrl+Shift+P)) und den Befehl Python: Virtuelle Umgebung erstellen ausführen ().

Syntax der Kommandozeile

Die Syntax für den Debugger-Befehl lautet wie folgt:

python -m debugpy
    --listen | --connect
    [<host>:]<port>
    [--wait-for-client]
    [--configure-<name> <value>]...
    [--log-to <path>] [--log-to-stderr]
    <filename> | -m <module> | -c <code> | --pid <pid>
    [<arg>]...

Beispiel

Von der Kommandozeile aus könnten Sie den Debugger mit einem bestimmten Port (5678) und Skript unter Verwendung der folgenden Syntax starten. Dieses Beispiel geht davon aus, dass das Skript lange läuft und unterlässt das Flag --wait-for-client, was bedeutet, dass das Skript nicht darauf wartet, dass der Client sich anhängt.

python -m debugpy --listen 5678 ./myscript.py

Sie würden dann die folgende Konfiguration verwenden, um sich von der VS Code Python-Debugger-Erweiterung anzuhängen.

{
  "name": "Python Debugger: Attach",
  "type": "debugpy",
  "request": "attach",
  "connect": {
    "host": "localhost",
    "port": 5678
  }
}

Hinweis: Die Angabe des Hosts ist für listen optional, standardmäßig wird 127.0.0.1 verwendet.

Wenn Sie Remote-Code oder Code, der in einem Docker-Container läuft, debuggen möchten, müssen Sie auf dem Remote-Computer oder im Container den vorherigen CLI-Befehl ändern, um einen Host anzugeben.

python -m debugpy --listen 0.0.0.0:5678 ./myscript.py

Die zugehörige Konfigurationsdatei würde dann wie folgt aussehen.

{
  "name": "Attach",
  "type": "debugpy",
  "request": "attach",
  "connect": {
    "host": "remote-machine-name", // replace this with remote machine name
    "port": 5678
  }
}

Hinweis: Beachten Sie, dass Sie, wenn Sie einen Host-Wert außer 127.0.0.1 oder localhost angeben, einen Port öffnen, der den Zugriff von jedem Rechner erlaubt, was Sicherheitsrisiken birgt. Sie sollten sicherstellen, dass Sie geeignete Sicherheitsvorkehrungen treffen, wie z. B. die Verwendung von SSH-Tunneln, wenn Sie Remote-Debugging durchführen.

Kommandozeilenoptionen

Hinweis: [<arg>] kann verwendet werden, um Kommandozeilenargumente an die gestartete App weiterzureichen.

Debugging durch Anhängen über eine Netzwerkverbindung

Lokales Skript-Debugging

Es kann vorkommen, dass Sie ein Python-Skript debuggen müssen, das lokal von einem anderen Prozess aufgerufen wird. Sie können beispielsweise einen Webserver debuggen, der verschiedene Python-Skripte für bestimmte Verarbeitungsaufgaben ausführt. In solchen Fällen müssen Sie den VS Code-Debugger an das Skript anhängen, sobald es gestartet wurde.

1. Führen Sie VS Code aus, öffnen Sie den Ordner oder Arbeitsbereich, der das Skript enthält, und erstellen Sie bei Bedarf eine launch.json-Datei für diesen Arbeitsbereich.

2. Fügen Sie im Skriptcode Folgendes hinzu und speichern Sie die Datei:

   import debugpy
   
   # 5678 is the default attach port in the VS Code debug configurations. Unless a host and port are specified, host defaults to 127.0.0.1
   debugpy.listen(5678)
   print("Waiting for debugger attach")
   debugpy.wait_for_client()
   debugpy.breakpoint()
   print('break on this line')
   

3. Öffnen Sie ein Terminal über Terminal: Neues Terminal erstellen, wodurch die ausgewählte Umgebung des Skripts aktiviert wird.

4. Installieren Sie im Terminal das debugpy-Paket (Debugpy installieren).

5. Starten Sie im Terminal Python mit dem Skript, z. B. python3 myscript.py. Sie sollten die Meldung "Waiting for debugger attach" sehen, die im Code enthalten ist, und das Skript hält am Aufruf von debugpy.wait_for_client() an.

6. Wechseln Sie zur Ansicht Ausführen und Debuggen (⇧⌘D (Windows, Linux Ctrl+Shift+D)), wählen Sie die entsprechende Konfiguration aus der Dropdown-Liste des Debuggers aus und starten Sie den Debugger.

7. Der Debugger sollte bei dem Aufruf von debugpy.breakpoint() anhalten, von wo aus Sie den Debugger normal verwenden können. Sie haben auch die Möglichkeit, andere Haltepunkte im Skriptcode über die Benutzeroberfläche anstelle von debugpy.breakpoint() zu setzen.

Remote-Skript-Debugging mit SSH

Remote-Debugging ermöglicht es Ihnen, ein Programm lokal innerhalb von VS Code schrittweise zu durchlaufen, während es auf einem Remote-Computer ausgeführt wird. Es ist nicht notwendig, VS Code auf dem Remote-Computer zu installieren. Zur Erhöhung der Sicherheit können Sie eine sichere Verbindung, wie z. B. SSH, zum Remote-Computer beim Debuggen verwenden oder benötigen.

Hinweis: Auf Windows-Computern müssen Sie möglicherweise Windows 10 OpenSSH installieren, um den Befehl ssh verwenden zu können.

Die folgenden Schritte umreißen den allgemeinen Prozess zur Einrichtung eines SSH-Tunnels. Ein SSH-Tunnel ermöglicht es Ihnen, auf Ihrem lokalen Computer zu arbeiten, als ob Sie direkt auf dem Remote-System arbeiten würden, und das auf sicherere Weise, als wenn ein Port für den öffentlichen Zugriff geöffnet wäre.

Auf dem Remote-Computer

1. Aktivieren Sie die Portweiterleitung, indem Sie die Konfigurationsdatei sshd_config (unter /etc/ssh/ unter Linux und unter %programfiles(x86)%/openssh/etc unter Windows zu finden) öffnen und die folgende Einstellung hinzufügen oder ändern:

   AllowTcpForwarding yes
   

   Hinweis: Der Standardwert für AllowTcpForwarding ist yes, daher müssen Sie möglicherweise keine Änderung vornehmen.

2. Wenn Sie AllowTcpForwarding hinzufügen oder ändern mussten, starten Sie den SSH-Server neu. Unter Linux/macOS führen Sie sudo service ssh restart aus; unter Windows führen Sie services.msc aus, wählen Sie OpenSSH oder sshd in der Liste der Dienste aus und wählen Sie Neustart.

Auf dem lokalen Computer

1. Erstellen Sie einen SSH-Tunnel, indem Sie ssh -2 -L Quellport:localhost:Zielport -i Identitätsdatei Benutzer@RemoteAdresse ausführen, wobei Sie einen ausgewählten Port für Zielport und den entsprechenden Benutzernamen sowie die IP-Adresse des Remote-Computers in Benutzer@RemoteAdresse verwenden. Um beispielsweise Port 5678 auf der IP-Adresse 1.2.3.4 zu verwenden, lautet der Befehl ssh -2 -L 5678:localhost:5678 -i Identitätsdatei Benutzer@1.2.3.4. Sie können den Pfad zu einer Identitätsdatei mit dem Flag -i angeben.

2. Stellen Sie sicher, dass Sie eine Eingabeaufforderung in der SSH-Sitzung sehen.

3. Erstellen Sie in Ihrem VS Code-Arbeitsbereich eine Konfiguration für das Remote-Debugging in Ihrer launch.json-Datei, wobei der Port dem im ssh-Befehl verwendeten Port entspricht und der Host auf localhost gesetzt ist. Sie verwenden hier localhost, da Sie den SSH-Tunnel eingerichtet haben.

   {
     "name": "Python Debugger: Attach",
     "type": "debugpy",
     "request": "attach",
     "port": 5678,
     "host": "localhost",
     "pathMappings": [
       {
         "localRoot": "${workspaceFolder}", // Maps C:\Users\user1\project1
         "remoteRoot": "." // To current working directory ~/project1
       }
     ]
   }
   

Debugging starten

Nachdem ein SSH-Tunnel zum Remote-Computer eingerichtet wurde, können Sie mit dem Debugging beginnen.

1. Beide Computer: Stellen Sie sicher, dass identischer Quellcode verfügbar ist.

2. Beide Computer: Debugpy installieren.

3. Remote-Computer: Es gibt zwei Möglichkeiten, wie Sie sich an den Remote-Prozess anhängen können.

   1. Fügen Sie im Quellcode die folgenden Zeilen hinzu und ersetzen Sie adresse durch die IP-Adresse und Portnummer des Remote-Computers (die IP-Adresse 1.2.3.4 dient hier nur zur Veranschaulichung).

      import debugpy
      
      # Allow other computers to attach to debugpy at this IP address and port.
      debugpy.listen(('1.2.3.4', 5678))
      
      # Pause the program until a remote debugger is attached
      debugpy.wait_for_client()
      

      Die in listen verwendete IP-Adresse sollte die private IP-Adresse des Remote-Computers sein. Sie können dann das Programm normal starten, wodurch es pausiert, bis sich der Debugger anhängt.

   2. Starten Sie den Remote-Prozess über debugpy, z. B.:

      python3 -m debugpy --listen 1.2.3.4:5678 --wait-for-client -m myproject
      

      Dies startet das Paket myproject mit python3, mit der privaten IP-Adresse des Remote-Computers 1.2.3.4 und lauschend auf Port 5678 (Sie können den Remote-Python-Prozess auch starten, indem Sie anstelle von -m einen Dateipfad angeben, z. B. ./hello.py).

4. Lokaler Computer: Nur wenn Sie den Quellcode auf dem Remote-Computer wie oben beschrieben geändert haben, fügen Sie im Quellcode eine auskommentierte Kopie derselben Zeilen hinzu, die Sie auf dem Remote-Computer hinzugefügt haben. Das Hinzufügen dieser Zeilen stellt sicher, dass der Quellcode auf beiden Computern zeilenweise übereinstimmt.

   #import debugpy
   
   # Allow other computers to attach to debugpy at this IP address and port.
   #debugpy.listen(('1.2.3.4', 5678))
   
   # Pause the program until a remote debugger is attached
   #debugpy.wait_for_client()
   

5. Lokaler Computer: Wechseln Sie in VS Code zur Ansicht Ausführen und Debuggen (⇧⌘D (Windows, Linux Ctrl+Shift+D)), wählen Sie die Konfiguration Python Debugger: Attach aus

6. Lokaler Computer: Setzen Sie einen Haltepunkt im Code, an dem Sie mit dem Debugging beginnen möchten.

7. Lokaler Computer: Starten Sie den VS Code-Debugger mit der geänderten Konfiguration Python Debugger: Attach und der Schaltfläche "Debugging starten". VS Code sollte bei Ihren lokal gesetzten Haltepunkten stoppen, sodass Sie den Code schrittweise durchlaufen, Variablen untersuchen und alle anderen Debugging-Aktionen durchführen können. Ausdrücke, die Sie in der Debug-Konsole eingeben, werden ebenfalls auf dem Remote-Computer ausgeführt.

   Textausgaben nach stdout, wie z. B. von print-Anweisungen, erscheinen auf beiden Computern. Andere Ausgaben, wie z. B. grafische Plots von Paketen wie Matplotlib, erscheinen jedoch nur auf dem Remote-Computer.

8. Während des Remote-Debuggings wird die Debugging-Symbolleiste wie folgt angezeigt:

   

   Auf dieser Symbolleiste beendet die Trennen-Schaltfläche (⇧F5 (Windows, Linux Shift+F5)) den Debugger und ermöglicht dem Remote-Programm, bis zum Ende zu laufen. Die Neustart-Schaltfläche (⇧⌘F5 (Windows, Linux Ctrl+Shift+F5)) startet den Debugger auf dem lokalen Computer neu, aber nicht das Remote-Programm. Verwenden Sie die Neustart-Schaltfläche nur, wenn Sie das Remote-Programm bereits neu gestartet haben und den Debugger erneut anhängen müssen.

Konfigurationsoptionen festlegen

Wenn Sie launch.json zum ersten Mal erstellen, gibt es zwei Standardkonfigurationen, die die aktive Datei im Editor entweder im integrierten Terminal (innerhalb von VS Code) oder im externen Terminal (außerhalb von VS Code) ausführen.

{
  "configurations": [
    {
      "name": "Python Debugger: Current File (Integrated Terminal)",
      "type": "debugpy",
      "request": "launch",
      "program": "${file}",
      "console": "integratedTerminal"
    },
    {
      "name": "Python Debugger: Current File (External Terminal)",
      "type": "debugpy",
      "request": "launch",
      "program": "${file}",
      "console": "externalTerminal"
    }
  ]
}

Die spezifischen Einstellungen werden in den folgenden Abschnitten beschrieben. Sie können auch andere Einstellungen hinzufügen, wie z. B. args, die nicht in den Standardkonfigurationen enthalten sind.

Tipp: Es ist oft hilfreich, in einem Projekt eine Konfiguration zu erstellen, die eine bestimmte Startdatei ausführt. Wenn Sie beispielsweise startup.py immer mit den Argumenten --port 1593 starten möchten, wenn Sie den Debugger starten, erstellen Sie einen Konfigurationseintrag wie folgt:

 {
     "name": "Python Debugger: startup.py",
     "type": "debugpy",
     "request": "launch",
     "program": "${workspaceFolder}/startup.py",
     "args" : ["--port", "1593"]
 },

name

Gibt den Namen der Debug-Konfiguration an, der in der VS Code-Dropdown-Liste angezeigt wird.

type

Identifiziert den zu verwendenden Debugger-Typ; lassen Sie diesen auf debugpy für das Debugging von Python-Code gesetzt.

request

Gibt den Modus an, in dem das Debugging gestartet werden soll

• launch: Startet den Debugger für die in program angegebene Datei.
• attach: Hängt den Debugger an einen bereits laufenden Prozess an. Siehe Remote-Debugging für ein Beispiel.

program

Gibt den vollständig qualifizierten Pfad zum Einstiegsmodul (Startdatei) des Python-Programms an. Der Wert ${file}, der oft in Standardkonfigurationen verwendet wird, verwendet die aktuell aktive Datei im Editor. Durch Angabe einer spezifischen Startdatei können Sie sicherstellen, dass Ihr Programm immer mit demselben Einstiegspunkt gestartet wird, unabhängig davon, welche Dateien geöffnet sind. Zum Beispiel:

"program": "/Users/Me/Projects/MyProject/src/event_handlers/__init__.py",

Sie können sich auch auf einen relativen Pfad vom Stammverzeichnis des Arbeitsbereichs verlassen. Wenn das Stammverzeichnis beispielsweise /Users/Me/Projects/MyProject ist, können Sie das folgende Beispiel verwenden:

"program": "${workspaceFolder}/src/event_handlers/__init__.py",

module

Bietet die Möglichkeit, den Namen eines zu debuggenden Moduls anzugeben, ähnlich dem Argument -m bei der Ausführung auf der Kommandozeile. Weitere Informationen finden Sie unter Python.org

python

Der vollständige Pfad, der auf den zu verwendenden Python-Interpreter für das Debugging verweist.

Wenn diese Einstellung nicht angegeben ist, wird standardmäßig der für Ihren Arbeitsbereich ausgewählte Interpreter verwendet, was der Verwendung des Werts ${command:python.interpreterPath} entspricht. Um einen anderen Interpreter zu verwenden, geben Sie stattdessen seinen Pfad in der Eigenschaft python einer Debug-Konfiguration an.

Alternativ können Sie eine benutzerdefinierte Umgebungsvariable verwenden, die auf jeder Plattform definiert ist, um den vollständigen Pfad zum zu verwendenden Python-Interpreter zu enthalten, sodass keine anderen Ordnerpfade erforderlich sind.

Wenn Sie Argumente an den Python-Interpreter übergeben müssen, können Sie die Eigenschaft pythonArgs verwenden.

pythonArgs

Gibt Argumente an, die an den Python-Interpreter übergeben werden sollen, mit der Syntax "pythonArgs": ["<arg 1>", "<arg 2>",...].

args

Gibt Argumente an, die an das Python-Programm übergeben werden sollen. Jedes Element der durch Leerzeichen getrennten Argumentzeichenkette sollte in Anführungszeichen eingeschlossen sein, z. B.:

"args": ["--quiet", "--norepeat", "--port", "1593"],

Wenn Sie unterschiedliche Argumente pro Debug-Lauf bereitstellen möchten, können Sie args auf "${command:pickArgs}" setzen. Dies fordert Sie jedes Mal auf, Argumente einzugeben, wenn Sie eine Debugging-Sitzung starten.

Hinweis: Es gibt einen Unterschied, wie "${command:pickArgs}" und ["${command:pickArgs}"] geparst werden, insbesondere in Bezug auf die Verwendung von []. Als Array werden alle Argumente als einzelner String übergeben, ohne Klammern wird jedes Argument als eigener String übergeben.

stopOnEntry

Wenn auf true gesetzt, stoppt der Debugger bei der ersten Zeile des zu debuggenden Programms. Wenn weggelassen (Standard) oder auf false gesetzt, führt der Debugger das Programm bis zum ersten Haltepunkt aus.

console

Gibt an, wie die Programmausgabe angezeigt wird, solange die Standardeinstellungen für redirectOutput nicht geändert werden.

purpose

Es gibt mehr als eine Möglichkeit, die Schaltfläche Ausführen zu konfigurieren, indem die Option purpose verwendet wird. Das Setzen der Option auf debug-test definiert, dass die Konfiguration beim Debuggen von Tests in VS Code verwendet werden soll. Das Setzen der Option auf debug-in-terminal definiert jedoch, dass die Konfiguration nur beim Zugriff auf die Schaltfläche Python-Datei ausführen oben rechts im Editor verwendet werden soll (unabhängig davon, ob die Optionen Python-Datei ausführen oder Python-Datei debuggen der Schaltfläche verwendet werden). Hinweis: Die Option purpose kann nicht verwendet werden, um den Debugger über F5 oder Ausführen > Debugging starten zu starten.

autoReload

Ermöglicht das automatische Neuladen des Debuggers, wenn Änderungen am Code vorgenommen werden, nachdem die Debugger-Ausführung einen Haltepunkt erreicht hat. Um diese Funktion zu aktivieren, setzen Sie {"enable": true}, wie im folgenden Code gezeigt.

{
  "name": "Python Debugger: Current File",
  "type": "debugpy",
  "request": "launch",
  "program": "${file}",
  "console": "integratedTerminal",
  "autoReload": {
    "enable": true
  }
}

Hinweis: Wenn der Debugger ein Neuladen durchführt, kann Code, der beim Import ausgeführt wird, erneut ausgeführt werden. Um diese Situation zu vermeiden, versuchen Sie, nur Imports, Konstanten und Definitionen in Ihrem Modul zu verwenden und den gesamten Code in Funktionen zu platzieren. Alternativ können Sie auch if __name__=="__main__"-Prüfungen verwenden.

subProcess

Gibt an, ob das Debugging von Unterprozessen aktiviert werden soll. Standardmäßig auf false gesetzt, auf true setzen, um es zu aktivieren. Weitere Informationen finden Sie unter Multi-Target-Debugging.

cwd

Gibt das aktuelle Arbeitsverzeichnis für den Debugger an, was der Basisordner für alle relativen Pfade ist, die im Code verwendet werden. Wenn weggelassen, wird standardmäßig ${workspaceFolder} (der in VS Code geöffnete Ordner) verwendet.

Als Beispiel: Angenommen, ${workspaceFolder} enthält einen Ordner py_code mit app.py und einen Ordner data mit salaries.csv. Wenn Sie den Debugger auf py_code/app.py starten, variieren die relativen Pfade zur Datendatei je nach Wert von cwd:

redirectOutput

Wenn auf true gesetzt (Standard für internalConsole), wird die gesamte Ausgabe des Programms in das VS Code-Debug-Ausgabefenster gedruckt. Wenn auf false gesetzt (Standard für integratedTerminal und externalTerminal), wird die Programmausgabe nicht im Debug-Ausgabefenster angezeigt.

Diese Option ist typischerweise deaktiviert, wenn "console": "integratedTerminal" oder "console": "externalTerminal" verwendet wird, da keine Notwendigkeit besteht, die Ausgabe in der Debug-Konsole zu duplizieren.

justMyCode

Wenn weggelassen oder auf true gesetzt (Standard), beschränkt sich das Debugging auf benutzergeschriebenen Code. Auf false setzen, um auch das Debugging von Standardbibliotheksfunktionen zu aktivieren.

django

Wenn auf true gesetzt, werden spezifische Debugging-Funktionen für das Django-Webframework aktiviert.

sudo

Wenn auf true gesetzt und mit "console": "externalTerminal" verwendet, ermöglicht das Debugging von Apps, die eine Erhöhung der Rechte erfordern. Die Verwendung einer externen Konsole ist notwendig, um das Passwort zu erfassen.

pyramid

Wenn auf true gesetzt, wird sichergestellt, dass eine Pyramid-App mit dem notwendigen Befehl pserve gestartet wird.

env

Legt optionale Umgebungsvariablen für den Debuggerprozess fest, zusätzlich zu den Systemumgebungsvariablen, die der Debugger immer erbt. Die Werte für diese Variablen müssen als Strings eingegeben werden.

envFile

Optionaler Pfad zu einer Datei, die Umgebungsvariablen-Definitionen enthält. Siehe Konfiguration von Python-Umgebungen – Umgebungsvariablen-Definitionsdatei.

gevent

Wenn auf true gesetzt, wird das Debugging von gevent monkey-patched code aktiviert.

jinja

Wenn auf true gesetzt, werden spezifische Debugging-Funktionen für das Jinja-Templating-Framework aktiviert.

Haltepunkte und Logpunkte

Die Python-Debugger-Erweiterung unterstützt Haltepunkte und Logpunkte für das Debugging von Code. Eine kurze Einführung in grundlegende Debugging-Schritte und die Verwendung von Haltepunkten finden Sie im Tutorial – Konfigurieren und Ausführen des Debuggers.

Bedingte Haltepunkte

Haltepunkte können auch so eingestellt werden, dass sie basierend auf Ausdrücken, Trefferzahlen oder einer Kombination aus beidem ausgelöst werden. Die Python-Debugger-Erweiterung unterstützt Trefferzahlen, die ganze Zahlen sind, sowie ganze Zahlen, denen ==, >, >=, <, <= und % vorangestellt sind. Sie könnten beispielsweise einen Haltepunkt so einrichten, dass er nach fünf Vorkommnissen ausgelöst wird, indem Sie eine Trefferzahl von >5 setzen. Weitere Informationen finden Sie unter bedingte Haltepunkte im Hauptartikel zu VS Code-Debugging.

Aufrufen eines Haltepunkts im Code

In Ihrem Python-Code können Sie debugpy.breakpoint() an jeder Stelle aufrufen, an der Sie den Debugger während einer Debugging-Sitzung anhalten möchten.

Haltepunkt-Validierung

Die Python-Debugger-Erweiterung erkennt automatisch Haltepunkte, die auf nicht ausführbaren Zeilen gesetzt sind, wie z. B. pass-Anweisungen oder die Mitte einer mehrzeiligen Anweisung. In solchen Fällen verschiebt das Ausführen des Debuggers den Haltepunkt zur nächstgelegenen gültigen Zeile, um sicherzustellen, dass die Codeausführung an dieser Stelle stoppt.

Debugging spezifischer App-Typen

Die Konfigurationsdropdown bietet verschiedene Optionen für allgemeine App-Typen.

Für Remote-Debugging und Google App Engine sind ebenfalls spezifische Schritte erforderlich. Details zum Debuggen von Tests finden Sie unter Tests.

Um eine App zu debuggen, die Administratorrechte benötigt, verwenden Sie "console": "externalTerminal" und "sudo": "True".

Flask-Debugging

{
    "name": "Python Debugger: Flask",
    "type": "debugpy",
    "request": "launch",
    "module": "flask",
    "env": {
        "FLASK_APP": "app.py"
    },
    "args": [
        "run",
        "--no-debugger"
    ],
    "jinja": true
},

Wie Sie sehen, gibt diese Konfiguration "env": {"FLASK_APP": "app.py"} und "args": ["run", "--no-debugger"] an. Die Eigenschaft "module": "flask" wird anstelle von program verwendet. (Sie sehen möglicherweise "FLASK_APP": "${workspaceFolder}/app.py" in der env-Eigenschaft. In diesem Fall ändern Sie die Konfiguration so, dass sie sich nur auf den Dateinamen bezieht. Andernfalls sehen Sie möglicherweise Fehler wie "Cannot import module C", wobei C ein Laufwerksbuchstabe ist.)

Die Einstellung "jinja": true aktiviert auch das Debuggen für die standardmäßige Jinja-Templating-Engine von Flask.

Wenn Sie den Entwicklungsserver von Flask im Entwicklungsmodus ausführen möchten, verwenden Sie die folgende Konfiguration

{
    "name": "Python Debugger: Flask (development mode)",
    "type": "debugpy",
    "request": "launch",
    "module": "flask",
    "env": {
        "FLASK_APP": "app.py",
        "FLASK_ENV": "development"
    },
    "args": [
        "run"
    ],
    "jinja": true
},

Fehlerbehebung

Es gibt viele Gründe, warum der Debugger möglicherweise nicht funktioniert. Manchmal deckt die Debug-Konsole spezifische Ursachen auf, aber die Hauptgründe sind folgende:

• Stellen Sie sicher, dass die Python Debugger-Erweiterung in VS Code installiert und aktiviert ist. Öffnen Sie dazu die Ansicht Erweiterungen (⇧⌘X (Windows, Linux Ctrl+Shift+X)) und suchen Sie nach @installed python debugger.

• Der Pfad zur Python-Executable ist falsch: Überprüfen Sie den Pfad Ihres ausgewählten Interpreters, indem Sie den Befehl Python: Interpreter auswählen ausführen und den aktuellen Wert betrachten.

  

• Sie haben "type" in Ihrer launch.json-Datei auf den veralteten Wert "python" gesetzt: Ersetzen Sie "python" durch "debugpy", um mit der Python Debugger-Erweiterung zu arbeiten.

• Es gibt ungültige Ausdrücke im Überwachungsfenster: Löschen Sie alle Ausdrücke aus dem Überwachungsfenster und starten Sie den Debugger neu.

• Wenn Sie mit einer Multi-Thread-App arbeiten, die native Thread-APIs verwendet (wie die Win32 CreateThread-Funktion anstelle der Python-Threading-APIs), ist es derzeit erforderlich, den folgenden Quellcode am Anfang der Datei einzufügen, die Sie debuggen möchten.

  import debugpy
  debugpy.debug_this_thread()
  

• Wenn Sie mit einem Linux-System arbeiten, erhalten Sie möglicherweise die Fehlermeldung "timed out" (Zeitüberschreitung), wenn Sie versuchen, einen Debugger auf einen laufenden Prozess anzuwenden. Um dies zu verhindern, können Sie den folgenden Befehl vorübergehend ausführen.

  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
  

Nächste Schritte

• Python-Umgebungen - Steuert, welcher Python-Interpreter zum Bearbeiten und Debuggen verwendet wird.
• Testen - Konfigurieren Sie Testumgebungen und entdecken, führen Sie Tests aus und debuggen Sie sie.
• Einstellungenreferenz – Erkunden Sie die gesamte Bandbreite der Python-bezogenen Einstellungen in VS Code.
• Allgemeines Debugging – Erfahren Sie mehr über die Debugging-Funktionen von VS Code.