Python Academy · Lektion

Egna undantagsklasser

Definiera egna undantagstyper för tydligare felkommunikation.

Lektion 4 av 414 steg

Egna undantagsklasser är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Introduktion

Egna undantagsklasser gör felhanteringen tydlig, självförklarande och enkel för anropare att hantera precist.

Varför egna undantag?

Inbyggda undantag är för generella. Med egna undantag kan anropare fånga endast fel från DITT bibliotek utan att fånga orelaterade fel.

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

Ärva från Exception

class MyError(Exception): pass är allt du behöver. Är alltid från Exception, inte från BaseException.

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

Lägga till egna attribut

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)

Undantagshierarki

Bygg en hierarki: class DBError(AppError): pass — anropare kan fånga AppError för alla programfel eller DBError specifikt.

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

Egen str-metod

Åsidosätt __str__ för att styra hur undantagsmeddelandet ser ut när det skrivs ut.

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

Utlösa egna undantag

Använd raise i dina funktioner för att signalera domänspecifika fel. Det skapar ett tydligt API för anropare.

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)

Fånga via basklassen

except AppError fångar alla underklasser: DBError, NetworkError med flera. Hierarkin låter anropare välja hur specifik hanteringen ska vara.

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

Undantag med kontexthanterare

Egna undantag fungerar tillsammans med kontexthanterare: class suppressed: __exit__ returnerar True för att undertrycka undantaget.

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

Dokumentera egna undantag

Dokumentera NÄR undantaget ska utlösas och VAD attributen betyder. Bra docstrings gör egna undantag användbara.

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

Bästa praxis

Håll hierarkin grund (2–3 nivåer). Är alltid från Exception. Använd beskrivande namn som slutar på Error. Placera klasserna i en särskild modul, exceptions.py.

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

Snabb kontroll

Vad bör egna undantag ärva från för att undvika att fånga händelser som avslutar systemet?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Egna undantag: ärv från Exception, lägg till attribut i __init__ och åsidosätt __str__. Bygg hierarkier för att kunna fånga olika nivåer. Placera dem i modulen exceptions.py.

Fortsätt

Bra jobbat! Gå vidare till nästa lektion för att fortsätta utvecklas.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Egna undantagsklasser” gratis?

Ja – hela texten till ”Egna undantagsklasser” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Egna undantagsklasser”?

Definiera egna undantagstyper för tydligare felkommunikation. Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Egna undantagsklasser”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy