Fange flere unntak i Python: En enkel guide

Håndtering av unntak i Python: En guide til flere feil i samme blokk

I Python er evnen til å håndtere unntak essensiell for å skape robuste og pålitelige programmer. Ved å fange opp uventede hendelser, unngår man krasj og sikrer en bedre brukeropplevelse. Denne artikkelen tar for seg hvordan man effektivt kan håndtere flere typer unntak i en enkelt `try/except`-blokk.

Hva er unntak i Python?

Unntak i Python fungerer som en kommunikasjonskanal mellom ulike deler av programmet. Når en del av systemet oppdager en kritisk feil den ikke kan håndtere selv, genereres et unntak. En annen del av programmet, som er utstyrt for å håndtere denne type feil, vil fange unntaket og iverksette passende tiltak. Uten slik håndtering vil unntak føre til at programmet krasjer. Derfor er det viktig å implementere unntakshåndtering for å øke stabiliteten og påliteligheten til applikasjonene dine. Forutsetningen for denne artikkelen er at du er kjent med grunnleggende konsepter for å generere og håndtere unntak.

Viktigheten av å håndtere flere unntak

Å håndtere flere unntak i Python har flere fordeler:

• Det reduserer redundans i koden ved at flere unntak behandles i samme blokk. Dette forenkler lesing, redigering og vedlikehold av koden.
• Det bidrar til mer effektiv kode ved at feiltypen kun må sjekkes én gang i stedet for flere ganger.

Håndtering av flere unntak

Å fange opp flere unntak betyr å håndtere ulike feil i den samme `except`-blokken. I Python kan du håndtere hvert unntak i separate `except`-blokker. Imidlertid, når du ønsker å håndtere ulike unntak på samme måte, kan du samle dem i én enkelt blokk. Dette krever at du fanger flere unntak samtidig. Nedenfor skal vi se på hvordan dette gjøres med et eksempel.

#1. Fange forskjellige unntak i forskjellige blokker

La oss tenke oss et program som tar inn to tall fra brukeren og deler det ene tallet på det andre. I dette programmet vil det kunne oppstå flere typer unntak dersom brukeren skriver inn ugyldige verdier. Vi ønsker spesifikt å håndtere `ValueError` og `ZeroDivisionError`. `ValueError` oppstår når brukeren skriver inn en verdi som ikke kan konverteres til et heltall, mens `ZeroDivisionError` vil oppstå når det andre tallet er null. I begge tilfeller ønsker vi å vise en feilmelding som sier «Du har skrevet inn en ugyldig verdi».

En måte å løse dette på, er ved å bruke følgende kode:

  try:
      dividend = int(input('Skriv inn første tall: '))
      divisor = int(input('Skriv inn andre tall: '))
      quotient = dividend / divisor
      print(quotient)
  except ValueError as e:
      print("Du har skrevet inn en ugyldig verdi")
  except ZeroDivisionError as e:
      print("Du har skrevet inn en ugyldig verdi")
  except Exception as e:
      print("Noe gikk galt")
  

Hvis vi kjører koden og skriver inn en tekst som ikke kan konverteres til et tall, får vi følgende resultat:

Dersom vi derimot skriver 0 som det andre tallet får vi dette:

Koden fungerer som forventet, men vi ser at vi håndterer `ValueError` og `ZeroDivisionError` på samme måte, noe som fører til mye kode duplisering. Dette er ikke ideelt, da det bryter med DRY-prinsippet i programmering (Don’t Repeat Yourself).

I stedet for å skrive kode for hvert unntak, kan vi kombinere de to blokkene i en enkelt blokk som fanger flere unntak. Dette vil eliminere gjentakelsen.

#2. Å fange flere unntak i en `except`-blokk

For å fange opp flere unntak samtidig, bruker vi en tuppel som spesifiserer alle feilene vi ønsker å fange. Her er et eksempel hvor vi fanger både `ValueError` og `ZeroDivisionError` i en enkelt `except`-blokk:

  try:
      dividend = int(input('Skriv inn første tall: '))
      divisor = int(input('Skriv inn andre tall: '))
      quotient = dividend / divisor
      print(quotient)
  except (ValueError, ZeroDivisionError) as e:
      print("Du har skrevet inn en ugyldig verdi")
  except Exception as e:
      print("Noe gikk galt")
    

Dette er en mye bedre implementasjon enn den tidligere. Koden ovenfor vil fungere på samme måte som før. Hvis du tester med de samme eksemplene vil du se at resultatet er det samme:

#3. Identifisere hvilket unntak som har blitt fanget

Koden ovenfor utfører den første `except`-blokken hvis enten en `ValueError` eller en `ZeroDivisionError` har blitt fanget. I noen tilfeller kan det være at du ønsker å utføre en spesiell kode for hver type feil. I slike tilfeller må du identifisere hvilken feil som har oppstått, og utføre passende kode.

For å identifisere unntaket som har blitt fanget, kan du bruke en `if/else`-blokk inne i `except`-blokken. For eksempel:

  try:
      dividend = int(input('Skriv inn første tall: '))
      divisor = int(input('Skriv inn andre tall: '))
      quotient = dividend / divisor
      print(quotient)
  except (ValueError, ZeroDivisionError) as e:
      print("Du har skrevet inn en ugyldig verdi")

      if isinstance(e, ValueError):
          print('Verdi feil')
      else:
          print('Null divisjonsfeil')
  except Exception as e:
      print("Noe gikk galt")
    

I denne koden, i tillegg til å skrive ut den generiske feilmeldingen, sjekker vi også nøyaktig hvilken type feil vi fanget, og skriver ut en tilleggsmelding. Hvis vi tester koden, vil vi se de ekstra meldingene som er spesifikke for hvert unntak.

Når ønsker du å håndtere flere unntak?

Generelt sett er det ideelt å håndtere flere unntak når du ønsker å utføre den samme koden for lignende feil. Dette kan omfatte følgende:

• Nettverksforespørsler som feiler av ulike årsaker. Det kan være hensiktsmessig å varsle brukeren om at serveren ikke er tilgjengelig.
• Mislykkede databasetilkoblinger. Selv om feilene kan være ulike, kan håndteringen være den samme.
• Fil I/O som genererer feil, som kan håndteres på samme måte (f.eks. tillatelsesfeil, full disk osv.).

Konklusjon

Denne artikkelen har tatt for seg hvordan man kan kombinere flere `except`-blokker til én ved å fange opp flere unntak samtidig. Dette vil føre til at koden din blir mer lesbar, ryddig og vedlikeholdbar.