JupyterLab installieren und starten: Die vollständige Anleitung

Name

Soren Atelier

Updated on 13.2.2026

Eine Python-Entwicklungsumgebung für Data Science einzurichten sollte einfach sein, doch neue Benutzer stoßen häufig auf Hindernisse: widersprüchliche Paketmanager, fehlerhafte PATH-Variablen, Berechtigungsfehler und verwirrende Ratschläge aus veralteten Forenbeiträgen. Eine falsch konfigurierte Installation kann Stunden kosten, bevor man eine einzige Zeile Code schreibt.

Die Frustration steigt, wenn Jupyter-Befehle ohne Rückmeldung fehlschlagen, Kernel sich nicht verbinden oder der Browser sich nicht öffnet. Selbst erfahrene Entwickler stoßen auf Probleme, wenn sie den Rechner wechseln oder Remote-Server einrichten. Ohne eine klare Referenz fühlt sich der Prozess, JupyterLab zum Laufen zu bringen, schwieriger an als nötig.

Diese Anleitung löst genau das. Sie behandelt die Installation von JupyterLab mit pip und conda, das Starten von JupyterLab auf allen gängigen Betriebssystemen und die Konfiguration für produktives Arbeiten. Ob Sie JupyterLab zum ersten Mal öffnen oder eine fehlerhafte Installation beheben -- folgen Sie diesen Schritten und Sie haben in wenigen Minuten eine funktionierende Umgebung.

Was ist JupyterLab?

JupyterLab ist die webbasierte interaktive Entwicklungsumgebung der nächsten Generation von Project Jupyter. Es ersetzt die klassische Jupyter-Notebook-Oberfläche durch einen modularen, erweiterbaren Arbeitsbereich, in dem Sie Notebooks bearbeiten, Skripte schreiben, ein Terminal verwenden, Dateien durchsuchen und Datenausgaben anzeigen können -- alles in einem einzigen Browserfenster.

Wichtige Funktionen von JupyterLab umfassen:

• Multi-Panel-Layout: Öffnen Sie Notebooks, Terminals, CSV-Vorschauen und Dokumentation nebeneinander mit Drag-and-Drop-Anordnung.
• Integrierter Dateibrowser: Navigieren Sie durch Projektverzeichnisse, erstellen Sie Ordner, laden Sie Dateien hoch und benennen Sie Ressourcen um, ohne die Oberfläche zu verlassen.
• Integriertes Terminal: Führen Sie Shell-Befehle direkt in JupyterLab aus, ohne zu einem externen Terminal wechseln zu müssen.
• Rich-Text-Bearbeitung: Bearbeiten Sie Markdown-Dateien mit Live-Vorschau, arbeiten Sie mit JSON und zeigen Sie Bilder nativ an.
• Erweiterungssystem: Fügen Sie Funktionen wie Git-Integration, Code-Formatierung, Language-Server-Unterstützung und benutzerdefinierte Themes über pip-installierbare Erweiterungen hinzu.
• Mehrfache Kernel-Unterstützung: Führen Sie Python, R, Julia und andere Sprach-Kernel im selben Arbeitsbereich aus.

JupyterLab ist die Standardoberfläche moderner Jupyter-Installationen. Wenn Sie jupyter lab ausführen, wird die JupyterLab-Oberfläche gestartet. Es ist die empfohlene Umgebung für Data Science, maschinelles Lernen, wissenschaftliches Rechnen und interaktive Python-Entwicklung im Jahr 2026.

JupyterLab vs. Jupyter Notebook

Viele Benutzer fragen sich, ob sie JupyterLab oder das klassische Jupyter Notebook verwenden sollten. Die kurze Antwort: JupyterLab ist der moderne Nachfolger. Das Jupyter-Team hat JupyterLab als primäre Oberfläche für die Zukunft bestimmt, und Jupyter Notebook 7 basiert jetzt auf derselben Technologie (JupyterLab-Komponenten).

Hier ist ein direkter Vergleich:

Wann JupyterLab wählen: Für jedes neue Projekt. Es bietet alles, was Jupyter Notebook bietet, plus einen leistungsfähigeren Arbeitsbereich. Wenn Sie mit mehreren Dateien arbeiten, ein Terminal benötigen oder Erweiterungen nutzen möchten, ist JupyterLab die klare Wahl.

Wann beim Notebook bleiben: Wenn Sie Legacy-Tools verwenden, die nur die klassische Notebook-Oberfläche unterstützen, oder wenn Sie die absolut einfachste Benutzeroberfläche für Einführungskurse in die Programmierung benötigen.

JupyterLab installieren

Vor der Installation von JupyterLab benötigen Sie Python 3.8 oder höher und einen Paketmanager (pip oder conda). Die folgenden Abschnitte behandeln jeden gängigen Installationsweg.

JupyterLab mit pip installieren (Empfohlen)

pip ist der Standard-Paketmanager für Python und der schnellste Weg zur Installation von JupyterLab. Öffnen Sie Ihr Terminal (Eingabeaufforderung oder PowerShell unter Windows, Terminal unter macOS/Linux) und führen Sie aus:

pip install jupyterlab

Dieser Befehl lädt die neueste stabile Version von JupyterLab zusammen mit allen erforderlichen Abhängigkeiten herunter und installiert sie. Um die Installation zu überprüfen:

jupyter lab --version

Sie sollten eine Versionsausgabe wie 4.3.x oder höher sehen. Falls pip nicht erkannt wird, müssen Sie möglicherweise pip3 verwenden:

pip3 install jupyterlab

Um eine bestehende JupyterLab-Installation auf die neueste Version zu aktualisieren:

pip install --upgrade jupyterlab

JupyterLab mit Conda installieren (Anaconda/Miniconda)

Wenn Sie Anaconda oder Miniconda zur Paketverwaltung verwenden, installieren Sie JupyterLab über den conda-forge-Kanal:

conda install -c conda-forge jupyterlab

Dieser Ansatz ist bei Data Scientists beliebt, da conda sowohl Python-Pakete als auch Nicht-Python-Abhängigkeiten (wie C-Bibliotheken) verwaltet, die einige wissenschaftliche Pakete benötigen.

Um JupyterLab in einer dedizierten conda-Umgebung zu installieren:

conda create --name jupyter-env python=3.12
conda activate jupyter-env
conda install -c conda-forge jupyterlab

Überprüfen Sie die Installation:

jupyter lab --version

Windows-Installation Schritt für Schritt

Folgen Sie diesen Schritten, um JupyterLab unter Windows von Grund auf zu installieren:

Schritt 1: Python installieren

Laden Sie den neuesten Python-Installer von python.org/downloads (opens in a new tab) herunter. Aktivieren Sie während der Installation das Kontrollkästchen "Add Python to PATH" -- das ist entscheidend. Ohne diese Option funktionieren die Befehle python und pip nicht in Ihrem Terminal.

Schritt 2: Terminal öffnen

Drücken Sie Win + R, geben Sie cmd ein und drücken Sie Enter. Alternativ suchen Sie nach "PowerShell" im Startmenü.

Schritt 3: Python und pip überprüfen

python --version
pip --version

Beide Befehle sollten Versionsnummern zurückgeben. Wenn python nicht erkannt wird, installieren Sie Python erneut mit aktiviertem PATH-Kontrollkästchen.

Schritt 4: JupyterLab installieren

pip install jupyterlab

Schritt 5: JupyterLab starten

jupyter lab

Ihr Standard-Webbrowser öffnet sich automatisch mit der JupyterLab-Oberfläche.

macOS-Installation

macOS wird bei den meisten Versionen mit Python ausgeliefert, aber das System-Python ist oft veraltet. Verwenden Sie Homebrew oder pyenv für eine saubere Einrichtung.

Option A: Mit Homebrew

brew install python
pip3 install jupyterlab

Option B: Mit dem offiziellen Installer

Laden Sie Python von python.org/downloads (opens in a new tab) herunter und führen Sie den .pkg-Installer aus. Dann:

pip3 install jupyterlab

Option C: Mit pyenv

brew install pyenv
pyenv install 3.12
pyenv global 3.12
pip install jupyterlab

JupyterLab starten:

jupyter lab

Linux (Ubuntu/Debian) Installation

Die meisten Linux-Distributionen enthalten Python 3 standardmäßig. Installieren Sie pip und JupyterLab:

sudo apt update
sudo apt install python3 python3-pip python3-venv
pip3 install jupyterlab

Unter Fedora/RHEL:

sudo dnf install python3 python3-pip
pip3 install jupyterlab

Unter Arch Linux:

sudo pacman -S python python-pip
pip install jupyterlab

Wenn Ihre Distribution pip-Installationen auf Systemebene einschränkt (PEP 668), erstellen Sie zuerst eine virtuelle Umgebung:

python3 -m venv ~/jupyter-env
source ~/jupyter-env/bin/activate
pip install jupyterlab
jupyter lab

JupyterLab starten

Sobald JupyterLab installiert ist, genügt ein einziger Befehl zum Starten. Dieser Abschnitt behandelt alle Möglichkeiten, JupyterLab zu starten und zu konfigurieren.

Einfacher Start

Öffnen Sie Ihr Terminal und führen Sie aus:

jupyter lab

JupyterLab startet einen lokalen Webserver (typischerweise auf Port 8888) und öffnet die Oberfläche in Ihrem Standardbrowser. Das Terminal zeigt eine URL mit einem Authentifizierungstoken an:

http://localhost:8888/lab?token=abc123...

Lassen Sie das Terminal geöffnet, während Sie arbeiten. Wenn Sie es schließen, wird der JupyterLab-Server heruntergefahren.

JupyterLab in einem bestimmten Verzeichnis starten

Standardmäßig öffnet JupyterLab das Verzeichnis, in dem Sie den Befehl ausgeführt haben. Um es in einem bestimmten Projektordner zu starten:

jupyter lab --notebook-dir=/pfad/zu/ihrem/projekt

Unter Windows:

jupyter lab --notebook-dir=C:\Users\IhrName\Projekte\datenanalyse

Dies ist nützlich, wenn Sie den JupyterLab-Dateibrowser auf ein bestimmtes Projekt fokussieren möchten.

Benutzerdefinierten Port verwenden

Wenn Port 8888 bereits belegt ist, geben Sie einen anderen Port an:

jupyter lab --port=9999

JupyterLab ist dann unter http://localhost:9999/lab verfügbar.

Ohne Browseröffnung starten

Um den Server zu starten, ohne automatisch ein Browserfenster zu öffnen:

jupyter lab --no-browser

Dies ist nützlich auf Remote-Servern oder wenn Sie die URL lieber manuell aufrufen möchten. Kopieren Sie die URL aus der Terminal-Ausgabe und fügen Sie sie in einen beliebigen Browser ein.

JupyterLab in einem bestimmten Browser öffnen

Um JupyterLab in einem bestimmten Browser zu öffnen:

jupyter lab --browser=firefox

oder

jupyter lab --browser=chrome

JupyterLab auf allen Netzwerkschnittstellen starten

Um auf JupyterLab von anderen Geräten im selben Netzwerk zuzugreifen (z. B. einem Remote-Server):

jupyter lab --ip=0.0.0.0 --port=8888 --no-browser

Verbinden Sie sich dann von einem anderen Rechner über die IP-Adresse des Servers.

Übersicht der Startbefehle

JupyterLab verwenden

Nachdem Sie JupyterLab geöffnet haben, zeigt die Oberfläche einen Launcher-Tab mit Optionen zum Erstellen neuer Notebooks, Öffnen einer Konsole, Starten eines Terminals oder Erstellen von Textdateien. Dieser Abschnitt behandelt grundlegende Arbeitsabläufe.

Notebooks erstellen und ausführen

1. Klicken Sie auf Python 3 im Bereich "Notebook" des Launchers, oder gehen Sie zu File > New > Notebook.
2. Wählen Sie einen Kernel, wenn Sie dazu aufgefordert werden (normalerweise "Python 3").
3. Ein neues .ipynb-Notebook öffnet sich mit einer leeren Codezelle.

Geben Sie Python-Code in die Zelle ein und drücken Sie Shift + Enter, um ihn auszuführen. Die Ausgabe erscheint direkt unter der Zelle.

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Score': [85, 92, 78]
})
df

Mit Zellen arbeiten

JupyterLab-Notebooks verwenden zwei Hauptzelltypen:

Codezellen: Führen Python-Code (oder Code einer anderen Kernel-Sprache) aus. Ergebnisse werden inline angezeigt.

Markdown-Zellen: Schreiben Sie formatierten Text mit Markdown-Syntax. Ändern Sie den Zelltyp über das Dropdown-Menü in der Symbolleiste oder drücken Sie M im Befehlsmodus.

Um eine neue Zelle hinzuzufügen, klicken Sie auf die +-Schaltfläche in der Symbolleiste oder drücken Sie B (darunter) oder A (darüber) im Befehlsmodus. Löschen Sie eine Zelle, indem Sie D zweimal im Befehlsmodus drücken.

Tastenkürzel

JupyterLab hat zwei Modi: Befehlsmodus (Escape drücken, blauer Zellenrand) und Bearbeitungsmodus (Enter drücken, grüner Zellenrand). Hier sind die nützlichsten Tastenkürzel:

Sie können Tastenkürzel über Settings > Advanced Settings Editor > Keyboard Shortcuts anpassen.

Den Dateibrowser verwenden

Die linke Seitenleiste enthält einen Dateibrowser, der den Inhalt des Verzeichnisses anzeigt, in dem JupyterLab gestartet wurde. Sie können:

• Ordner durch Klicken navigieren
• Neue Dateien und Ordner über das Rechtsklick-Kontextmenü erstellen
• Dateien durch Hineinziehen in den Browser hochladen
• Dateien per Rechtsklick > Rename umbenennen
• Dateien per Rechtsklick > Delete löschen

Integriertes Terminal

Um ein Terminal in JupyterLab zu öffnen, gehen Sie zu File > New > Terminal oder klicken Sie auf Terminal im Launcher. Dies gibt Ihnen eine vollständige Shell (bash, zsh oder PowerShell, abhängig von Ihrem Betriebssystem), ohne die JupyterLab-Oberfläche zu verlassen.

Das integrierte Terminal ist nützlich für:

• Pakete mit pip oder conda installieren
• Skripte ausführen
• Git-Befehle verwenden
• Dateien verwalten

Mehrere Panels und geteilte Ansicht

JupyterLab unterstützt Arbeitsabläufe mit geteiltem Bildschirm. Ziehen Sie einen beliebigen Tab (Notebook, Terminal, Datei) an den Rand des Arbeitsbereichs, um ein nebeneinander liegendes Layout zu erstellen. Sie können Panels horizontal oder vertikal anordnen.

Gängige Konfigurationen für geteilte Ansichten:

• Notebook + Terminal: Code in einem Notebook schreiben, während Befehle im Terminal ausgeführt werden
• Zwei Notebooks: Ergebnisse nebeneinander vergleichen
• Notebook + CSV-Vorschau: Datendateien beim Programmieren anzeigen
• Notebook + Markdown-Vorschau: Dokumentation mit Live-Vorschau schreiben

JupyterLab Fehlerbehebung

Dies sind die häufigsten Probleme, auf die Benutzer beim Versuch, JupyterLab auszuführen, stoßen, zusammen mit ihren Lösungen.

"jupyter: command not found"

Dies bedeutet, dass die ausführbare Datei jupyter nicht in Ihrem System-PATH liegt. Häufige Lösungen:

Prüfen, ob JupyterLab installiert ist:

pip show jupyterlab

Wenn nichts angezeigt wird, installieren Sie es:

pip install jupyterlab

Den vollständigen Python-Modulpfad verwenden:

python -m jupyter lab

Das pip-Skriptverzeichnis zum PATH hinzufügen (häufig unter Linux/macOS):

export PATH="$HOME/.local/bin:$PATH"

Fügen Sie diese Zeile Ihrer ~/.bashrc oder ~/.zshrc hinzu, um sie dauerhaft zu machen.

Windows: Wenn Sie Python ohne "Add to PATH" installiert haben, installieren Sie Python erneut mit aktivierter Option, oder fügen Sie manuell C:\Users\IhrName\AppData\Local\Programs\Python\Python312\Scripts zu Ihrem System-PATH hinzu.

Port bereits belegt

Wenn Sie "OSError: [Errno 98] Address already in use" sehen:

jupyter lab --port=8889

Oder finden und stoppen Sie den bestehenden Jupyter-Prozess:

jupyter lab list
jupyter lab stop 8888

Unter Linux/macOS können Sie auch den Prozess finden, der den Port belegt:

lsof -i :8888
kill -9 <PID>

Berechtigungsfehler

Wenn die pip-Installation mit Berechtigungsfehlern fehlschlägt, vermeiden Sie sudo pip install. Verwenden Sie stattdessen das --user-Flag:

pip install --user jupyterlab

Oder verwenden Sie besser eine virtuelle Umgebung (wird weiter unten behandelt).

Kernel nicht gefunden

Wenn Ihr Notebook "Kernel not found" anzeigt oder der Python-Kernel fehlt:

pip install ipykernel
python -m ipykernel install --user

Für einen Kernel in einer virtuellen Umgebung:

python -m ipykernel install --user --name=myenv --display-name="Python (myenv)"

JupyterLab öffnet sich nicht im Browser

Wenn der Server startet, aber kein Browserfenster erscheint:

1. Kopieren Sie die URL aus der Terminal-Ausgabe (einschließlich des Tokens).
2. Fügen Sie sie direkt in Ihren Browser ein.
3. Wenn Sie auf einem Remote-Server arbeiten, verwenden Sie SSH-Portweiterleitung:

ssh -L 8888:localhost:8888 user@remote-server

Öffnen Sie dann http://localhost:8888/lab auf Ihrem lokalen Rechner.

JupyterLab zeigt eine leere Seite

Leeren Sie den Browser-Cache oder versuchen Sie einen anderen Browser. Sie können auch den JupyterLab-Arbeitsbereich zurücksetzen:

jupyter lab --LabApp.default_url='/lab?reset'

JupyterLab-Erweiterungen

JupyterLab 4.x verwendet ein vereinfachtes Erweiterungssystem, bei dem die meisten Erweiterungen über pip installiert werden, ohne dass Node.js erforderlich ist. Hier sind die nützlichsten Erweiterungen für Data-Science-Arbeit.

jupyterlab-git

Vollständige Git-Integration in JupyterLab. Diffs anzeigen, Änderungen stagen, committen, pushen und pullen, ohne die Oberfläche zu verlassen.

pip install jupyterlab-git

Nach der Installation erscheint ein Git-Tab in der linken Seitenleiste.

jupyterlab-lsp

Language-Server-Protocol-Unterstützung, die Autovervollständigung, Hover-Dokumentation, Gehe-zu-Definition und Linting für Python und andere Sprachen hinzufügt.

pip install jupyterlab-lsp python-lsp-server[all]

jupyterlab_code_formatter

Automatische Formatierung von Codezellen mit Formatierern wie black oder isort.

pip install jupyterlab-code-formatter black isort

Nach der Installation formatieren Sie Zellen über die Symbolleisten-Schaltfläche oder ein Tastenkürzel.

Theme-Erweiterungen

Passen Sie das JupyterLab-Erscheinungsbild an:

pip install jupyterlab_darkside_ui    # Dunkles Theme
pip install jupyterlab-night          # Nacht-Theme

Wechseln Sie Themes über Settings > Theme.

Erweiterungen verwalten

Alle installierten Erweiterungen auflisten:

jupyter labextension list

Eine Erweiterung deinstallieren:

pip uninstall jupyterlab-git

Datenvisualisierung auf das nächste Level bringen: PyGWalker

JupyterLab ist eine leistungsstarke Umgebung zum Schreiben und Ausführen von Code, aber interaktive Datenvisualisierung erfordert oft das Schreiben von sich wiederholendem Plot-Code. PyGWalker ist eine Open-Source-Python-Bibliothek, die jeden pandas- oder polars-DataFrame in eine Tableau-ähnliche interaktive Visualisierungsoberfläche direkt in JupyterLab verwandelt.

Anstatt für jedes Diagramm matplotlib- oder seaborn-Code zu schreiben, können Sie Ihre Daten visuell mit Drag-and-Drop erkunden:

pip install pygwalker

import pygwalker as pyg
import pandas as pd
 
df = pd.read_csv("your_data.csv")
pyg.walk(df)

Dieser einzelne Befehl rendert eine interaktive Oberfläche, in der Sie Balkendiagramme, Streudiagramme, Histogramme, Heatmaps und mehr erstellen können, ohne Plot-Code zu schreiben. Es unterstützt Filterung, Aggregation und mehrere Diagrammtypen -- ideal für explorative Datenanalyse in JupyterLab.

Erfahren Sie mehr unter github.com/Kanaries/pygwalker (opens in a new tab).

Wenn Sie noch weiter mit KI-gestützter Automatisierung in Jupyter gehen möchten, schauen Sie sich RunCell (www.runcell.dev (opens in a new tab)) an -- ein KI-Agent, der in Jupyter läuft und repetitive Notebook-Aufgaben wie Datenbereinigung, Feature Engineering und Visualisierung automatisiert. Er versteht Ihren Datenkontext und generiert Codezellen für Sie.

JupyterLab in einer virtuellen Umgebung einrichten

JupyterLab in einer virtuellen Umgebung auszuführen ist die empfohlene Vorgehensweise. Es hält Ihre Projektabhängigkeiten isoliert und vermeidet Konflikte mit anderen Python-Installationen.

Mit Python venv

# Create a virtual environment
python -m venv jupyter-env
 
# Activate it
# macOS/Linux:
source jupyter-env/bin/activate
# Windows:
jupyter-env\Scripts\activate
 
# Install JupyterLab
pip install jupyterlab
 
# Start JupyterLab
jupyter lab

Wenn Sie mit der Arbeit fertig sind, deaktivieren Sie die Umgebung:

deactivate

Mit virtualenv

pip install virtualenv
virtualenv jupyter-env
source jupyter-env/bin/activate   # macOS/Linux
pip install jupyterlab
jupyter lab

Mit Conda-Umgebungen

conda create --name jupyter-env python=3.12
conda activate jupyter-env
conda install -c conda-forge jupyterlab
jupyter lab

Eine virtuelle Umgebung als Kernel verfügbar machen

Wenn Sie JupyterLab global installiert haben, aber Pakete aus einer virtuellen Umgebung verwenden möchten, registrieren Sie die Umgebung als Kernel:

# Inside the activated virtual environment:
pip install ipykernel
python -m ipykernel install --user --name=jupyter-env --display-name="Python (jupyter-env)"

Wenn Sie jetzt ein neues Notebook in JupyterLab erstellen, können Sie "Python (jupyter-env)" als Kernel auswählen.

JupyterLab mit Docker ausführen

Docker bietet eine saubere, reproduzierbare Möglichkeit, JupyterLab auszuführen, ohne etwas auf Ihrem Hostsystem zu installieren. Das Jupyter-Projekt pflegt offizielle Docker-Images.

Schnellstart

docker run -p 8888:8888 jupyter/base-notebook

Dies lädt das Basis-Jupyter-Image herunter und führt es aus. Die Terminal-Ausgabe enthält eine URL mit einem Token. Öffnen Sie diese URL in Ihrem Browser.

Ein lokales Verzeichnis einbinden

Um auf Ihre lokalen Dateien innerhalb des Containers zuzugreifen:

docker run -p 8888:8888 -v /pfad/zu/ihrem/projekt:/home/jovyan/work jupyter/base-notebook

Unter Windows:

docker run -p 8888:8888 -v C:\Users\IhrName\projekt:/home/jovyan/work jupyter/base-notebook

Verfügbare Docker-Images

Benutzerdefiniertes Dockerfile

Erstellen Sie ein Dockerfile für eine projektspezifische JupyterLab-Umgebung:

FROM jupyter/scipy-notebook:latest
 
# Install additional packages
RUN pip install pygwalker seaborn scikit-learn
 
# Set the working directory
WORKDIR /home/jovyan/work
 
# Expose the Jupyter port
EXPOSE 8888
 
CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

Erstellen und ausführen:

docker build -t my-jupyter .
docker run -p 8888:8888 -v $(pwd):/home/jovyan/work my-jupyter

Docker Compose

Für Projekte, die JupyterLab mit anderen Diensten kombinieren (Datenbanken, APIs):

version: '3'
services:
  jupyter:
    image: jupyter/scipy-notebook
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - JUPYTER_ENABLE_LAB=yes

docker compose up

Mehrere Python-Kernel verwalten

Wenn Sie an mehreren Projekten mit verschiedenen Python-Versionen oder Paketsets arbeiten, können Sie jede Umgebung als separaten Kernel in JupyterLab registrieren.

Einen Kernel aus einer virtuellen Umgebung hinzufügen

# Create and activate a new environment
python -m venv ml-project
source ml-project/bin/activate    # macOS/Linux
ml-project\Scripts\activate       # Windows
 
# Install the required packages
pip install ipykernel numpy pandas scikit-learn
 
# Register this environment as a Jupyter kernel
python -m ipykernel install --user --name=ml-project --display-name="Python (ML Project)"

Einen Kernel aus einer Conda-Umgebung hinzufügen

conda create --name data-analysis python=3.11 pandas matplotlib
conda activate data-analysis
conda install ipykernel
python -m ipykernel install --user --name=data-analysis --display-name="Python (Data Analysis)"

Installierte Kernel auflisten

jupyter kernelspec list

Einen Kernel entfernen

jupyter kernelspec remove ml-project

Kernel in einem Notebook wechseln

Klicken Sie in einem geöffneten Notebook auf den Kernel-Namen in der oberen rechten Ecke (z. B. "Python 3") und wählen Sie einen anderen Kernel aus dem Dropdown-Menü. Sie können auch über Kernel > Change Kernel in der Menüleiste wechseln.

FAQ

Wie starte ich JupyterLab?

Öffnen Sie ein Terminal und führen Sie jupyter lab aus. Der JupyterLab-Server startet und Ihr Standardbrowser öffnet sich automatisch. Um in einem bestimmten Ordner zu starten, verwenden Sie jupyter lab --notebook-dir=/pfad/zum/ordner.

Wie installiere ich JupyterLab mit pip?

Führen Sie pip install jupyterlab in Ihrem Terminal aus. Verwenden Sie pip3 auf Systemen, bei denen pip auf Python 2 verweist. Überprüfen Sie mit jupyter lab --version.

Wie installiere ich JupyterLab mit conda?

Führen Sie conda install -c conda-forge jupyterlab aus. Für eine saubere Einrichtung erstellen Sie zuerst eine dedizierte conda-Umgebung.

Was ist der Unterschied zwischen JupyterLab und Jupyter Notebook?

JupyterLab ist die Oberfläche der nächsten Generation mit Multi-Panel-Layout, integriertem Terminal, Dateibrowser und Erweiterungen. Jupyter Notebook ist die ursprüngliche Einzeldokument-Oberfläche. JupyterLab wird für neue Projekte empfohlen.

Wie behebe ich "jupyter: command not found"?

Überprüfen Sie die Installation mit pip show jupyterlab. Falls installiert, versuchen Sie python -m jupyter lab. Andernfalls fügen Sie das pip-Skriptverzeichnis zu Ihrem System-PATH hinzu.

Wie führe ich JupyterLab in einer virtuellen Umgebung aus?

Erstellen Sie eine venv mit python -m venv myenv, aktivieren Sie sie, installieren Sie JupyterLab mit pip install jupyterlab und führen Sie jupyter lab aus.

Wie führe ich JupyterLab mit Docker aus?

Führen Sie docker run -p 8888:8888 jupyter/base-notebook aus. Binden Sie lokale Dateien mit dem -v-Flag für persistenten Speicher ein.

Wie öffne ich JupyterLab auf einem anderen Port?

Verwenden Sie jupyter lab --port=9999, um auf Port 9999 statt dem Standard 8888 zu starten.

Fazit

JupyterLab ist die Standard-Entwicklungsumgebung für interaktive Python-Arbeit in Data Science, maschinellem Lernen und wissenschaftlichem Rechnen. Diese Anleitung hat jeden Schritt von der Installation bis zur erweiterten Konfiguration behandelt:

• JupyterLab installieren mit pip install jupyterlab oder conda install -c conda-forge jupyterlab
• JupyterLab starten mit jupyter lab und den Start mit Flags für Port, Verzeichnis und Browser anpassen
• JupyterLab effektiv nutzen mit Tastenkürzeln, geteilten Ansichten und dem integrierten Terminal
• Fehlerbehebung bei häufigen Problemen wie "command not found", Port-Konflikten und Kernel-Fehlern
• JupyterLab erweitern mit Git-Integration, LSP-Unterstützung und Code-Formatierung
• Umgebung isolieren mit virtuellen Umgebungen und Docker für reproduzierbare Arbeitsabläufe

Ob Sie ein Python-Anfänger sind oder ein erfahrener Data Scientist, der einen neuen Rechner einrichtet -- diese Schritte geben Ihnen eine voll funktionsfähige JupyterLab-Umgebung. Für interaktive Datenvisualisierung in JupyterLab probieren Sie PyGWalker (opens in a new tab), um jeden DataFrame in ein visuelles Drag-and-Drop-Analysetool zu verwandeln.