Fehlerbehandlung: try-except-finally

Selbst der beste Code stürzt manchmal ab – jemand gibt „abc" ein wo eine Zahl erwartet wird, eine Datei existiert nicht, eine Internet-Verbindung bricht ab, eine Berechnung teilt durch null. Wenn dein Programm so etwas nicht abfangen kann, crasht es einfach. Genau dafür gibt es Exception Handling: ein eingebautes System um Fehler kontrolliert zu behandeln statt von ihnen überrascht zu werden.

Python folgt dabei einer eigenen Philosophie die sich von Java unterscheidet: „Es ist einfacher um Vergebung zu bitten als um Erlaubnis". Heißt: erst versuchen, dann reagieren wenn was schiefläuft. Statt vor jedem Schritt zu prüfen ob alles OK ist. Diese Haltung („EAFP" – Easier to Ask Forgiveness than Permission) ist sehr pythonic.

1) Was ist eine Exception?

Wenn etwas schiefgeht „wirft" (raise) Python eine Exception – ein spezielles Objekt das den Fehler beschreibt. Wenn nichts diese Exception abfängt, „propagiert" sie nach oben durch alle aufrufenden Funktionen bis zum Programm-Start. Dann sieht der Benutzer eine hässliche Fehlermeldung wie diese – ein sogenannter Traceback:

Traceback (most recent call last):

File "rechner.py", line 12, in <module>

ergebnis = berechne(zahl)

File "rechner.py", line 5, in berechne

return 100 / x

ZeroDivisionError: division by zero

Tracebacks liest man von unten nach oben: ganz unten steht WAS passiert ist (ZeroDivisionError), darüber WO im Code – mit den Funktionsaufrufen die dahin geführt haben (siehe Funktionen-Lektion). Die unterste Datei/Zeile ist der eigentliche Ort des Fehlers. Wer Tracebacks fließend lesen kann, debuggt viel schneller.

2) Die wichtigsten eingebauten Exceptions

Python hat dutzende eingebaute Exception-Typen, die hierarchisch organisiert sind. Hier die wichtigsten – klicke einen Knoten für Details und ein Beispiel wann sie auftritt:

Pythons Exception-Hierarchie (Ausschnitt)

Exception

ArithmeticError

LookupError

ValueError

TypeError

OSError

ZeroDivisionError

IndexError

KeyError

NameError

AttributeError

FileNotFoundError

← Klick auf einen Exception-Typ.

Die ganz oben stehende Exception ist die Basis aller „normalen" Fehler. Darunter Kategorien (ArithmeticError, LookupError, ...), darunter die konkreten Fehler. Wenn du except Exception: schreibst, fängst du ALLE diese Fehler – das ist meistens zu breit. Lieber den spezifischen Typ angeben um nicht unbeabsichtigt Programmierfehler zu schlucken.

3) try-except: der Schutzring

Die Grundstruktur: Code der schiefgehen könnte packst du in einen try-Block. Was passieren soll wenn etwas schiefgeht, kommt in except. Du kannst dabei nach Exception-Typ unterscheiden:

try: alter = int(input("Alter: ")) print(f"In 10 Jahren: {alter + 10}") except ValueError: print("Das war keine gültige Zahl!")

Wenn der Benutzer „25" eingibt → alles läuft. Tippt er „abc" → int() wirft ValueError, der except-Block fängt das ab, das Programm bricht nicht ab. Du kannst auch mehrere except-Blöcke für verschiedene Fehler haben:

try: zahlen = [10, 20, 30] idx = int(input("Index: ")) print(100 / zahlen[idx]) except ValueError: print("Bitte eine Zahl eingeben.") except IndexError: print("Index außerhalb der Liste.") except ZeroDivisionError: print("Wert an dieser Position ist 0.")

4) Live-Tracer: try-except in Aktion

Wähle ein Szenario und klicke dich durch um zu sehen welcher Pfad genommen wird:

try-except-Tracer – Szenario wählen

Szenario:

Ablauf

Ausgabe

–

Beachte: der finally-Block läuft IMMER – egal ob es einen Fehler gab oder nicht, egal ob er gefangen wurde oder durchrauscht. Perfekt für Aufräumarbeiten (Datei schließen, Datenbankverbindung freigeben). Der else-Block (selten genutzt) läuft nur wenn KEIN Fehler im try aufgetreten ist. So unterscheidest du „erfolgreich gelaufen" von „abgefangen". Ein vollständiges try-Konstrukt kann alle vier Blöcke haben: try / except / else / finally.

5) Die Exception abfangen UND auslesen mit „as"

Wenn du den Fehler-Details brauchst (z.B. für Logging), kannst du die Exception in eine Variable schreiben:

try: n = int("abc") except ValueError as e: print(f"Fehler beim Parsen: {e}") # Ausgabe: Fehler beim Parsen: invalid literal for int() with base 10: 'abc'

Mehrere Exception-Typen im selben Block fangen geht mit einem Tupel:

try: daten = riskante_operation() except (ValueError, TypeError, KeyError) as e: print(f"Datenfehler: {e}")

6) Eigene Exceptions werfen mit raise

Manchmal willst du selbst einen Fehler signalisieren – etwa wenn ein Parameter nicht stimmt. Dafür gibt's raise:

def berechne_alter(geburtsjahr): if geburtsjahr < 1900 or geburtsjahr > 2026: raise ValueError(f"Ungültiges Jahr: {geburtsjahr}") return 2026 - geburtsjahr # Eigene Exception-Klasse class MeineException(Exception): pass raise MeineException("Etwas Spezielles")

Eigene Exception-Klassen erstellst du indem du von Exception erbst – mehr zu Klassen-Vererbung lernst du in K41b. Für kleine Programme reicht oft das einfache raise ValueError("...") mit einer aussagekräftigen Nachricht.

7) Pythonic: EAFP vs LBYL

Zwei Stile gegen Fehler vorzugehen:

Zwei Philosophien

✓ EAFP (pythonic)

„Easier to Ask Forgiveness than Permission" – mach es einfach und reagiere auf Fehler.

try:
wert = d["name"]
except KeyError:
wert = "unbekannt"

LBYL (eher Java/C)

„Look Before You Leap" – prüfen bevor man etwas macht.

if "name" in d:
wert = d["name"]
else:
wert = "unbekannt"

Beide Stile funktionieren – aber EAFP ist in Python typischer und manchmal sogar schneller (weil keine Prüfung im Erfolgsfall passiert). Bei Datei-Operationen besonders sinnvoll: zwischen „Datei existiert?"-Prüfung und „Datei öffnen" könnte jemand die Datei löschen (Race Condition). Mit try-except ist das egal.

8) Wichtige Fehlerbehandlungs-Patterns

Drei Muster solltest du auswendig kennen:

Muster	Wann?	Wie?
Spezifische Exceptions fangen	Eine konkrete Fehlerart erwartet	`except ValueError:`
Mehrere fangen	Verschiedene Reaktionen nötig	Mehrere except-Blöcke
finally für Cleanup	Ressourcen müssen freigegeben werden	`finally:` oder besser noch: `with` (siehe L9)
Loop bis valid	Benutzer-Eingabe wiederholt versuchen	while True + try-except + return/break
❌ Bare except	Niemals (außer ganz oben in main)	`except:` ohne Typ fängt ALLES – sogar KeyboardInterrupt

Zusammenfassung

Exception = Objekt das einen Fehler beschreibt. Wirft sich von selbst (oder per raise), wandert durch den Call-Stack bis abgefangen → sonst Crash mit Traceback. try-except: try: ... except Typ: .... Optional else (kein Fehler), finally (immer). Wichtigste Typen: ValueError, TypeError, KeyError, IndexError, ZeroDivisionError, FileNotFoundError, AttributeError, NameError. Fehler in Variable: except X as e:. Mehrere Typen: except (X, Y):. raise Type("msg") wirft eigenen Fehler. EAFP ist pythonic: erst versuchen, dann reagieren. Bare except niemals nutzen!