Python eigene Exception erstellen: Einfach erklärt mit Beispielen

Stell dir vor, du schreibst eine Anwendung für eine Bibliotheksverwaltung. Ein Nutzer versucht, ein Buch auszuleihen, das schon vergeben ist. Du könntest jetzt einfach `raise Exception("Buch schon vergeben")` schreiben - aber wie soll der aufrufende Code diesen Fehler später gezielt fangen, ohne dabei alle anderen Fehler mit einzufangen? Genau dafür brauchst du eine eigene Exception in Python.

Wenn du mit dem try-except-Mechanismus noch unsicher bist, lies zuerst den Artikel zu Python Exception Handling: try except finally einfach erklärt. Hier geht es um den nächsten Schritt: eigene Fehlerklassen bauen.

Was ist eine eigene Exception in Python?

Eine eigene Exception ist eine Klasse, die von der eingebauten Klasse `Exception` erbt. Damit sagst du Python: "Das ist ein neuer Fehlertyp, den mein Programm selbst auslösen kann." Vergleiche das am besten mit Formularwesen: Eingebaute Exceptions wie `ValueError` oder `TypeError` sind Standardformulare von Python. Eine eigene Exception ist ein Formular, das du für deinen speziellen Fall selbst entworfen hast.

Der Vorteil: Aufrufender Code kann deinen Fehler gezielt mit `except DeineException` abfangen - ohne andere, unvorhergesehene Fehler versehentlich zu verschlucken.

Merke: Eigene Exceptions sind normale Klassen, die von `Exception` (oder einer ihrer Unterklassen) erben. Der Mechanismus dahinter ist Vererbung.

Wie erstellst du eine eigene Exception? Zwei Zeilen reichen

Eine eigene Exception erstellst du, indem du eine Klasse definierst, die von `Exception` erbt - mehr braucht es nicht:

class BuchNichtVerfuegbarError(Exception):
    pass


def buch_ausleihen(buch_id, verfuegbar):
    if not verfuegbar:
        raise BuchNichtVerfuegbarError(
            f"Buch {buch_id} ist bereits ausgeliehen"
        )
    print(f"Buch {buch_id} wurde ausgeliehen")

Was passiert hier?

• `class BuchNichtVerfuegbarError(Exception):` definiert eine neue Klasse, die von `Exception` erbt. Damit erbt sie automatisch alles, was eine Exception kann - inklusive der Fähigkeit, eine Fehlermeldung zu tragen.

• `pass` ist ein Platzhalter, weil Python mindestens eine Anweisung im Klassenkörper braucht.

• `raise` löst die Exception aus, sobald der Fehlerfall eintritt.

Der Name endet auf `Error` - das ist eine weit verbreitete Konvention, die du auch in der offiziellen Exception-Hierarchie siehst (`ValueError`, `TypeError` usw.).

So fängst du sie gezielt ab:

try:
    buch_ausleihen(42, verfuegbar=False)
except BuchNichtVerfuegbarError as fehler:
    print(f"Leihvorgang fehlgeschlagen: {fehler}")

Wann solltest du eigene Exceptions erstellen?

Erstelle eine eigene Exception, wenn der Fehler spezifisch für deine Anwendung ist und aufrufender Code darauf unterschiedlich reagieren muss. Sobald du dich ertappst, generische `Exception`-Objekte mit beschreibenden Texten zu werfen, ist das ein deutliches Signal für eine eigene Klasse.

Wichtig: `except Exception` ist als Fangnetz zu grob - es fängt *jeden* Fehler, auch Tippfehler in Variablennamen (`NameError`) oder Logikfehler. Mit einer eigenen Exception fängst du exakt den einen Fall, den du behandeln kannst.

Eigene Exceptions mit mehr Kontext: `__init__` überschreiben

Mehr Kontext lieferst du mit, indem du den Konstruktor `__init__` überschreibst. Oft willst du ja zusätzliche Daten mitgeben - etwa den Kontostand, der zu niedrig war:

class ZuWenigGuthabenError(Exception):
    def __init__(self, benoetigt, vorhanden):
        self.benoetigt = benoetigt
        self.vorhanden = vorhanden
        super().__init__(
            f"Benoetigt: {benoetigt} EUR, vorhanden: {vorhanden} EUR"
        )

Der Aufruf von `super().__init__(...)` reicht die Hauptmeldung an die Elternklasse `Exception` weiter - so bleibt deine Klasse kompatibel mit allem, was Python intern mit Exceptions macht. Die einzelnen Werte speicherst du zusätzlich als Attribute (`self.benoetigt`, `self.vorhanden`), damit der aufrufende Code gezielt darauf zugreifen kann:

def abheben(guthaben, betrag):
    if betrag > guthaben:
        raise ZuWenigGuthabenError(benoetigt=betrag, vorhanden=guthaben)
    return guthaben - betrag


try:
    abheben(guthaben=50, betrag=100)
except ZuWenigGuthabenError as fehler:
    print(f"Fehlender Betrag: {fehler.benoetigt - fehler.vorhanden} EUR")

Wenn dich `__init__`, `__str__` und andere spezielle Methoden interessieren, wirf einen Blick in den Artikel zu Python Dunder Methoden.

Praxisbeispiel: Exception-Hierarchie für ein Bankkonto

In echten Projekten - etwa in deiner Abschlussprüfung, im Studium oder im ersten Job - gruppierst du eigene Exceptions meist in einer kleinen Hierarchie: Eine Basisklasse sammelt alle Fehler deiner Anwendung, konkrete Unterklassen präzisieren den Einzelfall.

class BankError(Exception):
    """Basisklasse fuer alle Fehler dieses Moduls."""

    pass


class KontoGesperrtError(BankError):
    pass


class ZuWenigGuthabenError(BankError):
    def __init__(self, benoetigt, vorhanden):
        self.benoetigt = benoetigt
        self.vorhanden = vorhanden
        super().__init__(
            f"Benoetigt: {benoetigt} EUR, vorhanden: {vorhanden} EUR"
        )


class UngueltigerBetragError(BankError):
    pass


def abheben(konto, betrag):
    if konto["gesperrt"]:
        raise KontoGesperrtError("Konto ist gesperrt")
    if betrag <= 0:
        raise UngueltigerBetragError(f"Betrag muss positiv sein, war: {betrag}")
    if betrag > konto["guthaben"]:
        raise ZuWenigGuthabenError(
            benoetigt=betrag, vorhanden=konto["guthaben"]
        )
    konto["guthaben"] -= betrag
    return konto["guthaben"]


konto = {"guthaben": 100, "gesperrt": False}

# Spezifisch fangen: nur der Guthaben-Fall
try:
    abheben(konto, 500)
except ZuWenigGuthabenError as fehler:
    print(
        f"Abheben nicht moeglich. Es fehlen {fehler.benoetigt - fehler.vorhanden} EUR"
    )

# Allgemein fangen: jeder Fehler aus diesem Modul
try:
    abheben(konto, -10)
except BankError as fehler:
    print(f"Bankfehler: {fehler}")

Merke: Dank Vererbung fängt `except BankError` automatisch auch `KontoGesperrtError`, `ZuWenigGuthabenError` und `UngueltigerBetragError`. Python prüft bei `except` die komplette Vererbungskette - Details dazu findest du in den Python Docs zu Errors and Exceptions.

Häufige Fehler bei eigenen Exceptions

Drei Stolperfallen tauchen immer wieder auf - auch in Prüfungsaufgaben und Code-Reviews.

Fehler 1: Von `BaseException` erben

`BaseException` ist die oberste Klasse der Exception-Hierarchie. Von ihr erben auch `KeyboardInterrupt` (Strg+C) und `SystemExit`. Wer eine eigene Klasse direkt von `BaseException` ableitet, riskiert, dass ein simples `except Exception` den eigenen Fehler gar nicht fängt. Erbe immer von `Exception` oder einer ihrer Unterklassen.

Fehler 2: Eigene Exceptions werfen, aber generisch fangen

# Falsch: Killt jede Fehlerbehandlung
try:
    abheben(konto, 500)
except Exception:
    pass

# Richtig: Gezielt den erwarteten Fehler fangen
try:
    abheben(konto, 500)
except ZuWenigGuthabenError as fehler:
    print(f"Nicht genug Guthaben: {fehler}")

Ein nacktes `except Exception: pass` verschluckt jeden Fehler - inklusive der Bugs, die du eigentlich finden willst. Das führt zu Programmen, die scheinbar funktionieren, aber im Hintergrund Daten verlieren.

Fehler 3: `super().__init__()` vergessen

Wenn du `__init__` überschreibst und den Aufruf von `super().__init__(...)` vergisst, kann die Ausgabe von `print(fehler)` leer oder verwirrend sein. Die Elternklasse verwaltet die Fehlermeldung - gib ihr deine Nachricht immer weiter.

Übungstipp: Bau dein eigenes Modul

Nimm dir 20 Minuten und schreibe ein kleines Registrierungsmodul für eine Website. Definiere eine Basisklasse `RegistrierungError` und mindestens zwei Unterklassen: `EmailUngueltigError` und `PasswortZuSchwachError`. Die Passwort-Exception soll das Passwort in `__init__` übernehmen und die Anzahl der Zeichen als Attribut speichern. Eine Funktion `registrieren(email, passwort)` löst bei Problemen die passende Exception aus. Warum diese Übung? Weil sie alle drei Konzepte kombiniert: Vererbung, `__init__` überschreiben und gezieltes Fangen mit try-except.

FAQ: Häufige Fragen zu eigenen Exceptions in Python

Wie erstelle ich eine eigene Exception in Python?

Du definierst eine Klasse, die von `Exception` erbt: `class MeinFehler(Exception): pass`. Danach kannst du sie mit `raise MeinFehler("Nachricht")` auslösen und mit `except MeinFehler` abfangen.

Wovon sollte meine eigene Exception erben?

In der Regel von `Exception`. Du kannst auch von einer passenden eingebauten Klasse erben, etwa von `ValueError`, wenn dein Fehler semantisch ein ungültiger Wert ist - dann fängt `except ValueError` auch deinen Fehler.

Muss ich `__init__` überschreiben?

Nein. Die geerbte Version nimmt eine Fehlermeldung entgegen und reicht sie weiter. `__init__` überschreibst du nur, wenn deine Exception zusätzliche Daten wie Kontostände oder IDs mittragen soll.

Wo lege ich meine Exception-Klassen ab?

Bei kleinen Projekten oben in die Datei, in der sie geworfen werden. Bei größeren Projekten in eine eigene Datei (z. B. `exceptions.py`), die andere Module importieren können.

Warum nicht von `BaseException` erben?

`BaseException` ist für Systemabbrüche wie `KeyboardInterrupt` und `SystemExit` reserviert. Eigene Klassen, die direkt davon erben, werden von `except Exception` nicht gefangen - deine Fehlerbehandlung läuft dann ins Leere.

Fazit

Eigene Exceptions in Python sind kein Hexenwerk: eine Klasse, die von `Exception` erbt, ein `raise` zum Auslösen, ein `except` zum Fangen. Der echte Gewinn liegt in der Klarheit - dein Code kommuniziert, *welcher* Fehler passiert ist, und aufrufender Code kann gezielt darauf reagieren. Mit überschriebenem `__init__` und einer kleinen Klassenhierarchie hast du ein Werkzeug, das dich durch Ausbildung, Studium und Berufsalltag trägt.

Wenn du bei Python, OOP oder einem anderen IT-Thema festhängst - ob für die nächste Prüfung in der Ausbildung, eine Hausaufgabe im Studium oder dein erstes Berufprojekt: Die Nachhilfe von study-it.education holt dich genau dort ab, wo du gerade stehst. Schau vorbei und vereinbare deine individuelle Lerneinheit.