Visual Studio Code bietet uns Programmierern das ein oder andere Bequemlichkeitsfeature. Eines davon ist die Anbindung an das Projekt Jupyter.

In diesem Tutorial lernst du, wie du Jupyter in VS Code verwendest und welche Möglichkeiten du dadurch erhältst deinen Quellcode einfacher zu debuggen.

Was ist Jupyter

Das Jupyter Projekt erlaubt dir sogenannte Jupyter Notebooks zu erstellen. In diesen Notebooks kannst du langen Quellcode in Quellcodeblöcke aufteilen und unabhängig voneinander ausführen. Nachdem du einen Block ausgeführt hast, bleiben alle Variablen, die in diesem Block verändert wurden, verändert. Dadurch kannst du das ganze Programm ausführen, indem du alle Blöcke hintereinander ausführst.

Das hilft vor allem beim debuggen von Codeteilen in größeren Projekten, da du nicht für jeden Fehler den kompletten Quellcode von Neuem ausführen musst. Stattdessen kannst du nur den Teil ausführen, den du testen willst.

Juptyter unterstützt nicht nur Python, sondern auch andere Sprachen wie Julia, R, Scala und weiteren. In diesem Beitrag werde ich mich auf Python beschränken, da es die Installation mithilfe von pip sehr leicht macht und das Interaktive Fenster explizit für Python entwickelt wurde. Allerdings gibt es mittlerweile schon Adaptionen für andere Sprachen.

Installation Jupyterlab

Nachdem du Python installiert hast, kannst du Jupyterlab mit pip nachinstallieren. Jupyterlab ist die neue Weboberfläche, mit der du auf die Funktionen von Jupyter zugreifen kannst. Jupyterlab ersetzt damit das alte Tool “Jupyter Notebook”.

Mit folgendem Befehl wird Jupyterlab sowie die benötigten Pakete wie etwa jupyter-core und jupyter-client installiert.

pip install jupyterlab

Danach solltest du Jupyterlab starten können.

jupyter lab

Hinweis: Falls du pip nur für deinen Benutzer (nicht als Admin) ausgeführt oder du das --user Argument verwendent hast, kann es sein, dass dieser Befehl fehlschlägt:

Der Befehl "jupyter" ist entweder falsch geschrieben oder konnte nicht gefunden werden.

In dem Fall musst du den Userpfad in deine PATH Variable hinzufügen. Bei mir war der Pfad unter Windows C:\Users\Quisl\AppData\Roaming\Python\Python39\Scripts. Einen Hinweis auf deinen Pfad findest du mit folgendem Befehl.

python -c "import site; print(site.USER_BASE)"

C:\Users\Quisl\AppData\Roaming\Python

In Jupyterlab kannst du dich im Browser schon ein wenig mit den Codeblöcken von Jupyter vertraut machen. Aber wir wollen schließlich nicht im Browser, sondern in VS Code programmieren.

Jupyter in VS Code

Glücklicherweise kannst du diese Codeblöcke auch direkt in Visual Studio Code anzeigen und bearbeiten. Dazu stellt VS Code mithilfe der Jupyter Erweiterung zwei Möglichkeiten bereit: über Jupyter Notebooks und über das Interaktive Fenster.

Ich benutze neben der Jupyter Erweiterung übrigens noch zwei weitere Erweiterungen für Jupyter: Jupyter Keymap und Jupyter Notebook Renderers. Dazu später mehr.

Installation Jupyter in VS Code

Wenn du VS Code offen hast, kannst du die Jupyter Erweiterung im Erweiterungstab (STRG+Umschalt+X) installieren. Such dazu einfach nach “jupyter” und installiere das Paket.

Variante 1: Jupyter Notebook (mit .ipynb)

Um ein Jupyter Notebook direkt in Visual Studio zu erstellen, kannst du mit STRG+Umschalt+P folgendes VS Code Kommando ausführen.

Jupyter: Create New Jupyter Notebook

Danach verwandelt sich der Texteditor von VS Code in eine Codeblockoberfläche, ähnlich wie du sie von Jupyter Notebooks bzw. Jupyterlabs kennst. Über die Buttons kannst du Codeblöcke sowie Markdownblöcke für Kommentare hinzufügen.

Pro Tipp: Einzelne Blöcke kannst du - nachdem du sie mit einem Mausklick in den Fokus gebracht hast - auch mit der Tastenkombination Umschalt+Enter ausführen. Danach springt der Fokus automatisch auf den nächsten Block weiter.

Wenn du deine Datei speicherst, wird die Datei als Jupyternotebookdatei mit der Endung .ipynb abgespeichert. Das ist von Nachteil, wenn du eigentlich ein Script schreiben und mit Jupyter nur debuggen wolltest. Denn der Pythoninterpreter kann dieses Dateiformat nicht lesen. Deswegen musst du deinen Quellcode mit einem letzten Schritt wieder in eine .py Datei exportieren.

Der Vorteil von Jupyternotebookdateien ist, dass sie die letzten Zwischenergebnisse in der Datei speichern. Dieses Verhalten ist im Data Science Bereich unter Umständen genau das gewünschte. Falls du allerdings nur debuggen wolltest ist es etwas nervig. Daher kann ich dir das Interaktive Fenster in VS Code empfehlen.

Variante 2: Interaktives Fenster (mit .py)

Mit dem Interaktiven Fenster, kannst du jedes Pythonscript in Blöcke unterteilen (so wie es sonst nur mit Jupyternotebook Dateien geht) ohne die Programmlogik oder gar das Dateiformat zu ändern. Um einen Block zu erzeugen, brauchst du ihn nur mit den Zeichen # %% zu definieren. Beispiel:

# %%
msg = "Hello World"
print(msg)

# %%
msg = "Hello again"
print(msg)

Diese Blöcke können mit Shift+Enter oder mit dem “Run Cell” Knopf ausgeführt werden. Beim Ausführen startet das interaktive Fenster automatisch auf der rechten Seite neben deinem Quellcode. Dort siehst du dann auch die Kommandozeilenausgaben deines Programms.

Da die Blöcke über Kommentare definiert werden bleibt deine .py Datei weiterhin von Python ausführbar.

Ein weiterer Vorteil gegenüber der Notebookvariante ist, dass du deinen Text mit allen Erweiterungen und deinem gewohnten Syntaxhighlighting editieren kannst. Vor allem, wenn du noch andere Erweiterungen verwendest, ist dies sehr angenehm.

Erweiterung: Jupyter Keymap

Mit Jupyter Keymap kannst du deine gewohnten Hotkeys auch in Jupyter Notebooks verwenden. Das funktioniert auch mit der Vim Erweiterung zusammen.

Erweiterung: Jupyter Notebook Renderers

Die Jupyter Renderers Erweiterung macht, dass du Bilder direkt in VS Code anzeigen kannst. In der browserbasierten Variante von Jupyter funktioniert das von Haus aus.


Konnte ich helfen? Ich freue mich über einen Drink! 💙