Hvordan håndtere unntak i Python

Unntakshåndtering er din evne til å tilpasse og vise feilmeldinger for deler av programmet som ikke fungerer.

Enten du bygger et nettsted, lager en API, en modul eller et hvilket som helst annet produkt som bruker Python, kan du eksplisitt oppgi årsaken til en feil ved din evne til effektivt å håndtere unntak.

Her ser vi på hvordan du kan håndtere unntak i Python.

Hvordan Unntakshåndtering fungerer i Python

Når du tar opp unntak, ber du Python om å ta opp en melding når en blokk med kode mislykkes. Unntakshåndtering er som å fortelle noen å prøve å løfte en vekt. Og hvis de ikke kan, bør de gi deg beskjed.

For å heve et unntak i Python, vil du imidlertid be Python om å prøve å kjøre en bestemt blokk med kode. Hvis blokkeringen mislykkes, kan du be Python om å heve et definert unntak fra den mislykkede koden.

Når skal du bruke unntak i Python-programmering?

Ved de fleste anledninger kan du maskere standard Python-feil ved hjelp av unntak. Men du må være årvåken, da dette kan føre til feilsøkingsproblemer. Derfor kan det være vanskelig å finne ut av årsaken til en eventuell feil.

Derfor bør du bruke unntak når du har testet koden din tilstrekkelig, og du er sikker på at den fungerer. Til slutt er det best å bruke dem til å håndtere potensielle feil som kan oppstå fra brukerens slutt i stedet for selve koden.

Med andre ord, du kan bruke unntak som et advarselverktøy for å veilede brukere om hvordan du bruker programmet ditt.

Håndtering av Python-unntak

For å håndtere unntak i Python, må du først pakke koden i en prøv... bortsett fra blokkere. Noen ganger må du kanskje inkludere en endelig uttalelse for å håndtere videre handlinger, avhengig av dine behov.

Kodingskonseptet med Python-unntak ser generelt slik ut:

prøve:
"kode som skal utføres"
unntatt:
"feilmelding"

Som nevnt tidligere kan du også bruke endelig i en unntaksblokk. Men koden du skriver inne i endelig klausul er uavhengig og kjører enten det er et unntak eller ikke.

I hovedsak kommer det til nytte hvis du har en ny blokk med kode som du vil kjøre kontinuerlig uavhengig av hva som skjer i prøv... bortsett fra blokkere.

Her er et eksempel:

prøve:
trykk (9 + 6)
unntatt:
skriv ut ("feilmelding")
endelig:
skriv ut ("start på nytt")
Produksjon:
15
vennligst start på nytt 

I koden ovenfor, vennligst start på nytt kjører kontinuerlig, uavhengig av om det er et unntak eller ikke.

An ellers tilstand kan også følge en unntatt uttalelse:

prøve:
C = 2 + B
unntatt:
utskrift ("B må defineres")
ellers:
skriv ut (u "Lagt til vellykket! Resultatet er% s "% (C))
Produksjon: B må defineres

Prøv det igjen med "B" definert:

prøve:
B = 5
C = 2 + B
unntatt:
utskrift ("B må defineres")
ellers:
skriv ut (u "Lagt til vellykket! Resultatet er% s "% (C))
Produksjon: Lagt til vellykket! Resultatet er 7

Ovennevnte eksempler er unstandardiserte unntak. Men du kan ha et mer eksplisitt unntak når du kombinerer innebygde (definerte) unntak med ikke-standardiserte:

prøve:
C = 2 + B
unntatt NameError som err:
skriv ut (err, ":", "B må defineres, vær så snill")
ellers:
skriv ut (u "Lagt til vellykket! Resultatet er% s "% (C))
Produksjon: navnet 'B' er ikke definert: B må defineres, vær så snill

Ovennevnte kontrollerer først om det er et NameError i prøve blokkere. Deretter skrives ut standarden NameError unntak først ("navnet 'B' er ikke definert"). Og støtter det med ditt skriftlige unntak ("B må defineres, vær så snill").

I slekt: Grunnleggende programmeringsprinsipper Hver programmerer må vite

Og hvis du vil håndtere en rekke unntak, kan du også følge med på prøve blokk med mange unntatt uttalelser. Dette er ganske praktisk hvis din prøve block har potensial til å ha mange unntak:

prøve:
B = 5
C = 2 + B
D = flottør (6)
F = 7/0
unntatt NameError som err:
skriv ut (err, ":", "B må defineres, vær så snill")
unntatt ValueError som val:
print (val, ":", "Du kan ikke konvertere dataene")
unntatt ZeroDivisionError som zeroerr:
print (zeroerr, ":", "Du kan ikke dele et tall med null")
ellers:
skriv ut (u "Vellykket drift! Resultatene er:% s,% s og% s "% (C, D, F))
Produksjon: divisjon med null: Du kan ikke dele et tall med null

Hva om inndelingen er gyldig? For eksempel å erstatte F = 7/0 i koden ovenfor med F = 7/5 gir:

Produksjon: Drift vellykket! Resultatene er: 7, 6.0 og 1.4

Brukerdefinerte unntak i Python

Du kan også komme med unntaket ditt og ringe dem senere i programmet. Dette lar deg gi en spesifikk beskrivelse av unntaket ditt og navngi det slik du vil.

Ikke desto mindre kommer hvert brukerdefinert unntak (direkte eller indirekte) fremdeles fra den innebygde Unntak klasse av Python.

Eksempelkoden nedenfor viser til basen Unntak direkte ved å ringe RuntimeError fra det:

class connectionError (RuntimeError):
def __init __ (selv, verdi):
self.value = verdi
prøve:
heve connectionError ("Dårlig vertsnavn")
unntatt tilkobling Feil som feil:
skriv ut (feil verdi)
Produksjon: Dårlig vertsnavn

Noter det tilkoblingsfeil, i dette tilfellet, er en brukerdefinert klasse, som du kan øke når du trenger det i programmet ditt.

I slekt: Beginner's Guide to Regular Expressions With Python

Du kan lage et brukerdefinert unntak ved å utlede det direkte fra Unntak baseklasse. Unntaket nedenfor forhindrer imidlertid subtraksjon fra 5 fra 6 og kaller unntaket fra basisklassen direkte:

klassefeil (unntak):
sende
klasse sixFiveError (feil):
def __init __ (selv, verdi, melding):
self.value = verdi
self.message = melding
prøve:
heve sixFiveError (6-5, "Denne undergrunnen er ikke tillatt")
unntatt sixFiveError som e:
print ("Det oppstod en feil:", e.message)
Produksjon: Det oppstod en feil: Denne undergrunnen er ikke tillatt

I praksis kan du bruke et unntak du definerte tidligere ved å kalle det i en annen funksjon. For eksempel kan du opprette en floatError som bare tillater tillegg av to flyter:

# Ring først basen unntaksklassene:
klassefeil (unntak):
sende
# Deretter får du ditt eget unntak fra baseklassen:
klasse FloatError (feil):
def __init __ (selv, verdi, melding):
self.value = verdi
self.message = melding
# Opprett en funksjon for å legge til to flyter:
def addTwoFloat (a, b):
hvis (type (a) og type (b))! = flyte:
heve FloatError (a + b, "Tallene må være flytende for å legge til")
ellers:
skriv ut (a + b)
addTwoFloat (4, 7)
Produksjon: __main __. FloatError: (11, 'Tallene må være flytende for å legge til')

Fordi du nå har definert en FloatError klasse, hever Python det hvis du prøver å legge til to ikke-flytende bokstaver ved hjelp av addtwoFloat funksjon.

Du kan skrive ut FloatError klasse i den samme Python-filen der du har opprettet den for å se hva som skjer:

skriv ut (FloatError)
Produksjon:

FloatErrorer imidlertid ikke et innebygd Python-unntak. Du kan bekrefte dette ved å ringe FloatError i en annen fersk Python-fil der du ikke har opprettet denne klassen:

skriv ut (FloatError)
Produksjon: NameError: name 'FloatError' er ikke definert

Du får en NameError fordi Python ikke gjenkjenner det som et standard unntak.

Du kan også prøve å definere andre feilklasser for å se hvordan de spiller ut.

Gjør dine Python-programmer mer brukervennlige med unntak

Det er mange standard unntak i Python. Men du kan også definere din. Likevel avhenger den enkle bruken av programmet til en viss grad av hvordan det håndterer forskjellige unntak (enten brukerdefinerte, ikke-spesifikke eller standard).

Unntak lar deg imidlertid diktere hvordan programmet ditt skal fungere når brukere kommuniserer med dem. Å tydelig og kortfattet angi årsaken til en feil, gir brukerne også en heads up om hva de gjør galt, og noen ganger peker det dem i riktig retning.

Hvordan feilsøke Python-koden

Utstyr deg selv med kunnskapen til å knuse hver Python-feil i veien.

Les Neste

Om forfatteren