Brugerdefinerede undtagelser oprettes ved at definere en ny klasse, der arver fra Pythons indbyggede undtagelse klasse eller en af ​​dens underklasser. Ved at gøre dette kan vi oprette brugerdefinerede fejlmeddelelser og håndtere specifikke fejl på en måde, der giver mening for vores applikation.

Trin til at oprette og bruge brugerdefinerede undtagelser

Følg disse trin for at oprette og bruge brugerdefinerede undtagelser i Python:

• Definer en ny undtagelsesklasse: Opret en ny klasse, der arver fra Exception eller en af ​​dens underklasser.
• Hæv undtagelsen: Brug raise-sætningen til at hæve den brugerdefinerede undtagelse, når en specifik tilstand opstår.
• Håndter undtagelsen: Brug try-except-blokke til at håndtere den brugerdefinerede undtagelse.

Eksempel: I dette eksempel opretter vi en tilpasset undtagelse InvalidAgeError for at sikre, at aldersværdier falder inden for et gyldigt interval (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  

Forklaring:

• InvalidAgeError-klassen arver fra Exception. Det definerer en __hot__ metode til at acceptere alder og budskab.
• Metoden __str__ returnerer en læsbar strengrepræsentation af fejlen.
• I set_age(), hvis alderen er uden for det gyldige interval (0-120), hæves undtagelsen.
• Prøv-undtagen-blokken fanger undtagelsen og udskriver fejlmeddelelsen.

Tilpasning af undtagelsesklasser

Når vi opretter en brugerdefineret undtagelse, underklasserer vi Pythons indbyggede undtagelsesklasse (eller en underklasse som ValueError TypeError osv.). Vi kan derefter tilføje vores egne attributmetoder eller tilpasset logik for at gøre vores undtagelse mere informativ.

Vi kan også forbedre tilpassede undtagelser ved at tilføje ekstra attributter eller tilsidesætte metoder.

Eksempel: Her forbedrer vi InvalidAgeError ved at tilføje en fejlkode og tilpasse fejlmeddelelsen.

   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  

Forklaring:

• InvalidAgeError har nu en ekstra attribut error_code.
• __str__ metode tilsidesættes for at vise både fejlkoden og alderen.
• Når set_age(150) udføres, hæves undtagelsen og fanges i try-except-blokken.
• Den tilpassede fejlmeddelelse udskrives, hvilket gør fejlen mere beskrivende.

Brug af standardundtagelser som en basisklasse

Nogle gange kan vi i stedet for direkte at nedarve fra Exception oprette en tilpasset undtagelse ved at underklassificere en standardundtagelse såsom RuntimeError ValueError osv. Dette er nyttigt, når din tilpassede undtagelse skal behandles som en specifik type fejl.

Eksempel: Dette eksempel viser, hvordan du opretter en brugerdefineret undtagelse NetworkError ved at arve fra RuntimeError, som er en standard indbygget undtagelse.

   # 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')  

Forklaring:

• NetworkError arver fra RuntimeError, som er en indbygget undtagelsestype.
• Når meddelelsen rejses, gemmes den i args-attributten som en tuple.
• Undtagelsen fanges, og dens lagrede argumenter vises.

Real-World Eksempel: Ugyldig e-mail-fejl

Her er et simpelt eksempel, hvor vi rejser en tilpasset undtagelse, hvis e-mailadressen ikke er gyldig:

   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  

Forklaring:

• En ny undtagelsesklasse InvalidEmailError er defineret for at validere e-mail-adresser.
• Hvis den givne e-mail ikke indeholder '@', hæves undtagelsen.
• Prøv-undtagen-blokken fanger fejlen og udskriver den formaterede meddelelse.

Hvornår skal man bruge brugerdefinerede undtagelser?

Brugerdefinerede undtagelser bør overvejes i følgende scenarier:

• Repræsenterer specifikke fejl i en applikation (f.eks. InvalidAgeError DatabaseConnectionError).
• Giver klarere og mere beskrivende fejlmeddelelser.
• Håndtering af en gruppe af relaterede fejl separat ved hjælp af undtagen.

Ved at bruge brugerdefinerede undtagelser bliver programmer mere læsbare og nemmere at vedligeholde.

Hvad sker der, hvis en brugerdefineret undtagelse arver fra RuntimeError i stedet for Exception?

• EN

  Det kan ikke fanges med undtagen

• B

  Det bliver en ukontrolleret undtagelse

• C

  Det behandles som en runtime-relateret fejl af handlere

• D

  Det mister tilpassede attributter

At arve fra RuntimeError lader det håndteres som en runtime fejl såvel som en brugerdefineret.

Hvorfor er super().__init__(self.msg) almindeligvis brugt i brugerdefinerede undtagelsesklasser?

• EN

  For at forhindre multipel arv

• B

  Til korrekt initialisering af basisundtagelsesklassen

• C

  For at tilsidesætte sporingen

• D

  For automatisk at hæve undtagelsen

Kaldning af super() sikrer, at basisundtagelsen initialiseres korrekt med beskeden.

Hvad vil blive udskrevet, hvis en tilpasset undtagelse tilsidesætter __str__() og udskrives inde undtagen?

• EN

  Den tilsidesatte strengrepræsentation

• B

  Hukommelsesadresse for undtagelsen

• C

  Kun klassens navn

• D

  Intet, medmindre repr() bruges

print(e) kalder __str__() af undtagelsesobjektet.