Jupyter Notebook Häufige Tastenkürzel und praktische Tipps
Jupyter Notebook ist die beliebteste interaktive Entwicklungsumgebung in den Bereichen Data Science und Machine Learning. Die Beherrschung seiner Tastenkürzel und Tipps kann die tägliche Entwicklungseffizienz erheblich verbessern.
Sie können auf das Menü Hilfe klicken, um Tastenkürzel anzuzeigen:
Alle Tastenkürzel in diesem Artikel basieren aufWindows/Linuxals Maßstab. Mac-Benutzer sollten ersetzen
CtrlwithCmd, und ersetzenAltwithOption。
Zwei Betriebsmodi
Jupyter Notebook hat zwei Modi,alle Tastenkürzel hängen vom aktuellen Modus ab, was der entscheidende Punkt ist, den die meisten Anfänger übersehen:
| Mode | Zellrahmenfarbe | So gelangt man hinein | Funktion |
|---|---|---|---|
| Befehlsmodus | Blau | drückenEscoder klicken Sie auf den leeren Bereich auf der linken Seite der Zelle |
Zellen verwalten (hinzufügen, löschen, verschieben usw.) |
| Bearbeitungsmodus | Grün | drückenEnteroder doppelklicken Sie innerhalb der Zelle |
Code oder Text in einer Zelle schreiben und ändern |
Kurze Merkhilfe:Grün = Eingeben und Bearbeiten möglich; Blau = Zellen verwalten möglich. Bevor Sie in den Bearbeitungsmodus wechseln, verwenden Sie zuerstEsczum Verlassen, dann verwendenEnterzum Betreten. Wenn Sie sich diese Gewohnheit aneignen, lassen sich viele versehentliche Aktionen vermeiden.
Tastenkürzel zum Ausführen von Zellen (universell)
Die folgenden drei Tastenkürzel können in beiden Modi verwendet werden. Sie sind die häufigsten Operationen, also sollten Sie sie sich unbedingt einprägen:
| Tastenkürzel | Funktion | Anwendungsszenario |
|---|---|---|
Shift + Enter |
Aktuelle Zelle ausführen und automatisch zur nächsten Zelle springen | Am häufigsten: Code sequenziell nach unten ausführen |
Ctrl + Enter |
Aktuelle Zelle ausführen und in der aktuellen Zelle bleiben | Verwenden, wenn derselbe Code wiederholt getestet wird |
Alt + Enter |
Aktuelle Zelle ausführen und darunter eine neue Zelle einfügen | Verwenden, wenn beim Ausführen Codeblöcke nach unten hinzugefügt werden |
Tastenkürzel für den Befehlsmodus (blauer Rahmen)
drückenEscNach dem Betreten des Befehlsmodus können Sie die folgenden Tastenkürzel verwenden:
1. Einfügen und Löschen von Zellen
| Tastenkürzel | Funktion |
|---|---|
A |
An der aktuellen ZelleOberhalbEine neue Zelle einfügen (Oberhalb) |
B |
An der aktuellen ZelleUnterhalbEine neue Zelle einfügen (Unterhalb) |
D, D(Zweimal D drücken) |
Die aktuelle Zelle löschen |
Z |
Löschen rückgängig machen (die gerade gelöschte Zelle wiederherstellen) |
X |
Die aktuelle Zelle ausschneiden |
C |
Die aktuelle Zelle kopieren |
V |
Eine Zelle unterhalb der aktuellen Zelle einfügen |
Shift + V |
Eine Zelle oberhalb der aktuellen Zelle einfügen |
2. Wechseln des Zelltyps
Zellen in Jupyter haben drei Typen, die jederzeit umgeschaltet werden können:
| Tastenkürzel | Wechseln zu | Zweck |
|---|---|---|
Y |
Code | Python-Code schreiben und ausführen |
M |
Markdown (Auszeichnungssprache) | Formatierte Dokumentation, Überschriften, Beschreibungen schreiben |
R |
Raw (Rohtext) | Text unverändert ausgeben, ohne Ausführung oder Rendering |
1 ~ 6 |
Markdown-Überschriftstufen H1 ~ H6 | Die Zelle schnell auf die entsprechende Überschriftsebene setzen (wechselt automatisch in den Markdown-Modus) |
3. Zellen auswählen und zusammenführen
| Tastenkürzel | Funktion |
|---|---|
↑ / K |
Die Zelle darüber auswählen |
↓ / J |
Die Zelle darunter auswählen |
Shift + ↑ / Shift + K |
Mehrere Zellen nach oben auswählen (fortlaufend) |
Shift + ↓ / Shift + J |
Mehrere Zellen nach unten auswählen (fortlaufend) |
Shift + M |
Die ausgewählten Zellen zu einer zusammenführen |
4. Ausgabe- und Anzeigesteuerung
| Tastenkürzel | Funktion |
|---|---|
O |
Ausgabe der aktuellen Zelle einklappen/ausklappen |
Shift + O |
Scrollmodus für den Ausgabebereich der aktuellen Zelle umschalten (verwenden, wenn der Ausgabeinhalt sehr lang ist) |
L |
Zeilennummern für die aktuelle Zelle anzeigen/ausblenden |
F |
Text in der Zelle suchen und ersetzen |
5. Kernel- und Schnittstellenoperationen
| Tastenkürzel | Funktion |
|---|---|
I, I(I zweimal drücken) |
Die aktuell laufende Zelle unterbrechen (entspricht Ctrl+C) |
0, 0(0 zweimal drücken) |
Den Kernel neu starten (dies löscht alle ausgeführten Variablen,mit Vorsicht verwenden） |
H |
Tastenkürzel-Hilfefenster öffnen (zeigt alle verfügbaren Tastenkürzel) |
P |
Befehlspalette öffnen, um alle Jupyter-Funktionen zu durchsuchen |
Space |
Seite nach unten scrollen |
Shift + Space |
Seite nach oben scrollen |
S / Ctrl + S |
Notebook speichern |
Tastenkürzel für den Bearbeitungsmodus (grüner Rahmen)
drückenEnterNach dem Wechsel in den Bearbeitungsmodus kannst du die folgenden Tastenkürzel verwenden, um innerhalb einer Zelle zu arbeiten:
1. Codebearbeitung
| Tastenkürzel | Funktion |
|---|---|
Tab |
Code-Autovervollständigung (einen Teil eines Funktions- oder Variablennamens eingeben und dann Tab drücken, um ihn zu vervollständigen) |
Shift + Tab |
Die Parameterbeschreibung der Funktion an der Cursorposition anzeigen (blendet einen Dokumentations-Tooltip ein; einmal drücken für eine kurze Zusammenfassung, zweimal drücken für die vollständige Dokumentation) |
Ctrl + / |
Die aktuelle Zeile oder mehrere ausgewählte Codezeilen kommentieren/auskommentieren |
Ctrl + D |
Die gesamte aktuelle Zeile löschen |
Ctrl + Shift + - |
Aktuelle Zelle am Cursor in zwei Zellen teilen |
Ctrl + Z |
Rückgängig (vorherige Bearbeitung wiederherstellen) |
Ctrl + Y |
Wiederholen (das Rückgängigmachen rückgängig machen) |
Ctrl + A |
Alle Inhalte in der aktuellen Zelle auswählen |
Ctrl + Home |
Ganz an den Anfang des Zelleninhalts springen |
Ctrl + End |
Ganz ans Ende des Zelleninhalts springen |
Ctrl + ← / Ctrl + → |
Cursor wortweise bewegen (schnell zum vorherigen/nächsten Wort springen) |
2. Vom Editiermodus in den Befehlsmodus zurückkehren
| Tastenkürzel | Funktion |
|---|---|
Esc |
Editiermodus verlassen, in den Befehlsmodus zurückkehren (Zellenrahmen wird blau) |
Ctrl + M |
Wie Esc, Editiermodus verlassen |
Magische Befehle
Magische Befehle sind spezielle integrierte Jupyter-Direktiven, die mit%(einzelne Zeile) oder%%(gesamte Zelle), verwendet, um häufige Aufgaben wie Zeitmessung, Debugging, Dateioperationen usw. zu erledigen.Sie können verwendet werden, ohne Bibliotheken zu installieren.。
1. Zeitmessung von Code
Beispiel
# %timeit: wiederholt die Zeitmessung einer einzelnen Zeile mehrmals und bildet den Durchschnitt für ein genaueres Ergebnis (geeignet zum Testen der Leistung kurzer Ausdrücke)
%timeit [x**2 for x in range(1000)]
# Beispielausgabe: 98.3 µs ± 1.2 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, je 10000 Schleifen)
# %%time: misst die Zeit des Codes der gesamten Zelle einmal (geeignet zum Testen vollständiger Prozesse, die lange dauern)
%%time
import time
data = [x**2 for x in range(100000)]
time.sleep(1)
# Example output:
# CPU-Zeiten: Benutzer 45.2 ms, System 8.1 ms, Gesamt: 53.3 ms
# Wandzeit: 1.05 s
%timeit [x**2 for x in range(1000)]
# Beispielausgabe: 98.3 µs ± 1.2 µs pro Schleife (Mittelwert ± Standardabweichung von 7 Durchläufen, je 10000 Schleifen)
# %%time: misst die Zeit des Codes der gesamten Zelle einmal (geeignet zum Testen vollständiger Prozesse, die lange dauern)
%%time
import time
data = [x**2 for x in range(100000)]
time.sleep(1)
# Example output:
# CPU-Zeiten: Benutzer 45.2 ms, System 8.1 ms, Gesamt: 53.3 ms
# Wandzeit: 1.05 s
2. Inline-Anzeige von Diagrammen
Beispiel
# %matplotlib inline: bettet Diagramme direkt zur Anzeige in das Notebook ein (am häufigsten verwendet, statische Diagramme)
# Normalerweise in der ersten Zelle des Notebooks platziert; muss nur einmal für das gesamte Notebook ausgeführt werden
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x))
plt.title('sine wave')
plt.show()
# %matplotlib notebook: aktiviert interaktive Diagramme, die gezoomt und verschoben werden können (kann aber nicht zusammen mit inline verwendet werden)
# %matplotlib notebook
# Normalerweise in der ersten Zelle des Notebooks platziert; muss nur einmal für das gesamte Notebook ausgeführt werden
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 100)
plt.plot(x, np.sin(x))
plt.title('sine wave')
plt.show()
# %matplotlib notebook: aktiviert interaktive Diagramme, die gezoomt und verschoben werden können (kann aber nicht zusammen mit inline verwendet werden)
# %matplotlib notebook
3. Anzeigen und Verwalten von Variablen
Beispiel
# %who: listet alle definierten Variablennamen im aktuellen Namensraum auf
%who
# Beispielausgabe: data plt x
# %whos: ausführlicher als %who, zeigt außerdem den Typ und den Wert von Variablen an
%whos
# Example output:
# Variable Typ Daten/Info
# ----------------------------
# x ndarray 100: [0. 0.06 ... 6.28]
# data list n=100000
# %reset: löscht alle Variablen (zeigt eine Bestätigungsabfrage an; geeignet, wenn Berechnungen neu gestartet werden)
%reset
# %reset -f: löscht alle Variablen zwangsweise ohne Bestätigungsabfrage (-f bedeutet erzwingen)
%reset -f
%who
# Beispielausgabe: data plt x
# %whos: ausführlicher als %who, zeigt außerdem den Typ und den Wert von Variablen an
%whos
# Example output:
# Variable Typ Daten/Info
# ----------------------------
# x ndarray 100: [0. 0.06 ... 6.28]
# data list n=100000
# %reset: löscht alle Variablen (zeigt eine Bestätigungsabfrage an; geeignet, wenn Berechnungen neu gestartet werden)
%reset
# %reset -f: löscht alle Variablen zwangsweise ohne Bestätigungsabfrage (-f bedeutet erzwingen)
%reset -f
4. Datei- und Pfadoperationen
Beispiel
# %pwd: zeigt das aktuelle Arbeitsverzeichnis an (Arbeitsverzeichnis ausgeben)
%pwd
# Beispielausgabe: '/home/user/notebooks'
# %ls: listet alle Dateien im aktuellen Verzeichnis auf (Windows-Benutzer müssen möglicherweise %ls verwenden oder direkt !dir benutzen)
%ls
# Beispielausgabe: data.csv model.py notebook.ipynb
# %%writefile: schreibt den Inhalt der gesamten Zelle in eine angegebene Datei (wird häufig verwendet, um schnell Skriptdateien zu erstellen)
%%writefile hello.py
def greet(name):
print(f"Hallo, {name}!")
greet("World")
# Nach der Ausführung wird eine hello.py-Datei im aktuellen Verzeichnis erzeugt, die den Code in der Zelle enthält
# %run: führt eine externe Python-Skriptdatei aus und importiert ihre Variablen in den aktuellen Namensraum
%run hello.py
# Ausgabe: Hello, world!
# %load: lädt den Inhalt einer externen Skriptdatei in die aktuelle Zelle (wird nicht automatisch ausgeführt; lädt nur den Code)
%load hello.py
%pwd
# Beispielausgabe: '/home/user/notebooks'
# %ls: listet alle Dateien im aktuellen Verzeichnis auf (Windows-Benutzer müssen möglicherweise %ls verwenden oder direkt !dir benutzen)
%ls
# Beispielausgabe: data.csv model.py notebook.ipynb
# %%writefile: schreibt den Inhalt der gesamten Zelle in eine angegebene Datei (wird häufig verwendet, um schnell Skriptdateien zu erstellen)
%%writefile hello.py
def greet(name):
print(f"Hallo, {name}!")
greet("World")
# Nach der Ausführung wird eine hello.py-Datei im aktuellen Verzeichnis erzeugt, die den Code in der Zelle enthält
# %run: führt eine externe Python-Skriptdatei aus und importiert ihre Variablen in den aktuellen Namensraum
%run hello.py
# Ausgabe: Hello, world!
# %load: lädt den Inhalt einer externen Skriptdatei in die aktuelle Zelle (wird nicht automatisch ausgeführt; lädt nur den Code)
%load hello.py
5. Ausführen von Systembefehlen
Beispiel
# Das Hinzufügen von ! vor einem Befehl ermöglicht die direkte Ausführung von Systemterminal-Befehlen, ohne in ein Terminalfenster wechseln zu müssen
!pip install pandas # Python-Pakete installieren
!pip list # Liste der installierten Pakete anzeigen
!python --version # Python-Version anzeigen
# Sie können die Befehlsausgabe auch als Python-Variable speichern
files = !ls -1 # Den Befehl ls ausführen und das Ergebnis der Variable files zuweisen
print(files) # files ist eine Liste, in der jeder Dateiname ein Element ist
!pip install pandas # Python-Pakete installieren
!pip list # Liste der installierten Pakete anzeigen
!python --version # Python-Version anzeigen
# Sie können die Befehlsausgabe auch als Python-Variable speichern
files = !ls -1 # Den Befehl ls ausführen und das Ergebnis der Variable files zuweisen
print(files) # files ist eine Liste, in der jeder Dateiname ein Element ist
6. Verlauf anzeigen und debuggen
Beispiel
# %history: zeigt den Verlauf aller in der aktuellen Sitzung ausgeführten Befehle an
%history
# Das Hinzufügen von -n zeigt Zeilennummern an; das Hinzufügen von -l 5 zeigt nur die letzten 5 Einträge an
%history -n -l 5
# %debug: Nachdem Code einen Fehler gemeldet hat, wird durch Ausführen von %debug in der nächsten Zelle der interaktive Debugging-Modus gestartet
# Im Debug-Modus können Sie Variablennamen eingeben, um Werte anzuzeigen, und q eingeben, um das Debugging zu beenden
# Zum Beispiel nach dem Ausführen eines Codeabschnitts, der einen Fehler verursacht hat:
%debug
%history
# Das Hinzufügen von -n zeigt Zeilennummern an; das Hinzufügen von -l 5 zeigt nur die letzten 5 Einträge an
%history -n -l 5
# %debug: Nachdem Code einen Fehler gemeldet hat, wird durch Ausführen von %debug in der nächsten Zelle der interaktive Debugging-Modus gestartet
# Im Debug-Modus können Sie Variablennamen eingeben, um Werte anzuzeigen, und q eingeben, um das Debugging zu beenden
# Zum Beispiel nach dem Ausführen eines Codeabschnitts, der einen Fehler verursacht hat:
%debug
7. Rendern spezieller Inhalte
Beispiel
# %%html: rendert den Zelleninhalt als HTML-Ausgabe (kann benutzerdefinierte Stile und interaktive Elemente einbetten)
%%html
<h3 style="color: steelblue;">Dies ist eine HTML-Überschrift</h3>
<p style="font-size: 16px;">HTML-Inhalt kann direkt im Notebook gerendert werden.</p>
# %%latex: rendert den Zelleninhalt als LaTeX-Formel (wird häufig zum Schreiben mathematischer Formeln verwendet)
%%latex
$$E = mc^2$$
$$\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$$
%%html
<h3 style="color: steelblue;">Dies ist eine HTML-Überschrift</h3>
<p style="font-size: 16px;">HTML-Inhalt kann direkt im Notebook gerendert werden.</p>
# %%latex: rendert den Zelleninhalt als LaTeX-Formel (wird häufig zum Schreiben mathematischer Formeln verwendet)
%%latex
$$E = mc^2$$
$$\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}$$
Laufenden Fortschritt in Echtzeit anzeigen
Beim Verarbeiten großer Datenmengen oder beim Ausführen langer Schleifen ist es sehr wichtig, den Fortschritt in Echtzeit anzuzeigen. Nachfolgend finden Sie mehrere häufig verwendete Lösungen zur Fortschrittsanzeige.
1. tqdm-Fortschrittsbalken (empfohlen)
tqdm ist die am häufigsten verwendete Fortschrittsbalken-Bibliothek und unterstützt Schleifen, Pandas und verschiedene Jupyter-Szenarien. Installationsbefehl:
pip install tqdm
Beispiel
from tqdm.notebook import tqdm # Verwenden Sie die Notebook-Version in Jupyter für eine ansprechendere Darstellung
import time
# Grundlegende Verwendung: Umschließen Sie ein iterierbares Objekt mit tqdm(), um automatisch einen Fortschrittsbalken anzuzeigen
for i in tqdm(range(100)):
time.sleep(0.05) # Simuliere einen zeitaufwändigen Vorgang
# Ausgabe: zeigt Fortschrittsbalken, abgeschlossenen Prozentsatz, verstrichene Zeit, geschätzte verbleibende Zeit
# Verwendung mit enumerate
data = list(range(50))
for i, item in enumerate(tqdm(data, desc="Daten werden verarbeitet")):
# Der Parameter desc legt den Beschriftungstext auf der linken Seite des Fortschrittsbalkens fest
time.sleep(0.05)
# Fortschritt manuell steuern (geeignet für Szenarien, in denen die Gesamtmenge unsicher ist)
with tqdm(total=100, desc="Download-Fortschritt") as pbar:
for chunk in range(10):
time.sleep(0.1)
pbar.update(10) # Fortschritt jedes Mal um 10 Einheiten aktualisieren
pbar.set_postfix({"chunk": chunk}) # Zusätzliche Informationen auf der rechten Seite des Fortschrittsbalkens anzeigen
import time
# Grundlegende Verwendung: Umschließen Sie ein iterierbares Objekt mit tqdm(), um automatisch einen Fortschrittsbalken anzuzeigen
for i in tqdm(range(100)):
time.sleep(0.05) # Simuliere einen zeitaufwändigen Vorgang
# Ausgabe: zeigt Fortschrittsbalken, abgeschlossenen Prozentsatz, verstrichene Zeit, geschätzte verbleibende Zeit
# Verwendung mit enumerate
data = list(range(50))
for i, item in enumerate(tqdm(data, desc="Daten werden verarbeitet")):
# Der Parameter desc legt den Beschriftungstext auf der linken Seite des Fortschrittsbalkens fest
time.sleep(0.05)
# Fortschritt manuell steuern (geeignet für Szenarien, in denen die Gesamtmenge unsicher ist)
with tqdm(total=100, desc="Download-Fortschritt") as pbar:
for chunk in range(10):
time.sleep(0.1)
pbar.update(10) # Fortschritt jedes Mal um 10 Einheiten aktualisieren
pbar.set_postfix({"chunk": chunk}) # Zusätzliche Informationen auf der rechten Seite des Fortschrittsbalkens anzeigen
Beispiel
# tqdm-Integration mit Pandas: Fortschritt für DataFrame-apply-Operationen anzeigen
import pandas as pd
from tqdm.notebook import tqdm
tqdm.pandas() # Pandas-Integration aktivieren; muss nur einmal ausgeführt werden
df = pd.DataFrame({'value': range(1000)})
# progress_apply statt normalem apply verwenden, um den Fortschritt automatisch anzuzeigen
result = df['value'].progress_apply(lambda x: x ** 2)
import pandas as pd
from tqdm.notebook import tqdm
tqdm.pandas() # Pandas-Integration aktivieren; muss nur einmal ausgeführt werden
df = pd.DataFrame({'value': range(1000)})
# progress_apply statt normalem apply verwenden, um den Fortschritt automatisch anzuzeigen
result = df['value'].progress_apply(lambda x: x ** 2)
2. display + clear_output dynamische Aktualisierung der Ausgabe
Wenn Sie tqdm nicht installieren möchten, können Sie die in IPython integrierte Funktion verwenden,clear_outputum dynamische Aktualisierungseffekte zu erzielen:
Beispiel
from IPython.display import clear_output
import time
total = 50
for i in range(total):
time.sleep(0.1)
# clear_output(wait=True): löscht die vorherige Ausgabe; wait=True bedeutet, zu warten, bis neuer Inhalt verfügbar ist, bevor gelöscht wird,
# um Flackern zu vermeiden. Hinweis: Dadurch wird die gesamte Ausgabe der aktuellen Zelle gelöscht
clear_output(wait=True)
# Manuell eine einfache Textfortschrittsleiste zeichnen
done = int((i + 1) / total * 30) # Anzahl der abgeschlossenen Zellen berechnen (insgesamt 30 Zellen)
bar = '█' * done + '░' * (30 - done) # █ steht für abgeschlossen, ░ steht für nicht abgeschlossen
pct = (i + 1) / total * 100
print(f"Fortschritt: [{bar}] {pct:.1f}% ({i+1}/{total})")
print("✅ Alles erledigt!")
import time
total = 50
for i in range(total):
time.sleep(0.1)
# clear_output(wait=True): löscht die vorherige Ausgabe; wait=True bedeutet, zu warten, bis neuer Inhalt verfügbar ist, bevor gelöscht wird,
# um Flackern zu vermeiden. Hinweis: Dadurch wird die gesamte Ausgabe der aktuellen Zelle gelöscht
clear_output(wait=True)
# Manuell eine einfache Textfortschrittsleiste zeichnen
done = int((i + 1) / total * 30) # Anzahl der abgeschlossenen Zellen berechnen (insgesamt 30 Zellen)
bar = '█' * done + '░' * (30 - done) # █ steht für abgeschlossen, ░ steht für nicht abgeschlossen
pct = (i + 1) / total * 100
print(f"Fortschritt: [{bar}] {pct:.1f}% ({i+1}/{total})")
print("✅ Alles erledigt!")
3. Fortschritt beim Zeichnen von Echtzeit-Diagrammen
In Szenarien wie beim Modelltraining können Sie Diagramme in Abständen dynamisch aktualisieren, um Metriktrends in Echtzeit zu beobachten:
Beispiel
%matplotlib inline
import matplotlib.pyplot as plt
from IPython.display import clear_output, display
import numpy as np
import time
losses = [] # Den Verlustwert jedes Schritts speichern, um den Trainingsprozess zu simulieren
for step in range(50):
# Training simulieren: einen schrittweise abnehmenden Verlustwert generieren
loss = 1 / (step + 1) + np.random.uniform(0, 0.05)
losses.append(loss)
# Aktualisiere das Diagramm alle 5 Schritte, um zu häufiges Aktualisieren zu vermeiden
if (step + 1) % 5 == 0:
clear_output(wait=True)
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(losses, color='steelblue', linewidth=2)
ax.set_title(f'Trainingsfortschritt (Schritt {step + 1}/50)')
ax.set_xlabel('Schritt')
ax.set_ylabel('Verlust')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show() # Rufe show nach clear_output auf, und das Diagramm wird an derselben Position aktualisiert
time.sleep(0.1)
print("Training abgeschlossen! Endgültiger Verlust:", f"{losses[-1]:.4f}")
import matplotlib.pyplot as plt
from IPython.display import clear_output, display
import numpy as np
import time
losses = [] # Den Verlustwert jedes Schritts speichern, um den Trainingsprozess zu simulieren
for step in range(50):
# Training simulieren: einen schrittweise abnehmenden Verlustwert generieren
loss = 1 / (step + 1) + np.random.uniform(0, 0.05)
losses.append(loss)
# Aktualisiere das Diagramm alle 5 Schritte, um zu häufiges Aktualisieren zu vermeiden
if (step + 1) % 5 == 0:
clear_output(wait=True)
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(losses, color='steelblue', linewidth=2)
ax.set_title(f'Trainingsfortschritt (Schritt {step + 1}/50)')
ax.set_xlabel('Schritt')
ax.set_ylabel('Verlust')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show() # Rufe show nach clear_output auf, und das Diagramm wird an derselben Position aktualisiert
time.sleep(0.1)
print("Training abgeschlossen! Endgültiger Verlust:", f"{losses[-1]:.4f}")
Tipps zum Anzeigen von Dokumentation und Code
1. Funktionsdokumentation schnell anzeigen
Beispiel
# Methode 1: Fügen Sie ? nach dem Funktionsnamen hinzu, um unten im Notebook ein Dokumentationsfenster einzublenden
import numpy as np
np.array?
# Dadurch werden die Parameterbeschreibung und die Funktionsbeschreibung von np.array eingeblendet
# Methode 2: Fügen Sie ?? nach dem Funktionsnamen hinzu, um die vollständige Dokumentation einschließlich des Quellcodes einzublenden (falls die Quelle verfügbar ist)
np.array??
# Methode 3: Drücken Sie Shift + Tab innerhalb der Funktionsklammern
# Wenn Sie beispielsweise np.linspace( eingegeben haben, drücken Sie (innerhalb der Klammern) Shift + Tab, um Parameterhinweise einzublenden
# Drücken Sie zweimal Shift + Tab, um eine vollständigere Dokumentation anzuzeigen
# Methode 4: Verwenden Sie die Funktion help() (die Ausgabe ist vollständiger, wird aber im Ausgabebereich statt in einem Popup angezeigt)
help(np.array)
import numpy as np
np.array?
# Dadurch werden die Parameterbeschreibung und die Funktionsbeschreibung von np.array eingeblendet
# Methode 2: Fügen Sie ?? nach dem Funktionsnamen hinzu, um die vollständige Dokumentation einschließlich des Quellcodes einzublenden (falls die Quelle verfügbar ist)
np.array??
# Methode 3: Drücken Sie Shift + Tab innerhalb der Funktionsklammern
# Wenn Sie beispielsweise np.linspace( eingegeben haben, drücken Sie (innerhalb der Klammern) Shift + Tab, um Parameterhinweise einzublenden
# Drücken Sie zweimal Shift + Tab, um eine vollständigere Dokumentation anzuzeigen
# Methode 4: Verwenden Sie die Funktion help() (die Ausgabe ist vollständiger, wird aber im Ausgabebereich statt in einem Popup angezeigt)
help(np.array)
2. Verwenden Sie display, um mehrere Ausgabeergebnisse anzuzeigen
Standardmäßig zeigt Jupyter nur den Wert des letzten Ausdrucks in jeder Zelle an. Durchdisplay()können Sie mehrere Ergebnisse in einer Zelle ausgeben:
Beispiel
import pandas as pd
from IPython.display import display
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'X': [7, 8, 9], 'Y': [10, 11, 12]})
# Ohne display wird nur das letzte DataFrame angezeigt
# df1 # wird nicht angezeigt
# df2 # Nur dieses wird angezeigt
# Mit display() können mehrere Tabellen gleichzeitig und mit schöner Formatierung angezeigt werden
display(df1)
display(df2)
from IPython.display import display
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'X': [7, 8, 9], 'Y': [10, 11, 12]})
# Ohne display wird nur das letzte DataFrame angezeigt
# df1 # wird nicht angezeigt
# df2 # Nur dieses wird angezeigt
# Mit display() können mehrere Tabellen gleichzeitig und mit schöner Formatierung angezeigt werden
display(df1)
display(df2)
Beispiel
# Tipp: Ändere die Notebook-Konfiguration, sodass der Wert jedes Ausdrucks automatisch angezeigt wird (display muss nicht manuell aufgerufen werden)
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" # Standard ist "last_expr"; nach Änderung zu "all"
# Jeder Ausdruck in der Zelle gibt automatisch sein Ergebnis aus
1 + 1 # Gibt 2 aus
2 + 2 # Gibt 4 aus (standardmäßig gibt diese Zeile nichts aus)
"hello" # Gibt 'hello' aus
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" # Standard ist "last_expr"; nach Änderung zu "all"
# Jeder Ausdruck in der Zelle gibt automatisch sein Ergebnis aus
1 + 1 # Gibt 2 aus
2 + 2 # Gibt 4 aus (standardmäßig gibt diese Zeile nichts aus)
"hello" # Gibt 'hello' aus
3. Unerwünschte Ausgabe unterdrücken
Beispiel
import matplotlib.pyplot as plt
import numpy as np
# Problem: plt.plot() gibt beim Anzeigen des Diagramms eine zusätzliche Objektbeschreibung aus, wie:
# [<matplotlib.lines.Line2D object at 0x7f3b1234>]
# Lösung: Fügen Sie ein Semikolon (;) am Ende der Anweisung hinzu, um die Ausgabe des letzten Ausdrucks zu unterdrücken, ohne die Diagrammanzeige zu beeinträchtigen
plt.plot(np.sin(np.linspace(0, 2*np.pi, 100)));
# Nach dem Hinzufügen des Semikolons wird das Diagramm normal angezeigt, aber die zusätzliche Objektbeschreibung erscheint nicht
import numpy as np
# Problem: plt.plot() gibt beim Anzeigen des Diagramms eine zusätzliche Objektbeschreibung aus, wie:
# [<matplotlib.lines.Line2D object at 0x7f3b1234>]
# Lösung: Fügen Sie ein Semikolon (;) am Ende der Anweisung hinzu, um die Ausgabe des letzten Ausdrucks zu unterdrücken, ohne die Diagrammanzeige zu beeinträchtigen
plt.plot(np.sin(np.linspace(0, 2*np.pi, 100)));
# Nach dem Hinzufügen des Semikolons wird das Diagramm normal angezeigt, aber die zusätzliche Objektbeschreibung erscheint nicht
Weitere praktische Tipps
1. Zwischenwerte von Variablen anzeigen (ohne die Codeausführung zu unterbrechen)
Beispiel
# Tipp: Nutze die Eigenschaft von Python-Zuweisungsanweisungen, dass sie auch einen Wert zurückgeben,
# Wenn du das Zwischenergebnis einer Variablen zuweist, schließe die gesamte Zeile in Klammern ein, damit sie ausgegeben wird
import numpy as np
# Normale Methode (der Wert von result ist nicht sichtbar)
result = np.array([1, 2, 3]) * 2
# Methode mit Klammern (gibt den Wert von result während der Zuweisung aus)
(result := np.array([1, 2, 3]) * 2) # Python 3.8+ Walrus-Operator-Ansatz
# Ausgabe: array([2, 4, 6])
# Oder einfacher: Schreibe einfach den Variablennamen in eine neue Zeile nach der Zuweisung
result = np.array([1, 2, 3]) * 2
result # Jupyter zeigt automatisch den Wert des letzten Ausdrucks an
# Wenn du das Zwischenergebnis einer Variablen zuweist, schließe die gesamte Zeile in Klammern ein, damit sie ausgegeben wird
import numpy as np
# Normale Methode (der Wert von result ist nicht sichtbar)
result = np.array([1, 2, 3]) * 2
# Methode mit Klammern (gibt den Wert von result während der Zuweisung aus)
(result := np.array([1, 2, 3]) * 2) # Python 3.8+ Walrus-Operator-Ansatz
# Ausgabe: array([2, 4, 6])
# Oder einfacher: Schreibe einfach den Variablennamen in eine neue Zeile nach der Zuweisung
result = np.array([1, 2, 3]) * 2
result # Jupyter zeigt automatisch den Wert des letzten Ausdrucks an
2. Auf das vorherige Ausgabeergebnis verweisen
Beispiel
# Jupyter hat integrierte spezielle Variablen, um schnell auf historische Ausgaben zu verweisen:
# _ : Ausgabeergebnis der vorherigen Zelle
# __ : Ausgabeergebnis der vorletzten Zelle
# _3 : Ausgabeergebnis der 3. Zelle (Out
# Zum Beispiel:
1 + 1
# Out[1]: 2
_ # Auf die vorherige Ausgabe verweisen, Wert ist 2
# Out[2]: 2
_ * 10 # Verwenden Sie die vorherige Ausgabe, um weiterzurechnen
# Out[3]: 20
_3 + 5 # Auf das Ergebnis 20 von Out verweisen
# Out[4]: 25
# _ : Ausgabeergebnis der vorherigen Zelle
# __ : Ausgabeergebnis der vorletzten Zelle
# _3 : Ausgabeergebnis der 3. Zelle (Out
# Zum Beispiel:
1 + 1
# Out[1]: 2
_ # Auf die vorherige Ausgabe verweisen, Wert ist 2
# Out[2]: 2
_ * 10 # Verwenden Sie die vorherige Ausgabe, um weiterzurechnen
# Out[3]: 20
_3 + 5 # Auf das Ergebnis 20 von Out verweisen
# Out[4]: 25
3. Rich-Text-Inhalt im Notebook anzeigen
Beispiel
from IPython.display import display, HTML, Image, Markdown, Audio, Video
# Markdown-formatierten Text rendern
display(Markdown("## Dies ist eine Überschrift\n\n**fetter Text**, *kursiver Text*, `code`"))
# HTML rendern
display(HTML("<span style='color:red; font-size:20px'>Großer roter Text</span>"))
# Ein Netzwerkbild anzeigen (Bild-URL übergeben)
display(Image(url="https://www.example.com/images/example-logo.png", width=200))
# Ein lokales Bild anzeigen (lokalen Dateipfad übergeben)
# display(Image(filename="./chart.png"))
# Markdown-formatierten Text rendern
display(Markdown("## Dies ist eine Überschrift\n\n**fetter Text**, *kursiver Text*, `code`"))
# HTML rendern
display(HTML("<span style='color:red; font-size:20px'>Großer roter Text</span>"))
# Ein Netzwerkbild anzeigen (Bild-URL übergeben)
display(Image(url="https://www.example.com/images/example-logo.png", width=200))
# Ein lokales Bild anzeigen (lokalen Dateipfad übergeben)
# display(Image(filename="./chart.png"))
4. Timing-Annotationen zu Zellen hinzufügen (verstrichene Zeit automatisch in der Ausgabe anzeigen)
Beispiel
# Die Installation von jupyter-contrib-nbextensions bietet mehr Erweiterungsfunktionen
# pip install jupyter-contrib-nbextensions
# Einfache Lösung: Verwende einen Decorator oder Context Manager, um die Zeitmessungslogik zu kapseln, in jedem Codeblock verwendbar
import time
from contextlib import contextmanager
@contextmanager
def timer(label="Verstrichene Zeit"):
start = time.time()
try:
yield
finally:
elapsed = time.time() - start
print(f"⏱ {label}: {elapsed:.3f} Sekunden")
# Verwendung: Umschließe jeden Codeblock mit with timer():, und die verstrichene Zeit wird nach der Ausführung automatisch ausgegeben
with timer("Datenverarbeitung"):
data = [x ** 2 for x in range(1000000)]
# Ausgabe: ⏱ Datenverarbeitung: 0.087 Sekunden
# pip install jupyter-contrib-nbextensions
# Einfache Lösung: Verwende einen Decorator oder Context Manager, um die Zeitmessungslogik zu kapseln, in jedem Codeblock verwendbar
import time
from contextlib import contextmanager
@contextmanager
def timer(label="Verstrichene Zeit"):
start = time.time()
try:
yield
finally:
elapsed = time.time() - start
print(f"⏱ {label}: {elapsed:.3f} Sekunden")
# Verwendung: Umschließe jeden Codeblock mit with timer():, und die verstrichene Zeit wird nach der Ausführung automatisch ausgegeben
with timer("Datenverarbeitung"):
data = [x ** 2 for x in range(1000000)]
# Ausgabe: ⏱ Datenverarbeitung: 0.087 Sekunden
5. Schnell alle Tastenkürzel für das aktuelle Notebook anzeigen
Im Befehlsmodus (blauer Rahmen), drücken SieH, oder über das MenüHilfe → Tastaturkürzel, um das vollständige Tastaturkürzel-Hilfefenster zu öffnen und jederzeit alle verfügbaren Vorgänge zu prüfen.
Übersichtstabelle gängiger Tastaturkürzel
| Aktion | Tastenkürzel | Mode |
|---|---|---|
| Zelle ausführen und zur nächsten springen | Shift + Enter |
Allgemein |
| Zelle ausführen und an Ort und Stelle bleiben | Ctrl + Enter |
Allgemein |
| Zelle ausführen und darunter neue Zelle erstellen | Alt + Enter |
Allgemein |
| In den Editiermodus wechseln | Enter |
Befehlsmodus |
| Editiermodus verlassen | Esc |
Editiermodus |
| Zelle oberhalb einfügen | A |
Befehlsmodus |
| Zelle unterhalb einfügen | B |
Befehlsmodus |
| Zelle löschen | D, D |
Befehlsmodus |
| Zelllöschung rückgängig machen | Z |
Befehlsmodus |
| Zu Code-Zelle wechseln | Y |
Befehlsmodus |
| Zu Markdown-Zelle wechseln | M |
Befehlsmodus |
| Mehrere ausgewählte Zellen zusammenführen | Shift + M |
Befehlsmodus |
| Kernel unterbrechen (Ausführung stoppen) | I, I |
Befehlsmodus |
| Kernel neu starten | 0, 0 |
Befehlsmodus |
| Tastenkürzel-Hilfe anzeigen | H |
Befehlsmodus |
| Code-Autovervollständigung | Tab |
Editiermodus |
| Funktionsparameter/Dokumentation anzeigen | Shift + Tab |
Editiermodus |
| Kommentieren/Kommentierung aufheben | Ctrl + / |
Editiermodus |
| Zelle am Cursor teilen | Ctrl + Shift + - |
Editiermodus |
| Notebook speichern | S / Ctrl + S |
Befehlsmodus / Bearbeitungsmodus |