Python Exception Handling: try except finally einfach erklärt

Dein Programm läuft, der Anwender tippt eine Zahl ein - und gibt versehentlich `"drei"` statt `3` ein. Ohne Python Exception Handling stürzt dein Programm kommentarlos ab. Damit fängst du den Fehler ab, zeigst eine verständliche Meldung und das Programm läuft weiter. Genau das lernst du hier - egal ob du gerade deine Ausbildung als Fachinformatiker machst, im Studium sitzt oder in deinen ersten Job startest.

Exception Handling ist der Mechanismus in Python, mit dem du Laufzeitfehler (sogenannte Exceptions) abfängst und kontrolliert behandelst, statt das Programm abstürzen zu lassen.

Stell es dir wie ein Sicherheitsnetz beim Trapez vor: Der Fehler passiert, aber dein Programm fällt nicht in den Abgrund.

Was ist eine Exception in Python?

Eine Exception ist ein Fehler, der zur Laufzeit auftritt - also während dein Programm ausgeführt wird. Python bricht an dieser Stelle normalerweise ab und gibt eine Fehlermeldung aus.

Typische Beispiele aus dem Alltag:

zahl = int("drei")  # ValueError: invalid literal for int()
liste = [1, 2, 3]
print(liste[10])  # IndexError: list index out of range
print(10 / 0)  # ZeroDivisionError: division by zero

Jede Exception hat einen Namen (z. B. `ValueError`) und eine Beschreibung. Diese Namen brauchst du gleich - denn über sie fängst du gezielt ab. Eine Übersicht aller eingebauten Exceptions findest du in der offiziellen Python-Dokumentation.

Wie funktioniert try except?

Mit `try` und `except` sagst du Python: "Versuch diesen Code - und wenn ein bestimmter Fehler passiert, reagiere so." Der riskante Code kommt in den `try`-Block, die Fehlerbehandlung in den `except`-Block.

eingabe = input("Bitte Zahl eingeben: ")

try:
    zahl = int(eingabe)
    print("Danke! Dein Doppeltes:", zahl * 2)
except ValueError:
    print("Das war keine Zahl. Bitte erneut versuchen.")

Läuft der `try`-Block fehlerfrei durch, wird `except` komplett ignoriert. Knallt es dagegen mit einem `ValueError`, springt Python direkt in den `except`-Block. Dein Programm läuft danach normal weiter.

Merke: Code im `try`-Block wird ausgeführt, bis der erste Fehler auftritt. Alles danach im Block wird übersprungen.

Mehrere Exceptions abfangen

Oft können unterschiedliche Fehler auftreten. Dafür hast du zwei Möglichkeiten - mehrere `except`-Blöcke oder ein Tuple:

def lies_zahl(text):
    try:
        return int(text)
    except ValueError:
        print("Keine gueltige Zahl:", text)
        return None
    except TypeError:
        print("Falscher Datentyp uebergeben")
        return None

# Kurze Variante mit Tuple: mehrere Exceptions, gleiche Reaktion
try:
    ergebnis = 10 / int("0")
except (ValueError, ZeroDivisionError) as fehler:
    print("Fehler aufgetreten:", fehler)

Das `as fehler` speichert dir das Exception-Objekt in einer Variable - damit kannst du die originale Fehlermeldung ausgeben, was beim Debuggen Gold wert ist.

Wann läuft finally - und was macht else?

`finally` definiert einen Block, der immer ausgeführt wird - egal ob ein Fehler auftrat, ob er gefangen wurde oder ob dein `except` selbst einen neuen Fehler wirft. Klassiker sind Aufräumarbeiten wie das Schließen von Dateien oder Verbindungen.

def datei_lesen(pfad):
    try:
        datei = open(pfad, "r")
        inhalt = datei.read()
        print(inhalt[:50])
    except FileNotFoundError:
        print("Datei nicht gefunden:", pfad)
    finally:
        print("Aufraeumen: finally laeuft immer.")
        datei.close()  # Achtung: siehe Fehler Nr. 2 unten

Der `else`-Block ist das Gegenstück: Er läuft nur, wenn im `try`-Block kein Fehler aufgetreten ist.

try:
    zahl = int(input("Zahl: "))
except ValueError:
    print("Keine Zahl!")
else:
    print("Super, deine Zahl:", zahl)  # laeuft nur ohne Fehler
finally:
    print("Fertig.")  # laeuft immer

So hängt alles zusammen:

Merke: `finally` läuft garantiert - selbst wenn im `except`-Block ein neuer Fehler geworfen wird. Perfekt fürs Aufräumen.

Wie wirfst du eigene Exceptions mit raise?

Mit `raise` löst du selbst eine Exception aus. Das nutzt du, wenn dein Code einen ungültigen Zustand erkennt - etwa eine Funktion, die nur positive Zahlen akzeptiert.

def wurzel_berechnen(wert):
    if wert < 0:
        raise ValueError(f"Negative Zahlen sind hier nicht erlaubt: {wert}")
    return wert**0.5


try:
    print(wurzel_berechnen(-4))
except ValueError as e:
    print("Abgefangen:", e)

Warum? Weil ein Fehler früh und deutlich geworfen werden sollte, statt mit unsinnigen Werten still weiterzurechnen. Falsche Eingaben solltest du vorher validieren - wie du `None`-Werte dabei sicher behandelst, zeigt unser Artikel Python None Optional: None-Werte sicher behandeln.

Praxisbeispiel: Robuste Benutzereingabe

Hier siehst du ein vollständiges Beispiel, wie du es in einem echten Projekt oder deiner IHK-Aufgabe umsetzen könntest:

def zahl_abfragen():
    """Fragt so lange, bis eine gueltige Zahl eingegeben wurde."""
    while True:
        eingabe = input("Bitte eine Zahl eingeben (oder 'q' fuer Ende): ")
        if eingabe.lower() == "q":
            return None
        try:
            return float(eingabe)
        except ValueError:
            print("Das war keine Zahl. Versuch es nochmal.")


def division_sicher():
    print("Division zweier Zahlen")
    a = zahl_abfragen()
    if a is None:
        print("Abgebrochen.")
        return
    b = zahl_abfragen()
    if b is None:
        print("Abgebrochen.")
        return

    try:
        ergebnis = a / b
    except ZeroDivisionError:
        print("Division durch Null ist nicht moeglich.")
        return
    finally:
        print("Berechnung abgeschlossen.")
    print("Ergebnis:", ergebnis)


division_sicher()

Beachte die Reihenfolge: `finally` läuft vor dem letzten `print`, auch bei Fehlern. `ergebnis` existiert nur, wenn keine Exception auftrat - deshalb steht das letzte `print` nach dem `try`-Konstrukt und wird nur im Erfolgsfall mit korrektem Wert erreicht.

Welche 3 Anfängerfehler solltest du vermeiden?

Diese drei Fehler tauchen bei Einsteigern ständig auf - merk sie dir am besten gleich mit.

Fehler 1: Das nackte except

# FALSCH: faengt ALLES ab, auch Tippfehler im Code
try:
    wert = int(eingabe)
except:
    print("Irgendwas ist schiefgelaufen")

# RICHTIG: gezielt die erwartete Exception fangen
try:
    wert = int(eingabe)
except ValueError:
    print("Bitte eine Zahl eingeben.")

Warum ist das nackte `except` so schlimm? Weil es auch `KeyboardInterrupt` (Strg+C) und `TypeError` schluckt. Du merkst dann nicht mal, wenn dein eigener Code einen Bug hat.

Faustregel: Fang immer die spezifischste Exception, die du erwartest - nie das nackte `except`.

Fehler 2: finally mit potenziell ungebundener Variable

# FALSCH: datei existiert nicht -> close() crasht im finally
try:
    datei = open(pfad, "r")
except FileNotFoundError:
    print("Nicht gefunden")
finally:
    datei.close()

# RICHTIG: with schliesst die Datei automatisch
try:
    with open(pfad, "r") as datei:
        inhalt = datei.read()
except FileNotFoundError:
    print("Nicht gefunden")

Das `with`-Statement schließt die Datei garantiert - auch bei Fehlern. Es ersetzt dein manuelles `close()` komplett.

Fehler 3: Falsche Reihenfolge bei Vererbung

Exceptions haben eine Hierarchie: `ZeroDivisionError` ist z. B. ein Spezialfall von `ArithmeticError`. Fängst du zuerst die allgemeine Exception, erreicht die spezielle nie ihren Block:

# FALSCH: der zweite Block ist unerreichbar
try:
    x = 1 / 0
except ArithmeticError:
    print("Allgemeiner Rechenfehler")
except ZeroDivisionError:  # wird nie erreicht!
    print("Division durch Null")

# RICHTIG: speziell zuerst, allgemein danach
try:
    x = 1 / 0
except ZeroDivisionError:
    print("Division durch Null")
except ArithmeticError:
    print("Allgemeiner Rechenfehler")

Details zur Hierarchie stehen im Python-Tutorial zu Errors and Exceptions.

Übungstipp: Bau dir einen Fehler-CSV-Reader

Nimm eine kleine CSV-Datei (z. B. mit Namen und Noten) und schreibe ein Skript, das sie Zeile für Zeile einliest. Fange ab: fehlende Datei (`FileNotFoundError`), kaputte Zahlen (`ValueError`) und zu wenige Spalten (`IndexError`). Notiere dir für jeden Fehler die passende Exception-Klasse - so verankerst du die Namen dauerhaft. Für den Umgang mit den Datenstrukturen dahinter hilft unser Artikel zum Python Dictionary.

Bonus: Schreib danach einen Unit Test, der mit `pytest.raises(ValueError)` prüft, ob deine Funktion wirklich wirft, was sie soll.

FAQ: Häufige Fragen zu Python Exception Handling

Was ist der Unterschied zwischen except und finally?

`except` läuft nur, wenn im `try`-Block ein passender Fehler auftritt. `finally` läuft immer - mit Fehler, ohne Fehler, sogar bei vorzeitigem `return`. Deshalb nutzt man `finally` fürs Aufräumen.

Kann ich mehrere except-Blöcke hintereinander schreiben?

Ja. Python prüft sie von oben nach unten und nimmt den ersten passenden Block. Wichtig: Spezielle Exceptions (wie `ZeroDivisionError`) müssen vor allgemeinen (wie `ArithmeticError` oder `Exception`) stehen.

Wann sollte ich eine eigene Exception-Klasse erstellen?

Sobald dein Modul eigene Fehlerzustände hat, die aufrufender Code gezielt behandeln soll. Du erbst einfach von `Exception`: `class MeinerFehler(Exception): pass`. Für kleine Skripte reicht `raise ValueError("...")`.

Was macht except Exception as e?

Es fängt alle "normalen" Programmfehler ab und speichert das Exception-Objekt in `e`. Damit kannst du `print(e)` für die Fehlermeldung nutzen oder `type(e)` für die Klasse. Vorsicht: Es fängt auch Fehler, die du eigentlich fixen solltest - darum nicht als Standard nutzen.

Wird finally ausgeführt, wenn kein Fehler auftritt?

Ja, immer. Egal ob der `try`-Block fehlschlägt, erfolgreich durchläuft oder ein `return` dazwischenkommt - `finally` läuft garantiert.

Fazit

Python Exception Handling ist kein optionaler Bonus, sondern Handwerkszeug, das in jeder echten Anwendung steckt. Merk dir die drei Grundregeln: spezifische Exceptions fangen statt nacktem `except`, `finally` bzw. `with` fürs Aufräumen nutzen und mit `raise` früh auf ungültige Zustände hinweisen. Wenn du diese Grundlagen sitzen hast, kannst du auch verschachtelte Konstrukte und eigene Exception-Klassen sicher angehen.

Hängst du gerade bei einem konkreten Problem - etwa in deiner Ausbildung, beim Lernen für eine Prüfung oder im ersten Job? Bei study-it.education bekommst du persönliche IT-Nachhilfe und genau auf dein Level zugeschnittene Erklärungen. Schau vorbei!