Sådan håndteres undtagelser i Python

Undtagelseshåndtering er din evne til at tilpasse og vise fejlmeddelelser for dele af dit program, der ikke fungerer.

Uanset om du bygger et websted, laver et API, et modul eller ethvert andet produkt ved hjælp af Python, giver din evne til effektivt at håndtere undtagelser dig eksplicit at angive årsagen til en fejl.

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

Sådan fungerer undtagelseshåndtering i Python

Når du hæver undtagelser, beder du Python om at oprette en besked, når en blok med kode mislykkes. Undtagelsesbehandling er som at bede nogen om at prøve at løfte en vægt. Og hvis de ikke kan, skal de fortælle dig det.

For at hæve en undtagelse i Python skal du dog bede Python om at prøve at køre en bestemt kodeblok. Hvis denne blok mislykkes, kan du derefter bede Python om at hæve en defineret undtagelse til den mislykkede kode.

Hvornår skal du bruge undtagelser i Python-programmering?

Ved de fleste lejligheder kan du maskere standard Python-fejl ved hjælp af undtagelser. Men du skal være opmærksom, da dette kan forårsage fejlretningsproblemer. Derfor kan det være svært for dig at finde ud af årsagen til en eventuel fejl.

Derfor skal du bruge undtagelser, når du har testet din kode tilstrækkeligt, og du er sikker på, at den fungerer. I sidste ende er det bedste praksis at bruge dem til at håndtere potentielle fejl, der kan opstå fra brugerens ende snarere end selve koden.

Med andre ord kan du bruge undtagelser som et advarselsværktøj til at guide brugerne til, hvordan du bruger dit program.

Håndtering af Python-undtagelser

For at håndtere undtagelser i Python skal du først indpakke din kode i en prøv... undtagen blok. Lejlighedsvis skal du muligvis medtage en langt om længe erklæring til at håndtere yderligere handlinger afhængigt af dine behov.

Kodningskonceptet med Python-undtagelser ser generelt sådan ud:

prøve:
"kode, der skal udføres"
undtagen:
"fejl besked"

Som nævnt tidligere kan du også bruge langt om længe i en undtagelsesblok. Men koden du skriver inde i langt om længe klausul er uafhængig og kører, uanset om der er en undtagelse eller ej.

I det væsentlige er det praktisk, hvis du har en anden blok kode, som du vil køre kontinuerligt, uanset hvad der sker inden for prøv... undtagen blok.

Her er et eksempel:

prøve:
print (9 + 6)
undtagen:
print ("fejlmeddelelse")
langt om længe:
udskriv ("genstart")
Produktion:
15
genstart 

I ovenstående kode, genstart kører kontinuerligt, uanset om der er en undtagelse eller ej.

En andet tilstand kan også følge en undtagen udmelding:

prøve:
C = 2 + B
undtagen:
print ("B skal defineres")
andet:
udskriv (u "Tilføjet med succes! Resultatet er% s "% (C))
Produktion: B skal defineres

Prøv det igen med "B" defineret:

prøve:
B = 5
C = 2 + B
undtagen:
print ("B skal defineres")
andet:
udskriv (u "Tilføjet med succes! Resultatet er% s "% (C))
Produktion: Tilføjet med succes! Resultatet er 7

Ovenstående eksempler er ikke-standardiserede undtagelser. Men du kan have en mere eksplicit undtagelse, når du kombinerer indbyggede (definerede) undtagelser med ikke-standardiserede:

prøve:
C = 2 + B
undtagen NameError som err:
print (err, ":", "B skal defineres, tak")
andet:
udskriv (u "Tilføjet med succes! Resultatet er% s "% (C))
Produktion: navn 'B' er ikke defineret: B skal defineres, tak

Ovenstående undtagelse kontrollerer først, om der er en NameError i prøve blok. Derefter udskrives standarden NameError undtagelse først ("navn 'B' er ikke defineret"). Og understøtter det med din skriftlige undtagelse ("B skal defineres, tak").

Relaterede: Grundlæggende programmeringsprincipper Hver programmør skal vide

Og hvis du vil håndtere en række undtagelser, kan du også ledsage en prøve blokere med mange undtagen udsagn. Dette er ret praktisk, hvis din prøve blok har potentialet til at have mange undtagelser:

prøve:
B = 5
C = 2 + B
D = flyde (6)
F = 7/0
undtagen NameError som err:
print (err, ":", "B skal defineres, tak")
undtagen ValueError som val:
print (val, ":", "Du kan ikke konvertere disse data")
undtagen ZeroDivisionError som zeroerr:
print (zeroerr, ":", "Du kan ikke dele et tal med nul")
andet:
udskriv (u "Drift vellykket! Resultaterne er:% s,% s og% s "% (C, D, F))
Produktion: division med nul: Du kan ikke dele et tal med nul

Hvad hvis divisionen er gyldig? For eksempel udskiftning F = 7/0 i ovenstående kode med F = 7/5 giver:

Produktion: Drift vellykket! Resultaterne er: 7, 6.0 og 1.4

Brugerdefinerede undtagelser i Python

Du kan også komme med din undtagelse og ringe til dem senere i dit program. Dette giver dig mulighed for at give en specifik beskrivelse af din undtagelse og navngive den, som du vil.

Ikke desto mindre kommer hver brugerdefineret undtagelse (direkte eller indirekte) stadig fra den indbyggede Undtagelse klasse af Python.

Eksempelkoden nedenfor henviser til basen Undtagelse direkte ved at ringe RuntimeError fra det:

class connectionError (RuntimeError):
def __init __ (selv, værdi):
self.value = værdi
prøve:
hæve connectionError ("Dårligt værtsnavn")
undtagen forbindelse Fejl som fejl:
udskriv (fejlværdi)
Produktion: Dårligt værtsnavn

Noter det forbindelsesfejli dette tilfælde er en brugerdefineret klasse, som du kan hæve når som helst du har brug for det i dit program.

Relaterede: Begyndervejledningen til regulære udtryk med Python

Du kan lave en brugerdefineret undtagelse ved at udlede den direkte fra Undtagelse basisklasse. Undtagelsen nedenfor forhindrer imidlertid subtraktion af 5 fra 6 og kalder undtagelsen direkte fra basisklassen:

klassefejl (undtagelse):
passere
klasse sixFiveError (fejl):
def __init __ (selv, værdi, besked):
self.value = værdi
self.message = besked
prøve:
hæv sixFiveError (6-5, "Denne undergrund er ikke tilladt")
undtagen sixFiveError som e:
print ("Der opstod en fejl:", e.message)
Produktion: Der opstod en fejl: Denne substration er ikke tilladt

I praksis kan du bruge en undtagelse, du definerede tidligere, ved at kalde den i en anden funktion. For eksempel kan du oprette en floatError der kun tillader tilføjelse af to flyder:

# Ring først til basisundtagelsesklasser:
klassefejl (undtagelse):
passere
# Få derefter din egen undtagelse fra basisklassen:
klasse FloatError (fejl):
def __init __ (selv, værdi, besked):
self.value = værdi
self.message = besked
# Opret en funktion for at tilføje to floats:
def addTwoFloat (a, b):
hvis (type (a) og type (b))! = float:
hæve FloatError (a + b, "Tallene skal flyde for at tilføje")
andet:
udskrive (a + b)
addTwoFloat (4, 7)
Produktion: __main __. FloatError: (11, 'Numbers must be float to add')

Fordi du nu har defineret en FloatError klasse hæver Python det, hvis du forsøger at tilføje to ikke-flydende bogstaver ved hjælp af addtwoFloat fungere.

Du kan udskrive FloatError klasse i den samme Python-fil, hvor du har oprettet den for at se, hvad der sker:

udskrive (FloatError)
Produktion:

FloatErrorer dog ikke en indbygget Python-undtagelse. Du kan bekræfte dette ved at ringe FloatError i en anden frisk Python-fil, hvor du ikke har oprettet denne klasse:

udskrive (FloatError)
Produktion: NameError: navn 'FloatError' er ikke defineret

Du får en NameError fordi Python ikke genkender det som en standardundtagelse.

Du kan også prøve selvdefinerende andre fejlklasser for at se, hvordan de spiller ud.

Gør dine Python-programmer mere brugervenlige med undtagelser

Der er mange standardundtagelser i Python. Men du kan også definere din. Ikke desto mindre afhænger brugervenligheden af ​​dit program til en vis grad af, hvordan det håndterer forskellige undtagelser (hvad enten brugerdefineret, ikke-specifik eller standard).

Undtagelser giver dig dog mulighed for at diktere, hvordan dit program skal fungere, når brugerne interagerer med dem. En tydelig og kortfattet angivelse af årsagen til en fejl giver også brugerne en heads up om, hvad de laver forkert, og nogle gange peger det dem i den rigtige retning.

Sådan debugges din Python-kode

Udstyr dig selv med know-how til at squash hver Python-bug på din vej.

Læs Næste

Om forfatteren