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

til loop i java

# 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:

instansiering i java

• 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:

ankita lokhande alder

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