Hur man hanterar undantag i Python

Undantagshantering är din förmåga att anpassa och visa felmeddelanden för delar av programmet som inte fungerar.

Oavsett om du bygger en webbplats, skapar ett API, en modul eller någon annan produkt som använder Python, kan du på ett effektivt sätt hantera undantag uttryckligen orsaken till ett fel.

Här tar vi en titt på hur du kan hantera undantag i Python.

Hur undantagshantering fungerar i Python

När du tar upp undantag säger du till Python att ta upp ett meddelande när ett kodblock misslyckas. Undantagshantering är som att berätta för någon att försöka lyfta en vikt. Och om de inte kan, borde de meddela dig.

För att höja ett undantag i Python säger du dock till Python att försöka köra ett visst kodblock. Om blocket misslyckas kan du sedan be Python att höja ett definierat undantag från den misslyckade koden.

När ska du använda undantag i Python-programmering?

Vid de flesta tillfällen kan du maskera standard Python-fel med undantag. Men du måste vara vaksam, eftersom det kan orsaka problem med felsökning. Följaktligen kan det vara svårt att ta reda på orsaken till ett eventuellt fel.

Därför bör du använda undantag när du har testat din kod tillräckligt och du är säker på att den fungerar. I slutändan är det bästa praxis att använda dem för att hantera potentiella fel som kan uppstå från användarens ände snarare än själva koden.

Med andra ord kan du använda undantag som ett varningsverktyg för att vägleda användare om hur du använder ditt program.

Hantering av Python-undantag

För att hantera undantag i Python måste du först slå in din kod i en försök... förutom blockera. Ibland kan du behöva inkludera en till sist uttalande för att hantera ytterligare åtgärder, beroende på dina behov.

Kodkonceptet för Python-undantag ser generellt ut så här:

Prova:
"kod som ska köras"
bortsett från:
"felmeddelande"

Som nämnts tidigare kan du också använda till sist i ett undantagsblock. Men koden du skriver inuti en till sist klausul är oberoende och kör oavsett om det finns ett undantag eller inte.

I huvudsak kommer det till nytta om du har ett annat kodblock som du vill köra kontinuerligt oavsett vad som händer inom försök... förutom blockera.

Här är ett exempel:

Prova:
tryck (9 + 6)
bortsett från:
skriv ut ("felmeddelande")
till sist:
skriv ut ("starta om")
Produktion:
15
snälla starta om 

I ovanstående kod, snälla starta om körs kontinuerligt, oavsett om det finns ett undantag eller inte.

Ett annan tillstånd kan också följa en bortsett från påstående:

Prova:
C = 2 + B.
bortsett från:
tryck ("B måste definieras")
annan:
skriv ut (u "Tillagt framgångsrikt! Resultatet är% s "% (C))
Produktion: B måste definieras

Försök nu igen med "B" definierat:

Prova:
B = 5
C = 2 + B.
bortsett från:
tryck ("B måste definieras")
annan:
skriv ut (u "Tillagt framgångsrikt! Resultatet är% s "% (C))
Produktion: Tillagt framgångsrikt! Resultatet är 7

Ovanstående exempel är icke-standardiserade undantag. Men du kan ha ett mer uttryckligt undantag när du kombinerar inbyggda (definierade) undantag med icke-standardiserade:

Prova:
C = 2 + B.
utom NameError som err:
skriv ut (err, ":", "B måste definieras, snälla")
annan:
skriv ut (u "Tillagt framgångsrikt! Resultatet är% s "% (C))
Produktion: namn 'B' är inte definierat: B måste definieras, snälla

Ovanstående undantag kontrollerar först om det finns en NameError i Prova blockera. Det skriver sedan ut standarden NameError undantag först ("namn" B "definieras inte"). Och stöder det med ditt skriftliga undantag ("B måste definieras, snälla").

Relaterad: Grundläggande programmeringsprinciper Varje programmerare måste veta

Och om du vill hantera en kedja av undantag kan du också följa med en Prova blockera med många bortsett från uttalanden. Detta är ganska praktiskt om din Prova block har potential att ha många undantag:

Prova:
B = 5
C = 2 + B.
D = flottör (6)
F = 7/0
utom NameError som err:
skriv ut (err, ":", "B måste definieras, snälla")
utom ValueError som val:
print (val, ":", "Du kan inte konvertera dessa data")
utom ZeroDivisionError som zeroerr:
print (zeroerr, ":", "Du kan inte dela ett tal med noll")
annan:
skriv ut (u "Drift framgångsrik! Resultaten är:% s,% s och% s "% (C, D, F))
Produktion: division med noll: Du kan inte dela ett tal med noll

Vad händer om uppdelningen är giltig? Till exempel ersätter F = 7/0 i ovanstående kod med F = 7/5 ger:

Produktion: Drift framgångsrik! Resultaten är: 7, 6,0 och 1,4

Användardefinierade undantag i Python

Du kan också komma med ditt undantag och ringa dem senare i programmet. Detta låter dig ge en specifik beskrivning av ditt undantag och namnge det som du vill.

Ändå kommer varje användardefinierat undantag (direkt eller indirekt) fortfarande från det inbyggda Undantag klass av Python.

Exempelkoden nedan hänvisar till basen Undantag direkt genom att ringa RuntimeError från det:

class connectionError (RuntimeError):
def __init __ (själv, värde):
självvärde = värde
Prova:
höja connectionError ("Bad hostname")
utom anslutningFel som fel:
skriva ut (err.value)
Produktion: Dåligt värdnamn

Anteckna det Anslutningsfel, i det här fallet, är en användardefinierad klass som du kan höja när du behöver den i ditt program.

Relaterad: Nybörjarguiden för regelbundna uttryck med Python

Du kan göra ett användardefinierat undantag genom att härleda det direkt från Undantag basklass. Undantaget nedan förhindrar dock subtraktion av 5 från 6 och kallar undantaget från basklassen direkt:

klassfel (undantag):
passera
klass sixFiveError (fel):
def __init __ (själv, värde, meddelande):
självvärde = värde
självmeddelande = meddelande
Prova:
höj sexFiveError (6-5, "Denna substration är inte tillåten")
förutom sixFiveError som e:
skriv ut ("Det uppstod ett fel:", e.message)
Produktion: Det uppstod ett fel: Det här substratet är inte tillåtet

I praktiken kan du använda ett undantag som du definierat tidigare genom att anropa det i en annan funktion. Du kan till exempel skapa en floatError som bara tillåter tillägg av två flottörer:

# Ring först basundantagsklasserna:
klassfel (undantag):
passera
# Hämta sedan ditt eget undantag från basklassen:
klass FloatError (fel):
def __init __ (själv, värde, meddelande):
självvärde = värde
självmeddelande = meddelande
# Skapa en funktion för att lägga till två flottörer:
def addTwoFloat (a, b):
om (typ (a) och typ (b))! = flottör:
höja FloatError (a + b, "Siffrorna måste flyttas för att lägga till")
annan:
skriva ut (a + b)
addTwoFloat (4, 7)
Produktion: __main __. FloatError: (11, 'Numbers must be float to add')

Eftersom du nu har definierat en FloatError klass, höjer Python det om du försöker lägga till två icke-flytande bokstäver med hjälp av addtwoFloat fungera.

Du kan skriva ut FloatError klass i samma Python-fil där du har skapat den för att se vad som händer:

skriva ut (FloatError)
Produktion:

FloatErrorär dock inte ett inbyggt Python-undantag. Du kan verifiera detta genom att ringa FloatError i en annan ny Python-fil där du inte har skapat den här klassen:

skriva ut (FloatError)
Produktion: NameError: namn 'FloatError' definieras inte

Du får en NameError eftersom Python inte känner igen det som ett standardundantag.

Du kan också försöka självdefiniera andra felklasser för att se hur de spelar ut.

Gör dina Python-program mer användarvänliga med undantag

Det finns många standardundantag i Python. Men du kan också definiera din. Ändå beror användarvänligheten av ditt program i viss mån på hur det hanterar olika undantag (vare sig användardefinierade, ospecifika eller standard).

Undantag låter dig dock diktera hur ditt program ska fungera när användare interagerar med dem. Att tydligt och kortfattat ange orsaken till ett fel ger också användarna en insikt om vad de gör fel, och ibland pekar det dem i rätt riktning.

Hur du felsöker din Python-kod

Utrusta dig med kunskapen att squasha alla Python-buggar i din väg.

Läs Nästa

Om författaren