REPL und Skripte

Python bietet dir zwei Wege, Code auszufuehren: die interaktive REPL und Skriptdateien (.py). Beide haben ihre Staerken, und als Python-Entwickler wirst du beide regelmaessig nutzen. In diesem Kapitel lernst du, wann du welchen Weg waehlen solltest.

Was ist die REPL?

REPL steht fuer Read-Eval-Print-Loop — auf Deutsch: Lesen-Auswerten-Ausgeben-Wiederholen. Es ist ein interaktiver Modus, in dem Python deinen Code Zeile fuer Zeile ausfuehrt und dir sofort das Ergebnis zeigt.

+------------------------------+
|  Read   -- Eingabe lesen     |
|  Eval   -- Code auswerten    |
|  Print  -- Ergebnis ausgeben |
|  Loop   -- Von vorne!        |
+------------------------------+

Die REPL ist wie ein Gespraech mit Python — du sagst etwas, Python antwortet sofort.

REPL starten

Oeffne ein Terminal (in VS Code: Ctrl + `) und tippe:

python

Auf macOS/Linux eventuell:

python3

Du siehst die Python-Eingabeaufforderung:

Python 3.12.x (main, ...) [...]
Type "help", "copyright", "credits" or "license" for more information.
>>>

Die drei Pfeile >>> sind der Prompt — hier gibst du deinen Code ein.

Arbeiten mit der REPL

Einfache Berechnungen

Die REPL ist ein maechtigster Taschenrechner:

>>> 2 + 3
5
>>> 10 * 7
70
>>> 100 / 3
33.333333333333336
>>> 2 ** 10
1024
>>> 17 % 5
2

Beachte: Du brauchst kein print() — die REPL zeigt das Ergebnis automatisch an!

Variablen nutzen

>>> name = "Python"
>>> version = 3.12
>>> print(f"Willkommen bei {name} {version}!")
Willkommen bei Python 3.12!
>>> laenge = 10
>>> breite = 5
>>> flaeche = laenge * breite
>>> flaeche
50

Variablen bleiben erhalten, solange die REPL-Sitzung laeuft.

Typen untersuchen

Die REPL ist perfekt, um Datentypen zu erforschen:

>>> type(42)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("Hallo")
<class 'str'>
>>> type(True)
<class 'bool'>
>>> type([1, 2, 3])
<class 'list'>

Hilfe aufrufen

>>> help(print)
Help on built-in function print in module builtins:

print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream...

>>> help(str.upper)
Help on method_descriptor:

upper(self, /)
    Return a copy of the string converted to uppercase.

Druecke q, um die Hilfe zu verlassen.

Mehrzeilige Anweisungen

Fuer mehrzeiligen Code zeigt die REPL ... als Fortsetzungszeichen:

>>> if 5 > 3:
...     print("Fuenf ist groesser!")
...     print("Logisch, oder?")
...
Fuenf ist groesser!
Logisch, oder?

Wichtig: Nach dem letzten ... musst du eine leere Zeile eingeben (einfach Enter druecken), damit Python den Block ausfuehrt.

>>> for i in range(5):
...     print(f"Zahl: {i}")
...
Zahl: 0
Zahl: 1
Zahl: 2
Zahl: 3
Zahl: 4

Listen und andere Datenstrukturen testen

>>> fruechte = ["Apfel", "Banane", "Kirsche"]
>>> fruechte
['Apfel', 'Banane', 'Kirsche']
>>> fruechte.append("Mango")
>>> fruechte
['Apfel', 'Banane', 'Kirsche', 'Mango']
>>> len(fruechte)
4
>>> "Banane" in fruechte
True
>>> fruechte[0]
'Apfel'
>>> fruechte[-1]
'Mango'

Vorteile der REPL

Die REPL ist hervorragend fuer bestimmte Aufgaben:

Vorteil	Beschreibung
Schnelles Testen	Eine Idee sofort ausprobieren, ohne Datei zu erstellen
Experimentieren	Neue Funktionen und Bibliotheken erkunden
Debugging	Einzelne Code-Zeilen isoliert testen
Lernen	Sofortiges Feedback beim Lernen neuer Konzepte
Berechnungen	Python als intelligenten Taschenrechner nutzen

Beispiel: Schnell etwas ausprobieren

Du fragst dich: “Wie funktioniert nochmal str.split()?”

>>> "Hallo Welt Python".split()
['Hallo', 'Welt', 'Python']
>>> "eins,zwei,drei".split(",")
['eins', 'zwei', 'drei']
>>> "  viele   leerzeichen  ".split()
['viele', 'leerzeichen']

In 10 Sekunden hast du deine Antwort — ohne eine Datei zu oeffnen.

Die REPL verlassen

>>> exit()

Oder druecke Ctrl + D (Linux/macOS) bzw. Ctrl + Z + Enter (Windows).

REPL vs. Skriptdateien

Jetzt schauen wir uns den anderen Weg an: Skriptdateien.

Die Unterschiede auf einen Blick

Aspekt	REPL	Skriptdatei (.py)
Ausfuehrung	Zeile fuer Zeile	Gesamte Datei auf einmal
Ergebnis anzeigen	Automatisch	Nur mit print()
Code speichern	Nein (geht verloren)	Ja (dauerhaft)
Geeignet fuer	Testen, Experimentieren	Programme, Projekte
Mehrzeiliger Code	Umstaendlich	Einfach
Fehlersuche	Schwierig	Einfacher mit Debugger

Der wichtigste Unterschied

In der REPL wird das Ergebnis automatisch angezeigt:

>>> 2 + 3
5           # <-- Wird automatisch angezeigt

In einem Skript musst du print() verwenden:

# skript.py
2 + 3       # Keine Ausgabe! Ergebnis geht verloren
print(2 + 3)  # 5 -- Jetzt wird es angezeigt

.py Dateien erstellen und ausfuehren

Schritt 1: Datei erstellen

Erstelle eine Datei mit der Endung .py — zum Beispiel mein_programm.py:

# mein_programm.py

# Variablen definieren
name = "Python-Lerner"
tage = 1

# Begruessung
print(f"Hallo, {name}!")
print(f"Du lernst seit {tage} Tag(en) Python.")

# Berechnung
stunden_pro_tag = 2
gesamt_stunden = tage * stunden_pro_tag
print(f"Geschaetzte Lernzeit: {gesamt_stunden} Stunden")

# Liste von Themen
themen = [
    "REPL und Skripte",
    "Variablen und Datentypen",
    "Kontrollstrukturen",
    "Funktionen",
]

print(f"\nNoch {len(themen)} Themen vor dir:")
for i, thema in enumerate(themen, 1):
    print(f"  {i}. {thema}")

print("\nWeiter so!")

Schritt 2: Skript ausfuehren

Im Terminal:

python mein_programm.py

In VS Code:

• Oeffne die Datei
• Klicke den gruenen Play-Button oben rechts
• Oder: Rechtsklick -> “Run Python File in Terminal”

Ausgabe:

Hallo, Python-Lerner!
Du lernst seit 1 Tag(en) Python.
Geschaetzte Lernzeit: 2 Stunden

Noch 4 Themen vor dir:
  1. REPL und Skripte
  2. Variablen und Datentypen
  3. Kontrollstrukturen
  4. Funktionen

Weiter so!

Ein ausfuehrlicheres Beispiel

# quiz.py -- Ein einfaches Quiz-Programm

print("=" * 40)
print("  Python-Quiz: REPL-Wissen")
print("=" * 40)
print()

punkte = 0

# Frage 1
print("Frage 1: Wofuer steht REPL?")
print("  a) Read-Eval-Print-Loop")
print("  b) Run-Execute-Process-Load")
print("  c) Read-Edit-Program-Launch")
antwort = input("\nDeine Antwort (a/b/c): ").lower()
if antwort == "a":
    print("Richtig!\n")
    punkte += 1
else:
    print("Falsch! Richtig ist: Read-Eval-Print-Loop\n")

# Frage 2
print("Frage 2: Was zeigt die REPL automatisch an?")
print("  a) Fehlermeldungen")
print("  b) Das Ergebnis von Ausdruecken")
print("  c) Den Quellcode")
antwort = input("\nDeine Antwort (a/b/c): ").lower()
if antwort == "b":
    print("Richtig!\n")
    punkte += 1
else:
    print("Falsch! Richtig ist: Das Ergebnis von Ausdruecken\n")

# Frage 3
print("Frage 3: Wie startet man die Python-REPL?")
print("  a) start python")
print("  b) python --repl")
print("  c) python")
antwort = input("\nDeine Antwort (a/b/c): ").lower()
if antwort == "c":
    print("Richtig!\n")
    punkte += 1
else:
    print("Falsch! Richtig ist: Einfach 'python' im Terminal\n")

# Ergebnis
print("=" * 40)
print(f"Ergebnis: {punkte}/3 Punkten")
if punkte == 3:
    print("Perfekt! Du kennst dich aus!")
elif punkte >= 2:
    print("Gut gemacht! Fast alles richtig.")
else:
    print("Lies das Kapitel nochmal durch!")
print("=" * 40)

Die Shebang-Zeile

Auf Linux und macOS kannst du Python-Skripte direkt ausfuehrbar machen, ohne python davor zu tippen. Dafuer brauchst du eine Shebang-Zeile ganz oben in der Datei:

#!/usr/bin/env python3

# mein_skript.py
print("Dieses Skript ist direkt ausfuehrbar!")

Was bedeutet das?

#!/usr/bin/env python3
^  ^               ^
|  |               |
|  |               +-- Programm: python3
|  +-- Suche im PATH nach...
+-- "Shebang" -- sagt dem System, welcher Interpreter genutzt werden soll

Skript ausfuehrbar machen (Linux/macOS)

# Ausfuehrbarkeitsflag setzen
chmod +x mein_skript.py

# Direkt ausfuehren -- ohne "python" davor!
./mein_skript.py

Warum #!/usr/bin/env python3 statt #!/usr/bin/python3?

#!/usr/bin/env python3     # GUT: Sucht python3 im PATH
#!/usr/bin/python3         # SCHLECHT: Fester Pfad, der sich unterscheiden kann

env sorgt dafuer, dass der Python-Interpreter gefunden wird, egal wo er installiert ist. Das ist wichtig, weil Python auf verschiedenen Systemen an verschiedenen Orten liegt.

Hinweis fuer Windows-Nutzer: Unter Windows funktioniert die Shebang-Zeile nicht direkt. Du fuehrst Skripte immer mit python datei.py aus. Die Shebang-Zeile stoert aber auch nicht — Python ignoriert sie unter Windows einfach. Es ist trotzdem gute Praxis, sie zu verwenden, falls dein Code auch auf Linux oder macOS laufen soll.

Wann REPL, wann Skript?

Hier eine praktische Entscheidungshilfe:

Nutze die REPL, wenn du…

# ...schnell etwas berechnen willst
>>> 1920 * 1080
2073600

# ...eine Funktion ausprobieren willst
>>> "hallo welt".title()
'Hallo Welt'

# ...einen Datentyp untersuchen willst
>>> dir(str)
['__add__', '__class__', ... 'upper', 'zfill']

# ...eine Bibliothek erkundest
>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(144)
12.0

Nutze ein Skript, wenn du…

• Code speichern und wiederverwenden willst
• Mehrzeiligen Code schreibst (mehr als 5-10 Zeilen)
• Ein Programm baust, das andere nutzen koennen
• Imports und Funktionen organisieren musst
• Code mit anderen teilen willst
• Version Control (Git) nutzen willst

Die Kombination ist der Schluessel

Erfahrene Python-Entwickler nutzen beide staendig:

1. Idee in der REPL testen
2. Funktionierender Code ins Skript uebertragen
3. Komplexere Logik im Skript entwickeln
4. Bei Problemen: Einzelne Zeilen in der REPL debuggen

Das if __name__ == "__main__" Pattern

Dieses Pattern wirst du in vielen Python-Dateien sehen. Es ist eines der wichtigsten Muster in Python.

Was bedeutet es?

# rechner.py

def addiere(a, b):
    """Addiert zwei Zahlen."""
    return a + b

def subtrahiere(a, b):
    """Subtrahiert b von a."""
    return a - b

# Dieser Block wird NUR ausgefuehrt,
# wenn die Datei DIREKT gestartet wird
if __name__ == "__main__":
    print("Rechner wird getestet...")
    print(f"3 + 4 = {addiere(3, 4)}")
    print(f"10 - 3 = {subtrahiere(10, 3)}")

Wie funktioniert das?

Jede Python-Datei hat eine spezielle Variable __name__:

• Wenn du die Datei direkt ausfuehrst (python rechner.py), ist __name__ gleich "__main__"
• Wenn die Datei von einer anderen Datei importiert wird, ist __name__ gleich dem Dateinamen (z.B. "rechner")

Praktisches Beispiel

rechner.py:

def addiere(a, b):
    return a + b

def subtrahiere(a, b):
    return a - b

if __name__ == "__main__":
    # Wird NUR beim direkten Aufruf ausgefuehrt
    print("Test: 3 + 4 =", addiere(3, 4))

hauptprogramm.py:

# Importiere die Funktionen aus rechner.py
from rechner import addiere, subtrahiere

# Nutze die Funktionen
ergebnis = addiere(10, 20)
print(f"10 + 20 = {ergebnis}")

# Der "if __name__" Block aus rechner.py wird NICHT ausgefuehrt!

Warum ist das nuetzlich?

python rechner.py        -->  __name__ ist "__main__"  -->  Test wird ausgefuehrt
import rechner           -->  __name__ ist "rechner"   -->  Test wird NICHT ausgefuehrt

So kannst du:

1. Funktionen definieren, die andere Dateien nutzen koennen
2. Testcode schreiben, der nur beim direkten Aufruf laeuft
3. Module erstellen, die sowohl eigenstaendig als auch als Import funktionieren

Einfache Faustregel

Verwende if __name__ == "__main__": in jeder Datei, die sowohl als eigenstaendiges Programm als auch als Import-Modul funktionieren soll. Fuer reine Skripte, die nie importiert werden, ist es optional — aber trotzdem guter Stil.

#!/usr/bin/env python3
# mein_werkzeug.py

"""Ein kleines Werkzeug fuer Textumwandlung."""

def grossbuchstaben(text):
    """Wandelt Text in Grossbuchstaben um."""
    return text.upper()

def wort_zaehlen(text):
    """Zaehlt die Woerter in einem Text."""
    return len(text.split())

def zeilen_zaehlen(text):
    """Zaehlt die Zeilen in einem Text."""
    return len(text.splitlines())

if __name__ == "__main__":
    # Interaktiver Modus, wenn direkt ausgefuehrt
    print("=== Text-Werkzeug ===")
    text = input("Gib einen Text ein: ")
    print(f"Grossbuchstaben: {grossbuchstaben(text)}")
    print(f"Anzahl Woerter: {wort_zaehlen(text)}")

IPython: Die verbesserte REPL

Wenn du die Standard-REPL magst, wirst du IPython lieben. Es ist eine erweiterte REPL mit vielen zusaetzlichen Features:

# IPython installieren
pip install ipython

# IPython starten
ipython

Was IPython besser kann

# Syntax-Highlighting und Autovervollstaendigung
In [1]: "hallo".<TAB>
# Zeigt alle String-Methoden an!

# Eingebaute Hilfe mit ?
In [2]: len?
# Zeigt Dokumentation an

# Shell-Befehle mit !
In [3]: !ls
# Zeigt Dateien an

# Vorherige Ergebnisse mit _
In [4]: 2 + 3
Out[4]: 5
In [5]: _ * 2
Out[5]: 10

Zusammenfassung

• Die REPL (Read-Eval-Print-Loop) ist Pythons interaktiver Modus
• Starte sie mit python im Terminal — perfekt zum Testen und Experimentieren
• Skriptdateien (.py) sind fuer dauerhaften, wiederverwendbaren Code
• In Skripten brauchst du print() fuer Ausgaben — die REPL zeigt Ergebnisse automatisch
• Die Shebang-Zeile (#!/usr/bin/env python3) macht Skripte auf Linux/macOS direkt ausfuehrbar
• if __name__ == "__main__": trennt Import-Code von Ausfuehrungs-Code
• Nutze beide Werkzeuge: REPL zum Testen, Skripte zum Bauen

Naechster Schritt: Jetzt wo du die Grundwerkzeuge kennst, tauchen wir im naechsten Kapitel tief in Variablen und Datentypen ein — das Fundament jedes Python-Programms!

---