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 erft 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.

Wat gebeurt er als een door de gebruiker gedefinieerde uitzondering overneemt van RuntimeError in plaats van Exception?

• A

  Het kan niet worden gevangen met behulp van, behalve

• B

  Het wordt een ongecontroleerde uitzondering

• C

  Het wordt door handlers behandeld als een runtime-gerelateerde fout

• D

  Er gaan aangepaste kenmerken verloren

Door het overnemen van RuntimeError kan het zowel als een runtimefout als als een aangepaste fout worden afgehandeld.

Waarom wordt super().__init__(self.msg) vaak gebruikt in aangepaste uitzonderingsklassen?

• A

  Om meervoudige overerving te voorkomen

• B

  Om de basis Exception-klasse correct te initialiseren

• C

  Om de traceback te overschrijven

• D

  Om de uitzondering automatisch te verhogen

Door super() aan te roepen, zorgt u ervoor dat de basisuitzondering correct wordt geïnitialiseerd met het bericht.

Wat wordt er afgedrukt als een aangepaste uitzondering __str__() overschrijft en binnenin wordt afgedrukt, behalve?

• A

  De overschreven tekenreeksrepresentatie

• B

  Geheugenadres van de uitzondering

• C

  Alleen de klassenaam

• D

  Niets tenzij repr() wordt gebruikt

print(e) roept __str__() van het uitzonderingsobject aan.