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

Att fånga undantag i Python hjälper till att säkerställa att dina program kraschar mindre ofta. Detta gör din kod mer tillförlitlig och ger en bättre användarupplevelse. I den här artikeln kommer jag att diskutera hur man fångar flera undantag i samma försök/utom-block i Python.

Vad är undantag i Python?

I Pytonorm, Undantag är en kommunikationsmekanism mellan olika programdelar. Denna kommunikationsmekanism tillåter en del av systemet att kommunicera att den har stött på ett kritiskt fel som den inte vet hur den ska hantera.

Så det väcker ett undantag. En annan del av programmet som vet hur man hanterar felet kommer att fånga undantaget och hantera felet korrekt.

När de inte hanteras kommer undantag att krascha programmet. Att hantera undantag förhindrar därför att ditt program kraschar och gör det mer tillförlitligt.

För den här artikeln kommer jag att anta att du redan är bekant med grunderna för att höja och hantera undantag, som behandlas i denna Introduktion till Python Try/Except-artikeln.

Vikten av att hantera flera undantag i Python

  • Det minskar kodduplicering eftersom flera undantag hanteras av samma block. Detta gör koden lättare att läsa, redigera och radera.
  • Det hjälper dig också att skriva mer effektiv kod eftersom feltypen bara behöver kontrolleras en gång istället för flera gånger.

Hantera flera undantag

Att fånga flera undantag hänvisar till situationen där flera undantag fångas med samma undantagsblock. I Python kan du fånga olika undantag i enskilda utom block.

Alternativt, när du vill hantera undantagen på liknande sätt, kan du hantera dem med ett block. För att göra det måste du fånga flera undantag. I det här avsnittet kommer jag att förklara hur man gör det med ett exempel.

#1. Fånga olika undantag i olika block

Anta att vi hade ett program utformat för att ta in två olika värden och dela upp dem. I det här programmet räknar vi med att olika typer av undantag kommer att uppstå när användaren anger ogiltiga värden. I synnerhet vill vi hantera ValueError och ZeroDivisionError.

ValueError kommer att höjas när användaren matar in ett värde som inte kan konverteras till ett heltal. ZeroDivisionError kommer att höjas när den andra siffran är en nolla. I båda dessa fall vill vi visa ett felmeddelande som säger ”Du har angett ett ogiltigt värde”.

För att göra ovanstående kan vi skriva följande kod:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except ValueError as e:
    print("You entered an invalid value")
except ZeroDivisionError as e:
    print("You entered an invalid value")
except Exception as e:
    print("Something went wrong")

Om vi ​​kör ovanstående kod och text som inte kan konverteras till ett heltal blir detta resultatet:

Och om vi angav den andra siffran som en 0, skulle detta bli resultatet:

Koden fungerar som förväntat, men lägg märke till att vi hanterar ValueError och ZeroDivisionError på liknande sätt. Så det finns en hel del kodduplicering mellan de två Except-blocken. Detta är inte idealiskt, eftersom vi bryter mot DRY-principen i programmering. DRY-principen säger att du inte upprepar dig själv.

Så istället för att skriva koden separat kan vi kombinera de två blocken till ett block som fångar flera undantag. Om vi ​​gör det undviker vi upprepningen.

#2. Fånga flera undantag i ett undantagsblock

För att fånga flera undantag tillhandahåller vi en tupel som anger alla fel vi vill fånga. Här är ett exempel där vi fångar både ValueError och ZeroDivisionError i ett utom block:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("You entered an invalid value")
except Exception as e:
    print("Something went wrong")

Detta är en mycket bättre implementering än koden tidigare. I grund och botten är detta vad hantering av flera undantag handlar om. Koden ovan fungerar på samma sätt som tidigare. Om du testar med de tidigare exemplen bör det fungera som tidigare:

#3. Identifiera vilket undantag som har fångats

Koden ovan exekverar det första undantagsblocket när antingen ett ValueError eller ett ZeroDivisionError har fångats. I vissa fall kan du ha kod du vill köra för båda felen och någon annan kod du vill köra för det ena men inte det andra felet.

I det här fallet måste du först identifiera vilket fel som har fångats och köra lämplig kod.

För att identifiera vilket undantag som har fångats kan du använda ett if/else-block inuti undantagsblocket. Till exempel:

try:
    dividend = int(input('Enter first num: '))
    divisor = int(input('Enter second num: '))
    quotient = dividend / divisor
    print(quotient)
except (ValueError, ZeroDivisionError) as e:
    print("You entered an invalid value")

    if isinstance(e, ValueError):
        print('Value Error')
    else:
        print('Zero Division Error')
except Exception as e:
    print("Something went wrong")

I det här blocket, förutom att skriva ut det allmänna felmeddelandet för både ValueError och ZeroDivisionError, kontrollerar vi också exakt vilken typ av fel vi fångade och skriver ut ytterligare ett meddelande. Om vi ​​testar koden igen bör vi se några ytterligare meddelanden som är specifika för undantaget.

När skulle du vilja hantera flera undantag?

I det allmänna fallet är hantering av flera undantag idealiskt när du vill köra samma kod för liknande undantag som kan uppstå. Detta inkluderar följande:

  • Nätverksbegäranden som misslyckades av olika anledningar. Oavsett vilket kanske du vill meddela användaren att servern inte kunde nås.
  • Misslyckade databasanslutningar, vilket ger flera fel. Även om dessa fel kan vara olika, kan din hantering vara densamma.
  • File I/O producerar också fel som kan hanteras på liknande sätt, såsom behörighets- och diskfulla fel.

Slutsats

Den här artikeln diskuterade att kombinera flera utom block till ett genom att fånga flera undantag samtidigt. Detta hjälper din kod att bli mer läsbar och underhållbar. Därefter kanske du vill läsa den här artikeln om Python Beginner Projects som du bör prova.