Hur man fångar flera undantag i Python: En enkel guide

Hantera flera undantag i Python för mer robust kod

Att hantera undantag är avgörande för att skapa stabilare Python-program. Genom att på ett korrekt sätt fånga och bearbeta fel, minskar du risken för oönskade programkrascher, vilket i sin tur förbättrar användarupplevelsen. I denna genomgång kommer vi att fokusera på tekniken att hantera flera undantag i samma try/except-block.

Vad är undantag i Python?

I Python fungerar undantag som en kommunikationskanal mellan olika delar av programmet. När en programdel upptäcker ett fel den inte kan hantera, skickas ett undantag. En annan programdel som är specialiserad på att hantera detta fel tar emot undantaget och bearbetar det.

Om undantagen inte fångas leder de till att programmet avslutas med ett felmeddelande. Att hantera undantag är därför ett viktigt steg för att göra din applikation pålitlig.

Denna genomgång förutsätter att du har grundläggande kunskap om hur man skapar och hanterar undantag, vilket du kan lära dig i artiklar som introducerar grunderna i Python try/except-hantering.

Varför är det viktigt att hantera flera undantag?

  • Det minskar kodupprepning genom att låta samma block hantera olika typer av undantag. Detta gör koden mer överskådlig, enklare att ändra och lättare att ta bort.
  • Det bidrar till effektivare kod eftersom feltypen behöver undersökas endast en gång, istället för flera gånger.

Tekniker för att hantera flera undantag

Att fånga flera undantag innebär att använda ett och samma except-block för att hantera olika typer av fel. Python erbjuder möjligheten att hantera olika undantag separat i olika except-block. Men, om du vill hantera flera undantag på samma sätt, är det mer effektivt att hantera dem i ett gemensamt block. Vi ska nu titta på hur man gör detta med hjälp av exempel.

1. Hantera olika undantag i separata block

Låt oss tänka oss ett program som tar två tal som input och utför en division. Vi förväntar oss att användaren kan mata in felaktiga värden som resulterar i ValueError eller ZeroDivisionError. Vi vill i dessa fall visa ett felmeddelande som säger ”Ogiltigt värde angivet”.

Här är ett exempel på hur man hanterar detta:


try:
    dividend = int(input('Ange första talet: '))
    divisor = int(input('Ange andra talet: '))
    quotient = dividend / divisor
    print(quotient)
except ValueError as e:
    print("Ogiltigt värde angivet")
except ZeroDivisionError as e:
    print("Ogiltigt värde angivet")
except Exception as e:
    print("Något gick fel")
    

Om vi kör koden med en inmatning som inte kan konverteras till ett tal, ser vi:

Om vi anger den andra siffran som 0, ser vi:

Koden fungerar som planerat men vi ser att hanteringen av ValueError och ZeroDivisionError är identisk. Detta är ett brott mot principen DRY (Don’t Repeat Yourself). Vi kan undvika kodupprepningen genom att hantera dessa fel i ett gemensamt block.

2. Hantera flera undantag i ett enda except-block

Vi kan kombinera flera fel i en tupel i ett enda except-block. Detta tillåter oss att hantera både ValueError och ZeroDivisionError med samma kod:


try:
    dividend = int(input('Ange första talet: '))
    divisor = int(input('Ange andra talet: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("Ogiltigt värde angivet")
except Exception as e:
    print("Något gick fel")
    

Detta är en mer effektiv implementering. Koden fungerar precis som tidigare och ger samma resultat som förut:

3. Identifiera det specifika undantaget

Ibland vill du kanske utföra viss kod för alla undantag, men också ha specifik kod för specifika feltyper. Då måste du kunna identifiera vilket undantag som utlöstes.

Detta kan du göra med en if/else-sats inuti except-blocket:


try:
    dividend = int(input('Ange första talet: '))
    divisor = int(input('Ange andra talet: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("Ogiltigt värde angivet")

    if isinstance(e, ValueError):
        print('Value Error')
    else:
        print('Zero Division Error')
except Exception as e:
    print("Något gick fel")
    

Nu ser vi inte bara det allmänna felmeddelandet utan också ett specifikt meddelande för det specifika undantaget:

När är det lämpligt att hantera flera undantag?

Det är ofta bra att hantera flera undantag om de kräver samma hantering. Här är några exempel:

  • När nätverksanrop misslyckas av olika anledningar. Oavsett anledning kan du informera användaren om att servern inte kan nås.
  • När anslutningar till databaser misslyckas med olika felkoder. Du kan hantera dessa fel på ett likartat sätt.
  • När filhantering genererar olika fel, t.ex. behörighetsproblem eller full disk.

Sammanfattning

Denna artikel förklarade hur man kombinerar flera except-block genom att fånga flera undantag samtidigt. Detta gör din kod mer läsbar och enklare att underhålla. Fortsätt gärna att utforska andra Python-relaterade ämnen, till exempel projekt för nybörjare.