Den här handledningen förklarar undantagshantering i Python med hjälp av blocket Try Except med hjälp av programmeringsexempel:
Två feltyper kan orsaka att ett Pythonprogram stannar plötsligt, dvs. Syntaxfel , och Undantag I den här handledningen kommer vi att diskutera den andra feltypen (undantag) under flera viktiga ämnen.
Vi kommer att ha stor nytta av att hantera undantag i vår applikation, t.ex:
- Skapa en robust applikation.
- Skapa en ren och felfri kod.
Python Prova Except
En god nyhet är att Python har ett stort antal inbyggda undantag för att fånga upp fel i vår kod. Python ger oss också möjlighet att skapa egna undantag när inget av de inbyggda undantagen passar våra behov.
Vad är ett undantag?
Vad är ett undantag i Python? Enkelt uttryckt, när Python-tolken försöker köra ogiltig kod, så uppstår ett undantag, och i de fall då ett sådant undantag inte hanteras, störs det normala flödet av programmets instruktioner och en spårning skrivs ut.
Låt oss skapa en ogiltig kod och se hur Python-tolken reagerar.
Öppna ett Python-skal och kör följande kod.
>>>> 50/0
Detta är ett av de vanligaste felen i programmering. Ovanstående kod försöker dividera talet 50 av 0 (noll). Python-tolken ser detta som en ogiltig operation och ger upphov till en ZeroDivisionError , avbryter programmet och skriver ut en spårning.
Vi kan tydligt se att ZeroDivisionError är undantaget som togs upp. Det är Pythons eget sätt att tala om för oss att det inte är bra att dividera ett tal med noll. I andra språk, som JavaScript, är detta inte ett fel, men Python förbjuder detta strikt.
Det är också viktigt att veta att detta bara är ett undantagsobjekt och att Python har många sådana objekt inbyggda. Kolla in Pythons officiella dokumentation för att se alla Pythons inbyggda undantag.
Förståelse för spårning av återkoppling
Innan vi börjar hantera undantag tror jag att det är bra att förstå vad som händer om undantag inte hanteras och hur Python gör sitt bästa för att informera oss om våra fel.
När Python stöter på ett fel, så uppstår ett undantag. Om undantaget inte hanteras, så produceras en information som kallas Traceback. Vilken information innehåller denna traceback?
Den innehåller:
- Felmeddelandet som talar om vilket undantag som uppstod och vad som hände innan undantaget uppstod.
- De olika radnumren i den kod som orsakade felet. Ett fel kan orsakas av en sekvens av funktionsanrop som kallas en anropsstapel som vi kommer att diskutera senare här.
Även om det är lite förvirrande, lovar vi att nästa exempel kommer att ge oss mer kunskap.
Minns du den spårning som skrevs ut när du dividerade 50 med 0 ovan, kan vi se att spårningen innehåller följande information:
- Fil "": Detta visar att koden kördes från en konsolterminal.
- line 1: Detta talar om att felet inträffade på denna rad.
- ZeroDivisionError: delning genom noll: Den talar om vilket undantag som togs upp och vad som orsakade det.
Låt oss prova ett annat exempel och kanske se hur en anropsstapel ser ut som. Öppna en editor, skriv in koden nedan och spara som tracebackExp .py
def stack1(numb): # 1 div = 0 # 2 stack2(numb, div) # 3 def stack2(numb, div): # 5 compute = numb/div # 6 print(compute) # 7 if __name__ == '__main__': # 9 numb = 5 # 10 stack1(numb) # 11
Öppna en terminal i katalogen där filen finns och kör.
python tracebackExp.py
Följande spårning visas:
Ovanstående traceback kan verka förvirrande, men det är det inte. Pythonistas kom fram till det bästa sättet att läsa traceback, vilket är från nedifrån och upp Låt oss använda denna visdom för att försöka förstå vad denna spårning har att erbjuda.
- Längst ner visas det undantag som togs upp och varför det togs upp.
- När vi går uppåt får vi filnamnet tracebackExp .py där felet inträffade, beräkningen som orsakade felet compute = numb/div, funktionen stack2 och länken rad 6 där beräkningen utfördes.
- När vi går vidare ser vi att vår funktion stack2 anropades i funktionen stack1 på rad 3.
- När vi går till den översta ser vi att funktionen stack1 anropades på rad 11. < modul > visar att det är filen som körs.
Vanliga undantag i Python
Python-biblioteket definierar en hel del inbyggda undantag. Du kan läsa i Python-dokumentationen eller anropa den inbyggda lokal () enligt nedan:
>>>> dir(locals()['__builtins__'])
Vi ska inte försöka ta upp alla dessa undantag, men vi ska se på några vanliga undantag som du sannolikt kommer att stöta på.
#1) Typfel
Det uppstår när en operation eller funktion tillämpas på ett objekt av en olämplig typ.
Exempel 1
Tänk på nedanstående program som tar in en dividend och en divisor och sedan beräknar och skriver ut resultatet av att dividend divideras med divisorn.
def compute_division(): dividend = int(input("Ange dividend: ")) # kastar sträng till int divisor = input("Ange divisor: ") # ingen kastning # Beräkna divisionen result = dividend/divisor # skriv ut resultatet print("Resultatet av {}/{}} är: {}".format(dividend, divisor, result))) if __name__ == '__main__': result = compute_division() Vi begär värdet på dividend och divisor från användaren, men vi glömmer att omvandla divisorns strängvärde till ett heltal, vilket gör att dividendtypen är heltal( int ) och divisorns typ är string( str ). Vi får sedan Typfel eftersom divisionsoperatorn (/) inte fungerar på strängar.
Till skillnad från Python har Javascript Type Coercion som i princip omvandlar en av operandernas typer till ett likvärdigt värde av den andra operandens typ när operanderna är av olika typer.
#2) ValueError
Detta uppstår när en operation eller funktion tar emot ett argument som har rätt typ men ett olämpligt värde.
Exempel 2
Tänk på vårt program i Exempel 1 ovan.
Om användaren anger ett alfanumeriskt värde för utdelningen, till exempel "3a", kommer vårt program att ge upphov till undantaget ValueError. Detta beror på att även om Python-metoden int() tar in ett valfritt tal eller en sträng och returnerar ett heltalsobjekt, får strängvärdet inte innehålla bokstäver eller något annat icke-numeriskt värde.
#3) AttributeError
Det här undantaget uppstår när du tilldelar eller hänvisar till ett attribut som inte finns.
Exempel 3
Se på programmet nedan. Det tar in ett tal och beräknar dess kvadratrot med hjälp av Pythons matematiska modul.
import math # importera matematikbiblioteket för att få tillgång till dess kod def compute_square_root(number): # beräkna kvadratroten med hjälp av matematikbiblioteket result = math.sqr(number) return result if __name__ == '__main__': # hämta inmatning för beräkning från användaren number = int(input("Beräkna kvadratroten av: ")) # anropa funktionen för att beräkna kvadratroten När en användare skriver in ett tal försöker vårt program använda en funktion från matematikmodulen för att beräkna dess kvadratrot, men just här har vi gjort ett fel: I stället för sqrt skrev vi sqr, som inte finns i matematikmodulen.
Vi försökte alltså referera till ett attribut sqr som inte finns, vilket ledde till undantaget AttributeError. De flesta av oss gör ofta sådana här misstag, så du är inte ensam.
Hantera undantag med Try Except
Som programmerare är en sak som de flesta av oss ägnar vår tid åt att skriva en robust kod som är motståndskraftig. En kod som inte går sönder på grund av några fel. I Python kan vi uppnå detta genom att innesluta våra uttalanden i en prova - utom uttalande.
Python Try-Except uttalande
Try-except-angivelsen har följande struktur:
try: #din kod går här except """Specificera undantagstyp(er) här"""": #hantera undantaget här
Låt oss innesluta koden i tracebackExp .py i ett try-except-uttalande.
def stack1(numb): # 1 div = 0 # 2 stack2(numb, div) # 3 def stack2(numb, div): # 5 try: # 6 compute = numb/div # 7 print(compute) # 8 except ZeroDivisionError as zde: # 9 print(zde) # 10 if __name__ == '__main__': # 12 numb = 5 # 13 stack1(numb) # 14 print("program continuous") # 15 Om du kör den här koden får du följande resultat
Så här fungerar try-except-anvisningen: Python utför koden i try-blocket. rad 7-8 Om ingen ogiltig kod hittas, används koden i undantagsblocket. rad 10 hoppas över och utförandet fortsätter.
Men om en ogiltig kod hittas stoppas utförandet omedelbart i try-blocket och kontrollerar om det undantag som tagits upp stämmer överens med det vi angett i except-angivelsen. rad 9 Om det stämmer, utförs undantagsblocket och fortsätter. Om det inte stämmer, avbryts programmet.
Try-blocket innehåller vanligtvis den kod som kan ge upphov till ett undantag medan except-blocket fångar upp och hanterar undantaget.
Hantering av flera undantag med Except
Vi kan hantera flera undantag med antingen ett enda "except" eller flera "excepts". Allt beror på hur du vill hantera varje undantag.
#1) Hantering av flera undantag med ett enda undantag
try: #din kod går här except(Exception1[, Exception2[,...ExceptionN]]]]): #hantera undantaget här
Den här metoden används när vi misstänker att vår kod kan ge upphov till olika undantag och vi vill vidta samma åtgärd i varje fall. Om Python-tolken hittar en matchning kommer koden i except-blocket att köras.
Låt oss se på Python-koden nedan
def get_fraction(value, idx): arr = [4,5,2,0] # en lista med siffror idx_value = arr[idx] # om idx är> arr längd, kommer IndexError att uppstå value/idx_value # om idx_value == 0, kommer ZeroDivisionError att uppstå if __name__ =='__main__': # ange 'value' och 'idx' value = 54 idx = 3 # anropa funktionen i en try-except-anvisning. try: result = get_fraction(value, idx) print("Fraktion är ", result) except(IndexError, ZeroDivisionError) som ex: print(ex) Det finns två möjliga undantag som kan tas upp här, ZeroDivisionError och IndexError Om något av dessa undantag uppstår, kommer except-blocket att exekveras.
I koden ovan är idx=3, så idx_ värde blir 0 och värde /idx_ värde ger upphov till ZeroDivisionError
#2) Hantering av flera undantag med flera undantag
try: #din kod går här except Exception1: #handle exception1 here except Exception2: #handle exception2 here except ExceptionN: #handle exceptionN here
Om vi hellre vill hantera varje undantag separat kan du göra så här.
Se exempel på Python-koden nedan
def get_fraction(value, idx): arr = [4,5,2,0] # en lista med siffror idx_value = arr[idx] # om idx är> arr längd, kommer IndexError att uppstå value/idx_value # om idx_value == 0, kommer ZeroDivisionError att uppstå if __name__ =='__main__': # ange 'value' och 'idx' value = 54 idx = 5 # anropa funktionen i ett try-excepts-uttalande. try: result = get_fraction(value, idx) print("Fraktion är ", result) exceptIndexError: print("idx of {} is out of range".format(idx)) except ZeroDivisionError: print("arr[{}] is 0. Hence, can't divide by zero".format(idx)) except Exception as ex: print(ex) print("Not sure what happened so not safe to continue, \ app will be interrupted") raise ex Vi märker här att Exception användes i det sista except-kommandot. Detta beror på att undantagsobjektet Exception matchar alla undantag. Av denna anledning bör det alltid vara sist, eftersom Python slutar kontrollera andra undantagshanterare när ett undantag matchar.
I koden ovan, idx=5 Därför arr[idx] kommer att höja IndexError eftersom idx är större än längden på listan arr
Det är aldrig säkert att fortsätta exekveringen om man inte vet vilket undantag som togs upp av programmet. Det är därför vi har typen Exception för att fånga upp alla oförutsedda undantag. Sedan informerar vi användaren och avbryter programmet genom att ta upp samma undantag.
Try Else-uttalande
Detta är en valfri funktion av undantagshanteringen och låter dig lägga till kod som du vill köra när inga fel inträffar. Om ett fel inträffar körs inte detta else-block.
Ta exemplet på Pythonkoden nedan, öppna din editor och spara koden som elseTry.py
def fraction_of_one(divisor): value = 1/divisor # om divisorn är noll kommer ZeroDivisionError att uppstå return value if __name__ == '__main__': while True: try: # Få in data från användaren. # om inmatningen inte är ett giltigt argument för int() kommer ValueError att uppstå divisor = int(input("Ange en divisor: ")) # kalla vår funktion för att beräkna fraktionen value = fraction_of_one(divisor) except (ValueError,ZeroDivisionError): print("Inmatningen kan inte vara noll och bör vara en giltig bokstav för int(). Försök igen!") else: print("Värde: ", värde) break Vi får in data från användaren och använder den för att dividera 1. Vi har två möjliga undantag här, en ogiltig användarinmatning som kommer att orsaka ValueError och en noll(0) vilket kommer att leda till att ZeroDivisionError . Vårt except-statement hanterar dessa fel.
Nu vill vi skriva ut värdet på värde Vårt else-block ser till att den skrivs ut endast om vårt try-block utförs utan fel. Detta är viktigt eftersom om ett fel inträffar i vårt try-block kommer värde kommer att vara odefinierad, så om du öppnar den kommer ett nytt fel att uppstå.
Kör koden ovan med Python elseTry.py
Utmatningen ovan visar att vi för den första inmatningen skrev 0 och tryckte på ENTER. Eftersom vår divisor fick 0, höjde 1/divisor zeroDivisionError . Vår andra inmatning var k, vilket är ogiltigt för int (), därav undantaget ValueError höjs.
Men vår sista inmatning var 9, vilket är giltigt, och som ett resultat fick vi värdet " värde " skrivs ut som 0.1111111111111111111111
Försök slutligen uttalande
Detta är också en valfri funktion av undantagshanteringen och kommer alltid att köras oavsett vad som händer i undantagshanterarna.
Det vill säga:
- Om ett undantag inträffar eller inte
- Även om en "retur" krävs i de andra blocken.
- Även om skriptet avslutas i de andra blocken
Så om vi har en kod som vi vill köra i alla situationer är finally-blocket vår kille. Detta block används mest för att städa upp, till exempel för att stänga filer.
Se exempel på Python-koden nedan
def readFile(file_path): try: openFile = open(file_path,'r') # Öppna en fil som skrivskyddad print(openFile.readline()) # Läs första raden av filinnehållet except FileNotFoundError as ex: print(ex) finally: print("Rengöring...") openFile.close() if __name__ == '__main__': filePath = './text.txt' readFile(filePath) Den här koden försöker öppna och läsa filen text.txt i den aktuella katalogen. Om filen finns kommer programmet att skriva ut den första raden i filen och sedan kommer vårt finally-block att köra och stänga filen.
Säg att vi har en fil som heter text.txt i katalogen där den här programfilen finns och som innehåller Hello. Om vi kör programmet får vi följande utdata
Det här exemplet valdes avsiktligt eftersom jag ville att vi skulle ta upp ett litet problem som kan uppstå när man stänger filer i finally-blocket.
Om filen inte finns, kommer undantaget FileNotFoundError och variabeln openFile kommer inte att vara definierad och kommer inte att vara ett filobjekt. Därför kommer ett försök att stänga den i finally-blocket att ge upphov till ett undantag. UnboundLocalError som är en underklass till NameError .
Detta säger i princip att vi försöker hänvisa till variabeln openFile innan den har tilldelats.
Ett litet knep här är att använda undantagshanterare i finally-blocket.
def readFile(file_path): try: openFile = open(file_path,'r') # Öppna en fil som skrivskyddad print(openFile.readline()) # Läs första raden av filinnehållet except FileNotFoundError as ex: print(ex) finally: try: print("Rengöring...") openFile.close() except: # fångar upp alla undantag pass # Ignorera det här felet, eftersom vi inte bryr oss om det. if __name__ == '__main__': filePath = './text.txt' readFile(filePath) Om vårt försök-block ger upphov till FileNotFoundError får vi följande resultat
Utlysa ett undantag
En bra nyhet med Python-avvikelser är att vi kan avsiktligt väcka dem. Avvikelser väcks med höjning av deklarationen .
Upphöjningsangivelsen har följande syntax:
raise [ExceptionName[(*args: Object)]]
Öppna en terminal och ta upp ett undantag från Pythons inbyggda undantagsobjekt. Till exempel, om vi får ZeroDivisionError:
>>> raise ZeroDivisionError("Kan inte dividera med noll") Vi ska få en spårning:
Varför är det då viktigt att höja undantagen?
- När du arbetar med anpassade undantag.
- Under sanitetskontroller.
Anpassade undantagsklasser
Ett anpassat undantag är ett undantag som du skapar för att hantera fel som är specifika för ditt behov. Tricket är att vi definierar en klass som härstammar från objektet Undantag , sedan använder vi raise-anvisningen för att höja vår undantagsklass.
Anta att vi vill kontrollera användarens inmatning och se till att inmatningsvärdet inte är negativt (sanity check). Naturligtvis kan vi ta upp Python-undantaget ValueError, men vi vill anpassa felet genom att ge det ett specifikt och självförklarande namn, t.ex. InputIsNegativeError Men detta undantag är inte ett inbyggt undantag i Python.
Först skapar vi vår basklass som kommer att härledas från Exception.
class CustomError(Exception): "Grundklassundantag för alla undantag i den här modulen" pass
Sedan skapar vi vår undantagsklass som ärver basklassen och hanterar vårt specifika fel.
class InputIsNegativeError(CustomError): """Uppstår när användaren anger ett negativt värde""" pass
Låt oss testa detta
försök: value = int(input()) if value <0: raise InputIsNegativeError # Upprätta undantag om värdet är negativt utom InputIsNegativeError: # fånga upp och hantera undantaget print("Ingångsvärdet bör inte vara negativt") Ovanstående kod begär användarinmatning och kontrollerar om den är negativ. Om den är sann, uppstår vårt anpassade undantag InputIsNegativeError som senare fångas upp i except-satsen.
Nedan följer den fullständiga koden:
class CustomError(Exception): "Basklassundantag för alla undantag i den här modulen" pass class InputIsNegativeError(CustomError): """Uppstår när användaren anger ett negativt värde""" pass if __name__ == '__main__': try: value = int(input("Ange ett tal: ")) if value <0: raise InputIsNegativeError # Uppstår undantag om värdet är negativt except InputIsNegativeError: # catch and handle exceptionprint("Ingångsvärdet får inte vara negativt") Om ingångsvärdet är ett negativt tal, t.ex. -1, får vi utgången:
Läs Python-dokumentationen för mer information om Pythons egna undantag.
Ofta ställda frågor
F #1) Hur hanterar Python ett undantag?
Svar: Python hanterar undantag med hjälp av försök-except uttalande Den kod som kan ge upphov till ett undantag placeras och utförs i Försök blockera medan den utom block innehåller koden som hanterar eventuella undantag.
F #2) Vad är att ta upp ett undantag i Python?
Svar: När Python-tolken stöter på en ogiltig kod, så uppstår ett undantag, vilket är Pythons eget sätt att tala om för oss att något oväntat har hänt. Vi kan också avsiktligt skapa undantag med hjälp av höjning av deklarationen .
F #3) Hur hanterar Python flera undantag?
Svar: Python hanterar flera undantag med hjälp av antingen ett enda except-block eller flera except-block.
För ett enskilt block skickas undantagen som en tupel: utom (Exception1, Exception2,...,ExceptionN) och Python kontrollerar om det finns en matchning från höger till vänster. I detta fall vidtas samma åtgärd för varje undantag.
Ett annat sätt att fånga upp alla undantag är att utelämna namnet på undantaget efter nyckelordet except.
except: # hanterar alla undantag här
Det andra sättet är att använda ett except-block för varje undantag:
except Exception1: # kod för att hantera Exception1 går här except Exception2: # kod för att hantera Exception2 går här except ExceptionN: # kod för att hantera ExceptionN går här
På så sätt kan du vidta separata åtgärder för varje undantag.
Q #4) Varför är undantagshantering viktigt i Python?
Svar: Fördelen med att hantera undantag i Python är att vi kan skapa robusta, rena och felfria program. Vi vill inte att vår produktionskod ska krascha på grund av några fel, så vi hanterar felen och håller programmet igång.
F #5) Hur ignorerar man ett undantag i Python?
Svar: Om du vill ignorera ett undantag i Python använder du passera i except-blocket. Låt oss säga att vi vill ignorera undantaget ValueError. Vi gör det på följande sätt:
except ValueError: pass
Om du inte vet vad du gör är det dåligt att ignorera undantag. Informera åtminstone användaren om alla potentiella fel.
Slutsats
I den här handledningen har vi behandlat: Python Exceptions, Traceback; hur man hanterar undantag med Prova / Utom / Annat / Äntligen block, hur man Upphöj Undantag och slutligen hur vi skapar våra egna anpassade undantag.
Tack för att du läste!