Python Academy · Lektion

Brugerdefinerede undtagelsesklasser

Definér egne undtagelsestyper for tydeligere fejlkommunikation.

Lektion 4 af 414 trin

Brugerdefinerede undtagelsesklasser er en gratis Python Academy-lektion på CoddyKit. Dette er lektion 4 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Python Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Python Academy-kurset indeholder 4 lektioner i alt.

Introduktion

Brugerdefinerede undtagelsesklasser gør din fejlhåndtering eksplicit, selvforklarende og nem for kaldere at håndtere præcist.

Hvorfor brugerdefinerede undtagelser?

Indbyggede undtagelser er for generelle. Brugerdefinerede undtagelser lader kaldere fange kun fejl fra DIT bibliotek uden at fange ikke-relaterede fejl.

class AppError(Exception):
    pass
raise AppError('something went wrong')

Nedarvning fra Exception

class MyError(Exception): pass er alt, hvad du behøver. Nedarv altid fra Exception, ikke BaseException.

class ValidationError(Exception):
    pass
try:
    raise ValidationError('email is invalid')
except ValidationError as e:
    print(e)

Tilføjelse af brugerdefinerede attributter

class APIError(Exception): def __init__(self, status, message): self.status = status; super().__init__(message)

class APIError(Exception):
    def __init__(self, status, message):
        self.status = status
        super().__init__(message)
try:
    raise APIError(404, 'Not found')
except APIError as e:
    print(e.status, e)

Undtagelseshierarki

Opbyg et hierarki: class DBError(AppError): pass — kaldere kan fange AppError for enhver applikationsfejl eller specifikt DBError.

class AppError(Exception): pass
class DBError(AppError): pass
class NetworkError(AppError): pass
try:
    raise DBError('timeout')
except AppError as e:
    print('app error:', e)

Den brugerdefinerede str-metode

Overskriv __str__ for at styre, hvordan undtagelsens meddelelse ser ud, når den udskrives.

class RangeError(ValueError):
    def __init__(self, val, lo, hi):
        self.val, self.lo, self.hi = val, lo, hi
    def __str__(self):
        return f'{self.val} not in [{self.lo}, {self.hi}]'
print(RangeError(15, 0, 10))

Rejsning af brugerdefinerede undtagelser

Brug raise i dine funktioner til at signalere domænespecifikke fejl. Det skaber en ren API for kaldere.

class InsufficientFundsError(Exception):
    def __init__(self, needed, available):
        super().__init__(f'Need {needed}, have {available}')
def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(amount, balance)
    return balance - amount
try:
    withdraw(100, 200)
except InsufficientFundsError as e:
    print(e)

Fangning via basisklasse

except AppError fanger alle underklasser: DBError, NetworkError osv. Hierarkiet lader kaldere vælge, hvor specifik fangningen skal være.

class AppError(Exception): pass
class DBError(AppError): pass
try:
    raise DBError('conn failed')
except AppError:
    print('any app error')

Undtagelser med konteksthåndtering

Brugerdefinerede undtagelser fungerer sammen med konteksthåndteringer: class suppressed: __exit__ returnerer True for at undertrykke undtagelsen.

class SuppressValue(Exception): pass
try:
    raise SuppressValue('ignored')
except SuppressValue:
    pass  # suppress silently
print('continued')

Dokumentation af brugerdefinerede undtagelser

Dokumentér, HVORNÅR undtagelsen skal rejses, og HVAD attributterne betyder. Gode docstrings gør brugerdefinerede undtagelser nemme at bruge.

class ConfigError(Exception):
    """Raised when configuration is invalid.
    Attributes:
        key: The invalid config key
    """
    def __init__(self, key, msg):
        super().__init__(msg)
        self.key = key

Bedste praksis

Hold hierarkiet fladt (2-3 niveauer). Nedarv altid fra Exception. Brug beskrivende navne, der slutter på Error. Placér dem i et dedikeret exceptions.py-modul.

# Good structure:
class AppError(Exception): pass
class ValidationError(AppError): pass
class NotFoundError(AppError): pass
print('hierarchy demo')

Hurtigt tjek

Hvad skal brugerdefinerede undtagelser nedarve fra for at undgå at fange hændelser, der afslutter systemet?

Besvar den i den interaktive lektion

Opsamling

Brugerdefinerede undtagelser: nedarv fra Exception, tilføj attributter i __init__, og overskriv __str__. Opbyg hierarkier for at gøre specifik fangning mulig. Placér dem i modulet exceptions.py.

Fortsæt

Godt arbejde! Gå videre til den næste lektion for at fortsætte din fremgang.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 76
Lektioner: 320

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Brugerdefinerede undtagelsesklasser” gratis?

Ja — hele teksten til “Brugerdefinerede undtagelsesklasser” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Python Academy-kurset, skal du opgradere til CoddyKit PRO. Python Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Brugerdefinerede undtagelsesklasser”?

Definér egne undtagelsestyper for tydeligere fejlkommunikation. Du øver dig i Python Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Python Academy?

Der kræves ingen tidligere erfaring. Python Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 4 af 4.

Hvor lang tid tager lektionen “Brugerdefinerede undtagelsesklasser”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Python Academy-lektion?

Ja. Alle Python Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Python Academy