Python - Benutzerdefinierte Ausnahmen

Hallo da, zukünftige Python-Zauberer! Heute werden wir auf eine aufregende Reise in die Welt der benutzerdefinierten Ausnahmen in Python einsteigen. Keine Sorge, wenn du neu bei der Programmierung bist; ich werde dich auf dieser Abenteuerreise Schritt für Schritt führen, genau wie ich es für unzählige Studenten in meinen Jahren des Unterrichtens getan habe. Also, nimm deine virtuellen Zauberstäbe (Tastaturen) und lass uns einsteigen!

Benutzerdefinierte Ausnahmen in Python

Bevor wir anfangen, unsere eigenen Ausnahmen zu erstellen, lassen wir uns schnell zurückblicken, was Ausnahmen sind. Stell dir vor, du bereitest ein köstliches Essen vor, aber plötzlich realisierst du, dass du eine entscheidende Zutat nicht mehr hast. Das ist ähnlich wie eine Ausnahme in der Programmierung – es ist eine unerwartete Situation, die den normalen Ablauf deines Codes stört.

Python kommt mit vielen eingebauten Ausnahmen, wie ValueError, TypeError und ZeroDivisionError. Manchmal müssen wir jedoch unsere eigenen speziellen Ausnahmen erstellen, um einzigartige Situationen in unseren Programmen zu handhaben. Hier kommen die benutzerdefinierten Ausnahmen ins Spiel!

Wie man eine benutzerdefinierte Ausnahme erstellt

Das Erstellen deiner eigenen Ausnahme ist so einfach wie einen Kuchen zu backen (nun, eine einfache Kuchenspezifikation). Alles, was du tun musst, ist, eine neue Klasse zu erstellen, die von der eingebauten Exception-Klasse oder einer ihrer Unterklasse erbt. Lass uns ein einfaches Beispiel ansehen:

class MeinSpeziellerFehler(Exception):
pass

Das ist alles! Du hast gerade deine erste benutzerdefinierte Ausnahme erstellt. Der pass-Befehl wird verwendet, weil wir keine zusätzliche Funktionalität zu unserer Ausnahme-Klasse hinzufügen müssen.

Aber was, wenn wir möchten, dass unsere Ausnahme ein bisschen informierter ist? Lass uns eine andere erstellen:

class WertZuGrossFehler(Exception):
def __init__(self, message, value):
self.message = message
self.value = value

In diesem Beispiel haben wir eine __init__-Methode zu unserer Ausnahme-Klasse hinzugefügt. Dies ermöglicht es uns, zusätzliche Informationen zu übergeben, wenn wir die Ausnahme auslösen.

Benutzerdefinierte Ausnahmen auslösen

Jetzt, da wir unsere benutzerdefinierten Ausnahmen haben, lassen uns sehen, wie wir sie in unserem Code verwenden können. Das Auslösen einer Ausnahme ist wie das Lösen eines Alarms, wenn etwas schiefgeht. So kannst du es tun:

def überprüfe_wert(value):
max_value = 100
if value > max_value:
raise WertZuGrossFehler("Wert ist zu groß!", value)
print(f"Wert {value} ist akzeptabel.")

# Lass uns es ausprobieren
try:
überprüfe_wert(150)
except WertZuGrossFehler as error:
print(f"Oje! {error.message} Der Wert war {error.value}")

In diesem Beispiel überprüfen wir, ob ein Wert zu groß ist. Wenn ja, then weisen wir unseren WertZuGrossFehler mit einer benutzerdefinierten Nachricht und dem tatsächlichen Wert aus.

Benutzerdefinierte Ausnahmen behandeln

Das Behandeln von benutzerdefinierten Ausnahmen ist genau wie das Behandeln von eingebauten Ausnahmen. Wir verwenden den vertrauenswürdigen try-except-Block. Lassen uns unser vorheriges Beispiel erweitern:

def verarbeite_wert(value):
try:
überprüfe_wert(value)
except WertZuGrossFehler as error:
print(f"Fehler: {error.message} Der Wert {error.value} ist nicht erlaubt.")
# Hier könntest du Code hinzufügen, um den Fehler zu behandeln, wie z.B. um einen neuen Wert zu bitten
else:
print("Wert erfolgreich verarbeitet!")
finally:
print("Wertprüfung abgeschlossen.")

# Lass uns es mit verschiedenen Werten ausprobieren
verarbeite_wert(50)
verarbeite_wert(200)

In diesem Code verwenden wir einen try-except-Block, um unseren WertZuGrossFehler zu behandeln. Wir haben auch eine else-Klausel hinzugefügt, die ausgeführt wird, wenn keine Ausnahme ausgelöst wird, und eine finally-Klausel, die immer ausgeführt wird, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht.

Komplettes Beispiel

Nun, lassen uns alles zusammen in ein komplexeres Beispiel setzen. Stell dir vor, wir erstellen ein einfaches Bankensystem:

class UnzureichendeGuthabenFehler(Exception):
def __init__(self, balance, amount):
self.balance = balance
self.amount = amount
self.message = f"Unzureichendes Guthaben. Guthaben: ${balance}, Auszahlung versucht: ${amount}"

class NegativerBetragFehler(Exception):
def __init__(self, amount):
self.amount = amount
self.message = f"Kann negativen Betrag nicht verarbeiten: ${amount}"

class BankKonto:
def __init__(self, balance=0):
self.balance = balance

def einzahlen(self, amount):
if amount < 0:
raise NegativerBetragFehler(amount)
self.balance += amount
print(f"Eingezahlt ${amount}. Neues Guthaben: ${self.balance}")

def auszahlen(self, amount):
if amount < 0:
raise NegativerBetragFehler(amount)
if amount > self.balance:
raise UnzureichendeGuthabenFehler(self.balance, amount)
self.balance -= amount
print(f"Ausgezahlt ${amount}. Neues Guthaben: ${self.balance}")

# Lass uns unsere BankKonto-Klasse verwenden
konto = BankKonto(100)

try:
konto.einzahlen(50)
konto.auszahlen(30)
konto.auszahlen(200)  # Dies sollte einen UnzureichendeGuthabenFehler auslösen
except NegativerBetragFehler as error:
print(f"Fehler: {error.message}")
except UnzureichendeGuthabenFehler as error:
print(f"Fehler: {error.message}")
else:
print("Alle Transaktionen erfolgreich abgeschlossen.")
finally:
print(f"Endgültiges Guthaben: ${konto.balance}")

In diesem Beispiel haben wir eine BankKonto-Klasse mit einzahlen und auszahlen Methoden erstellt. Wir haben auch zwei benutzerdefinierte Ausnahmen definiert: UnzureichendeGuthabenFehler und NegativerBetragFehler.

Wenn wir versuchen, mehr Geld auszuzahlen, als wir auf dem Konto haben, löst es einen UnzureichendeGuthabenFehler aus. Wenn wir versuchen, ein negatives Guthaben einzuzahlen oder auszuzahlen, löst es einen NegativerBetragFehler aus.

Dies ist ein großartiges Beispiel dafür, wie benutzerdefinierte Ausnahmen unseren Code lesbarer machen und uns helfen können, spezifische Fehlerfälle klar und organisiert zu handhaben.

Schlussfolgerung

Herzlichen Glückwunsch! Du hast gerade deine Python-Fähigkeiten aufgestockt, indem du über benutzerdefinierte Ausnahmen gelernt hast. Diese benutzerdefinierten Ausnahmen sind wie dein persönlicher Arme von Fehlerfangern, bereit, in Aktion zu treten, wenn etwas Unerwartetes in deinem Code passiert.

Denke daran, der Schlüssel zur Meisterschaft der benutzerdefinierten Ausnahmen ist das Üben. Versuche, deine eigenen Ausnahmen für verschiedene Szenarien zu erstellen, und bald wirst du Fehler wie ein Profi behandeln!

Hier ist eine schnelle Referenztabelle der Methoden, die wir behandelt haben:

Methode	Beschreibung
class CustomError(Exception):	Erstellt eine neue Ausnahme-Klasse
raise CustomError()	Löst eine benutzerdefinierte Ausnahme aus
try:	Beginnt einen try-Block
except CustomError as error:	Fängt eine spezifische benutzerdefinierte Ausnahme ab
else:	Wird ausgeführt, wenn keine Ausnahme ausgelöst wird
finally:	Wird immer ausgeführt, unabhängig von Ausnahmen

Happy coding, und möge deine Ausnahmen immer gefangen werden!

Credits: Image by storyset