REPL-Power: Mehr aus der interaktiven Shell holen

In Teil 1 der Python-Serie haben wir die REPL hauptsächlich als Taschenrechner verwendet. Damit verkaufen wir sie allerdings deutlich unter Wert.

Die interaktive Shell eignet sich hervorragend, um Code auszuprobieren, Datentypen und APIs zu erkunden, kleine Fehler nachzustellen oder eine Idee zu testen, ohne dafür jedes Mal ein Skript anzulegen.

Seit Python 3.13 ist auch die eingebaute REPL deutlich komfortabler geworden. Mehrzeiliges Editing, History-Browser und Paste-Mode machen für viele kurze Experimente zusätzliche Tools überflüssig. Wer noch mehr möchte, kann weiterhin zu IPython oder ptpython greifen.

Was ist eine REPL?

Die Abkürzung REPL steht für:

• Read: Eingabe lesen
• Evaluate: Eingabe auswerten
• Print: Ergebnis ausgeben
• Loop: auf die nächste Eingabe warten

Du startest die eingebaute REPL, indem Du Python ohne den Namen eines Skripts aufrufst:

python

Je nach Betriebssystem und Installation verwendest Du stattdessen möglicherweise python3 oder py.

Danach kannst Du Python-Code direkt eingeben:

>>> 6 * 7
42
>>> name = "Karl"
>>> print(f"Willkommen, {name}!")
Willkommen, Karl!

Sobald eine Eingabe vollständig ist, führt Python sie aus und zeigt Dir direkt das Ergebnis. Datei anlegen, speichern und erneut starten entfällt.

Gerade beim Ausprobieren einer unbekannten Funktion oder beim Nachstellen eines kleinen Fehlers ist das oft schneller als ein separates Testskript.

Die neue REPL seit Python 3.13

Bis einschließlich Python 3.12 war die eingebaute CPython-REPL vergleichsweise spartanisch. Python 3.13 führte eine neue, in Python geschriebene Shell ein, die auf PyREPL basiert. PyREPL stammt ursprünglich aus dem PyPy-Projekt.

Sie wird standardmäßig verwendet, wenn Python in einem unterstützten interaktiven Terminal läuft.

Mehrzeiliges Editing

Mehrzeilige Code-Blöcke werden als zusammengehörige Eingabe behandelt:

>>> for zahl in range(3):
...     print(f"Runde {zahl}")
...
Runde 0
Runde 1
Runde 2

Holst Du diesen Code später mit der Pfeiltaste nach oben aus der History zurück, kannst Du den gesamten Block wieder bearbeiten. Das ist besonders bei Funktionen, Schleifen und längeren Bedingungen angenehm.

Die alte REPL war an dieser Stelle deutlich unbequemer und behandelte mehrzeilige Eingaben wesentlich stärker als einzelne Zeilen.

Farben für Prompts und Tracebacks

Prompts und Tracebacks werden standardmäßig farbig dargestellt, sofern das Terminal Farben unterstützt.

Bei längeren Fehlermeldungen lässt sich dadurch schneller erkennen, wo der eigentliche Exception-Typ steht und welche Stellen zum Traceback gehören.

Die Farbausgabe kann unter anderem über PYTHON_COLORS oder die verbreitete Umgebungsvariable NO_COLOR beeinflusst werden.

Direkte REPL-Kommandos

Kommandos wie help, exit und quit funktionieren in der neuen REPL auch ohne Klammern:

>>> help
>>> exit

Die bisherigen Schreibweisen bleiben ebenfalls gültig:

>>> help()
>>> exit()

Das klingt nach einer Kleinigkeit, fühlt sich in einer interaktiven Shell aber wesentlich natürlicher an.

Die Funktionstasten F1 bis F3

PyREPL bringt drei nützliche Shortcuts mit:

Der History-Browser über F2 zeigt nur den zuvor eingegebenen Code. Die Prompts >>> und ... sowie erzeugte Ausgaben werden ausgeblendet. Dadurch kannst Du beispielsweise einen früheren Code-Block sauber kopieren, ohne ihn anschließend von REPL-Ausgaben befreien zu müssen.

F3 schaltet in einen speziellen Paste-Mode. Das ist vor allem bei Terminals nützlich, die Bracketed Paste nicht selbst unterstützen. Größere Code-Blöcke lassen sich dort einfügen, ohne dass jede Zeile sofort ausgeführt oder durch die automatische Einrückung verändert wird.

Mit einem weiteren Druck auf F3 verlässt Du den Modus wieder.

Je nach Terminal, Desktop-Umgebung oder Belegung der Funktionstasten können diese Shortcuts vom Terminal selbst abgefangen werden.

Weitere Verbesserungen in Python 3.14

Python 3.14 baut die neue REPL weiter aus. Zwei Änderungen fallen beim Arbeiten direkt auf.

Syntax-Highlighting während der Eingabe

Python-Code wird bereits beim Tippen farblich hervorgehoben. Strings, Zahlen, Keywords und andere Bestandteile des Codes sind dadurch leichter voneinander zu unterscheiden.

Das Highlighting ist standardmäßig aktiviert, solange die neue REPL verwendet und die Farbausgabe nicht deaktiviert wurde.

Autovervollständigung für Imports

Python 3.14 kann Module und Submodule direkt beim Schreiben eines Imports vervollständigen.

Gib beispielsweise Folgendes ein und drücke anschließend Tab:

import co

Die REPL kann nun installierte Module vorschlagen, deren Name mit co beginnt.

Das funktioniert auch bei Submodulen:

from concurrent import i

Hier kann die REPL passende Submodule von concurrent anbieten.

Wichtig ist die Einschränkung: Diese Erweiterung betrifft Module und Submodule. Die Attribute eines bereits importierten Moduls werden von dieser Import-Autocompletion nicht vervollständigt.

Auf die alte REPL zurückschalten

Falls PyREPL in einem ungewöhnlich konfigurierten Terminal Probleme verursacht oder Du auf ein Verhalten der alten REPL angewiesen bist, kannst Du sie über die Umgebungsvariable PYTHON_BASIC_REPL deaktivieren.

Unter Linux und macOS beispielsweise:

PYTHON_BASIC_REPL=1 python

In der PowerShell:

$env:PYTHON_BASIC_REPL = "1"
python

Python verwendet dann wieder die einfachere klassische REPL.

Für den normalen Alltag ist das kaum nötig. Die Option ist hauptsächlich als Fallback für inkompatible Terminals und bestehende Workflows gedacht, die etwa von einer älteren Readline-Konfiguration abhängen.

Eingebaute Tricks, die Du kennen solltest

Auch ohne IPython oder andere zusätzliche Pakete besitzt die Python-REPL einige Funktionen, mit denen sich unbekannter Code erstaunlich gut erkunden lässt.

Das letzte Ergebnis mit _ weiterverwenden

Der Unterstrich _ enthält in der normalen Python-REPL automatisch das Ergebnis des zuletzt ausgegebenen Ausdrucks:

>>> 6 * 7
42
>>> _ + 1
43
>>> _ * 2
86

Das ist praktisch, wenn Du mit einem Ergebnis direkt weiterrechnen möchtest, ohne dafür erst eine Variable anzulegen.

Python behandelt _ dabei allerdings etwas speziell. Du solltest der Variable in der REPL nicht selbst einen Wert zuweisen:

>>> _ = 10

Damit würdest Du die eingebaute Bedeutung von _ mit einer eigenen Variable überdecken.

Für Werte, mit denen Du länger arbeiten möchtest, ist ohnehin ein sprechender Name die bessere Wahl:

schaden = 6 * 7

Objekte mit dir(...) erkunden

dir(...) liefert Dir einen Überblick über die Attribute und Methoden eines Objekts oder Datentyps:

>>> dir(str)
['__add__', '__class__', ..., 'split', 'startswith', 'strip', ...]

Möchtest Du wissen, was Du mit einem String machen kannst, ist dir(str) ein guter Ausgangspunkt.

Die Liste wirkt zunächst etwas wild. Namen, die mit zwei Unterstrichen beginnen und enden, gehören meist zum Python-Datenmodell. Für den Einstieg interessieren eher Einträge wie split, strip, lower oder startswith.

dir(...) ist dabei als praktische Erkundungshilfe gedacht und nicht als garantiert vollständige Beschreibung einer API.

Hilfe mit help(...) anzeigen

Hast Du mit dir(...) eine interessante Methode gefunden, kannst Du direkt die eingebaute Hilfe öffnen:

>>> help(str.strip)

Python zeigt Dir die Signatur und Dokumentation der Methode an.

Ein typischer kleiner REPL-Workflow sieht deshalb so aus:

>>> text = "  Dungeon  "
>>> dir(text)
['__add__', ..., 'split', 'startswith', 'strip', ...]
>>> help(text.strip)
>>> text.strip()
'Dungeon'

Du findest eine Methode, liest kurz nach, was sie tut, und probierst sie direkt aus. Dafür musst Du weder die REPL verlassen noch ein Testskript anlegen.

Den Typ eines Wertes prüfen

Auch type(...) gehört zu den nützlichsten Werkzeugen beim interaktiven Arbeiten:

>>> type(100)
<class 'int'>
>>> type("100")
<class 'str'>
>>> type(3.5)
<class 'float'>

Gerade bei Benutzereingaben, Rückgabewerten oder Daten aus einer fremden API klärt ein kurzer Blick auf den Typ häufig schon, warum sich ein Wert anders verhält als erwartet.

IPython: Mehr Werkzeug für längere Sessions

Die eingebaute REPL reicht für kurze Experimente inzwischen erstaunlich weit. Wenn Du regelmäßig interaktiv arbeitest, bietet IPython aber weiterhin Funktionen, die weit darüber hinausgehen.

Du installierst IPython in Deiner Python-Umgebung mit:

python -m pip install ipython

Anschließend startest Du es mit:

ipython

IPython nummeriert Inputs und Outputs:

In [1]: zahlen = [1, 2, 3, 4]

In [2]: sum(zahlen)
Out[2]: 10

Das macht längere Sessions nachvollziehbarer und ermöglicht es außerdem, auf frühere Ein- und Ausgaben zurückzugreifen.

Hilfe mit ? und ??

Ein Fragezeichen hinter einem Objekt zeigt Informationen wie Signatur und Docstring an:

In [3]: sum?

Mit zwei Fragezeichen versucht IPython zusätzlich, den Quellcode des Objekts anzuzeigen:

In [4]: sum??

Das funktioniert naturgemäß nicht immer. Bei eingebauten oder in C implementierten Funktionen steht der Python-Quellcode häufig nicht zur Verfügung.

Für eigene Funktionen oder viele Python-Bibliotheken ist ?? dagegen eine schnelle Möglichkeit, direkt nachzusehen, was hinter einem Aufruf steckt.

Magic-Commands

Eine der bekanntesten Besonderheiten von IPython sind die Magics. Line-Magics beginnen mit %, Cell-Magics mit %%.

Einige Beispiele:

In [5]: %timeit sum(range(1000))

In [6]: %run dungeon.py

In [7]: %history

In [8]: %edit

%timeit führt einen Ausdruck mehrfach aus und ermittelt daraus eine aussagekräftigere Laufzeit als eine einzelne Messung mit der Stoppuhr.

Weitere nützliche Magics sind:

Mit einem Fragezeichen bekommst Du auch Hilfe zu einer Magic:

In [9]: %timeit?

Nach einer Exception direkt debuggen

Eine besonders praktische Funktion geht zwischen den bekannteren Magics leicht unter: %debug.

Angenommen, ein Aufruf schlägt fehl:

In [10]: int("Dungeon")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[10], line 1
----> 1 int("Dungeon")

ValueError: invalid literal for int() with base 10: 'Dungeon'

Danach kannst Du direkt Folgendes eingeben:

In [11]: %debug

IPython startet den Python-Debugger am Ort der Exception. Dort kannst Du Variablen untersuchen, den Stack entlanggehen und Dir den Zustand des Programms ansehen.

Bei Fehlern in eigenen Funktionen ist das oft wesentlich hilfreicher, als zusätzliche print()-Aufrufe in den Code einzubauen.

Automatisches Reloading von Modulen

Wenn Du parallel in einem Editor an einem eigenen Modul arbeitest, ist die autoreload-Extension praktisch:

In [12]: %load_ext autoreload

In [13]: %autoreload 2

Mit %autoreload 2 versucht IPython, importierte Module vor der nächsten Code-Ausführung automatisch neu zu laden.

Du kannst also beispielsweise dungeon.py im Editor verändern und anschließend in derselben IPython-Session weiterarbeiten, ohne nach jeder Änderung die Shell neu zu starten.

Das funktioniert erstaunlich gut, hat aber Grenzen. Änderungen an Klassen, Properties oder C-Extensions können sich nicht immer sauber in eine bereits laufende Session übertragen. Wenn sich ein Objekt plötzlich anders verhält als erwartet, ist ein kompletter Neustart weiterhin die zuverlässigste Methode für einen sauberen State.

Shell-Kommandos ausführen

Mit einem Ausrufezeichen kannst Du Befehle an die System-Shell weiterreichen:

In [14]: !python --version
Python 3.14.7

Unter Linux und macOS kannst Du beispielsweise den Inhalt des aktuellen Verzeichnisses anzeigen:

In [15]: !ls

Unter Windows:

In [15]: !dir

Diese Eingaben sind kein Python-Code. Das ! ist IPython-Syntax und weist IPython an, den Rest der Zeile an die System-Shell weiterzugeben.

Das Ergebnis lässt sich sogar einer Variable zuweisen:

In [16]: dateien = !ls

In [17]: dateien
Out[17]: [...]

Damit verschwimmt die Grenze zwischen Python-Session und Shell ein Stück weit, was bei kleinen Entwicklungs- und Analyseaufgaben ziemlich praktisch sein kann.

ptpython: Eine REPL mit Editor-Gefühl

ptpython legt den Schwerpunkt stärker auf Eingabe und Bearbeitung von Code. Es basiert auf prompt_toolkit und bietet unter anderem:

• Syntax-Highlighting
• Autocompletion
• komfortables Multiline-Editing
• eine durchsuchbare History
• verschiedene Farbschemas
• Mausunterstützung
• Vi- und Emacs-Keybindings
• Bracketed Paste in unterstützten Terminals

Du installierst ptpython mit:

python -m pip install ptpython

Danach startest Du die Shell mit:

ptpython

Beim Tippen zeigt ptpython mögliche Vervollständigungen direkt an. Mehrzeilige Inputs lassen sich eher wie in einem kleinen Editor bearbeiten als in einer klassischen Shell.

Interessant ist ptpython vor allem, wenn Du viel direkt in der REPL schreibst, starke Autocompletion möchtest oder mit Vi- beziehungsweise Emacs-Keybindings arbeitest.

Wer nur gelegentlich einen Ausdruck ausprobiert, braucht diesen zusätzlichen Komfort dagegen kaum.

IPython und ptpython kombinieren

ptpython kann auch als Frontend für IPython verwendet werden. Dadurch bekommst Du die Magics und weiteren Funktionen von IPython zusammen mit der Oberfläche von ptpython.

Dafür installierst Du beide Pakete:

python -m pip install ipython ptpython

Anschließend startest Du:

ptipython

Damit erhältst Du im Wesentlichen IPython mit dem Editing und der Autocompletion von ptpython.

Ob sich die Kombination lohnt, hängt vom eigenen Workflow ab. Für die meisten Aufgaben reicht IPython oder ptpython allein.

Welche REPL solltest Du verwenden?

Für den Einstieg und kurze Tests ist die eingebaute REPL die naheliegende Wahl. Seit Python 3.13 fehlen ihr viele Komfortfunktionen nicht mehr, für die früher schnell eine alternative Shell installiert wurde.

IPython lohnt sich, wenn Du länger interaktiv arbeitest, Code untersuchst, Benchmarks ausführst oder direkt aus einer Session heraus debuggen möchtest.

ptpython richtet sich eher an Leute, denen das Editieren und Navigieren innerhalb der Shell besonders wichtig ist.

Du musst Dich dabei nicht auf eine einzige Variante festlegen. Auf meinem Rechner kann die normale REPL genauso ihren Platz haben wie IPython für längere Sessions.

Stolperfallen

• _ selbst überschreiben: In der normalen REPL verweist _ auf das letzte ausgegebene Ergebnis. Eine eigene Zuweisung an _ überdeckt dieses Verhalten.

• REPL-Prompts in ein Skript kopieren: >>>, ..., In [1]: und Out[1]: gehören zur jeweiligen Shell und nicht in eine Python-Datei.

• IPython-Magics in normalem Python verwenden: %timeit, %run, %debug und andere Magics sind keine normale Python-Syntax. Sie funktionieren nur in IPython oder einer kompatiblen Umgebung.

• Shell-Kommandos mit Python-Code verwechseln: Eine Eingabe wie !ls wird von IPython an die System-Shell weitergegeben. Auch das ist keine Python-Syntax.

• Den State einer langen Session vergessen: Variablen, Imports und andere Änderungen bleiben in einer laufenden REPL erhalten. Dadurch kann Code funktionieren, obwohl ein dafür notwendiger Schritt schon vor einer Stunde ausgeführt wurde. Wenn das Verhalten nicht mehr nachvollziehbar ist, hilft ein Neustart mit sauberem State.

• autoreload blind vertrauen: Nicht jede Änderung an einem Modul lässt sich zuverlässig in eine laufende Session übertragen. Bei merkwürdigen Effekten ist ein Neustart häufig schneller als die Fehlersuche im alten State.

Weiterlesen

• Python lernen, Teil 1: Installation und erstes Programm
• PEP 762 – REPL-acing the default REPL
• What’s New In Python 3.13
• What’s New In Python 3.14
• IPython-Dokumentation
• ptpython auf GitHub