Door de gebruiker gedefinieerde uitzonderingen worden gemaakt door een nieuwe klasse te definiëren die erft van De ingebouwde uitzondering van Python klasse of een van zijn subklassen. Door dit te doen kunnen we aangepaste foutmeldingen maken en specifieke fouten afhandelen op een manier die zinvol is voor onze toepassing.

Stappen voor het maken en gebruiken van door de gebruiker gedefinieerde uitzonderingen

Volg deze stappen om door de gebruiker gedefinieerde uitzonderingen in Python te maken en te gebruiken:

• Definieer een nieuwe uitzonderingsklasse: Maak een nieuwe klasse die overerft van Exception of een van de subklassen ervan.
• Verhoog de uitzondering: Gebruik de instructie raise om de door de gebruiker gedefinieerde uitzondering te verhogen wanneer een specifieke voorwaarde optreedt.
• Behandel de uitzondering: Gebruik try-except-blokken om de door de gebruiker gedefinieerde uitzondering af te handelen.

Voorbeeld: In dit voorbeeld maken we een aangepaste uitzondering InvalidAgeError om ervoor te zorgen dat leeftijdswaarden binnen een geldig bereik vallen (0-120).

# Step 1: Define a custom exception class class InvalidAgeError(Exception): def __init__(self age msg='Age must be between 0 and 120'): self.age = age self.msg = msg super().__init__(self.msg) def __str__(self): return f'{self.age} -> {self.msg}' # Step 2: Use the custom exception in your code def set_age(age): if age < 0 or age > 120: raise InvalidAgeError(age) else: print(f'Age set to: {age}') # Step 3: Handling the custom exception try: set_age(150) # This will raise the custom exception except InvalidAgeError as e: print(e) 

150 -> Age must be between 0 and 120 

Uitleg:

• De klasse InvalidAgeError neemt over van Exception. Het definieert een __heet__ methode om leeftijd en bericht te accepteren.
• De methode __str__ retourneert een leesbare tekenreeksrepresentatie van de fout.
• Als de leeftijd in set_age() buiten het geldige bereik (0–120) ligt, wordt de uitzondering gegenereerd.
• Het try-except-blok vangt de uitzondering op en drukt het foutbericht af.

Uitzonderingsklassen aanpassen

Wanneer we een aangepaste uitzondering maken, classificeren we de ingebouwde Exception-klasse van Python (of een subklasse zoals ValueError TypeError enz.). We kunnen vervolgens onze eigen attribuutmethoden of aangepaste logica toevoegen om onze uitzondering informatiever te maken.

We kunnen aangepaste uitzonderingen ook verbeteren door extra attributen toe te voegen of methoden te overschrijven.

Voorbeeld: Hier verbeteren we de InvalidAgeError door een foutcode toe te voegen en de foutmelding aan te passen.

class InvalidAgeError(Exception): def __init__(self age msg='Age must be between 0 and 120' error_code=1001): self.age = age self.msg = msg self.error_code = error_code super().__init__(self.msg) def __str__(self): return f'[Error Code {self.error_code}] {self.age} -> {self.msg}' try: set_age(150) # This will raise the custom exception except InvalidAgeError as e: print(e) 

[Error Code 1001] 150 -> Age must be between 0 and 120 

Uitleg:

• InvalidAgeError heeft nu een extra attribuut error_code.
• De methode __str__ wordt overschreven om zowel de foutcode als de leeftijd weer te geven.
• Wanneer set_age(150) wordt uitgevoerd, wordt de uitzondering gegenereerd en opgevangen in het try-except-blok.
• Het aangepaste foutbericht wordt afgedrukt, waardoor de fout beter wordt beschreven.

Standaarduitzonderingen gebruiken als basisklasse

Soms kunnen we, in plaats van rechtstreeks te erven van Exception, een aangepaste uitzondering maken door een standaarduitzondering in een subklasse te plaatsen, zoals RuntimeError ValueError enz. Dit is handig wanneer uw aangepaste uitzondering moet worden behandeld als een specifiek soort fout.

Voorbeeld: In dit voorbeeld ziet u hoe u een aangepaste uitzondering NetworkError maakt door overerving van RuntimeError, een standaard ingebouwde uitzondering.

# NetworkError has base RuntimeError and not Exception class NetworkError(RuntimeError): def __init__(self arg): self.args = (arg) # store as tuple try: raise NetworkError('Connection failed') except NetworkError as e: print(e.args) 

('Connection failed') 

Uitleg:

• NetworkError erft van RuntimeError, een ingebouwd uitzonderingstype.
• Wanneer het bericht wordt gegenereerd, wordt het als een tuple opgeslagen in het args-attribuut.
• De uitzondering wordt opgevangen en de opgeslagen argumenten worden weergegeven.

Voorbeeld uit de praktijk: ongeldige e-mailfout

Hier is een eenvoudig voorbeeld waarbij we een aangepaste uitzondering maken als het e-mailadres niet geldig is:

class InvalidEmailError(Exception): def __init__(self email msg='Invalid email format'): self.email = email self.msg = msg super().__init__(self.msg) def __str__(self): return f'{self.email} -> {self.msg}' def set_email(email): if '@' not in email: raise InvalidEmailError(email) print(f'Email set to: {email}') try: set_email('userexample.com') except InvalidEmailError as e: print(e) 

userexample.com -> Invalid email format 

Uitleg:

• Er is een nieuwe uitzonderingsklasse InvalidEmailError gedefinieerd om e-mailadressen te valideren.
• Als het opgegeven e-mailadres geen '@' bevat, wordt er een uitzondering gemaakt.
• Het try-except-blok vangt de fout op en drukt het opgemaakte bericht af.

Wanneer moet u door de gebruiker gedefinieerde uitzonderingen gebruiken?

In de volgende scenario's moet door de gebruiker gedefinieerde uitzonderingen worden overwogen:

• Vertegenwoordigt specifieke fouten in een applicatie (bijvoorbeeld InvalidAgeError DatabaseConnectionError).
• Het verstrekken van duidelijkere en meer beschrijvende foutmeldingen.
• Een groep gerelateerde fouten afzonderlijk afhandelen met behulp van Except.

Door het gebruik van door de gebruiker gedefinieerde uitzonderingen worden programma's leesbaarder, onderhoudbaarder en gemakkelijker te debuggen.