Python Try Except: Förklarat med exempel

Python Try Except är en konstruktion som används i Python för att hantera undantag graciöst utan att krascha.

Undantagshantering gör din programkod mer tillförlitlig och mindre sannolikt att misslyckas. Den här artikeln vägleder hantering av undantag och vanliga scenarier där undantagshantering är idealisk. Som en bonus kommer vi också att ta upp hur man höjer undantag.

Vad är undantagshantering?

Undantag är kritiska anomalier och fel som uppstår under ett programs körning. Om de inte hanteras kommer undantag att krascha programmet. Därför är undantagshantering ett sätt att hantera undantag för att säkerställa att de inte kraschar programmet.

Här är ett exempel för att illustrera vad ett undantag är.

user_input = input("Enter a number: ")
num = int(user_input)
print("Your number doubled is:", num * 2)

Vid första anblicken verkar det inte vara något fel med ovanstående program. Den tar emot input från användaren och konverterar den till ett heltal. Därefter visar det heltal som tillhandahålls av användaren fördubblat.

Programmet går bra om du kör det med ett ingångsvärde på 5. Se nedan.

Men anta att du körde samma program igen. Bara den här gången, istället för att använda 5 som din inmatning, anger du strängen ”hej”. Programmet kommer att krascha. Strängen ”hej” kan inte konverteras till ett heltal, så ett undantag höjs och programmet kraschar.

Varför tas undantag upp och varför ska du hantera dem?

Undantag tas upp eftersom vi ofta delar upp program till funktioner när vi kodar dem. Dessa funktioner anropas sedan för att utföra olika uppgifter.

I exemplet ovan kallade vi ingångsfunktionen för att ta emot användarens indata, sedan anropade vi int-funktionen för att konvertera stränginmatningen till ett heltal, och slutligen anropade vi utskriftsfunktionen för att visa viss utdata.

Men när funktioner utför sina handlingar kan de stöta på fel som de inte vet hur de ska hantera. I detta fall måste nämnda funktioner sluta köra och kommunicera att ett fel har påträffats. För att kommunicera kommer de att ta upp undantag.

Koden som kallas funktionen är ansvarig för att lyssna på dessa undantag och reagera på rätt sätt. Om detta inte görs kommer programmet att krascha efter att ha stött på fel, som vi såg i det tidigare exemplet.

Därför är undantag i huvudsak en kommunikationsmekanism som gör det möjligt för en funktion som har anropats att skicka en nödsignal till koden som anropade den. Och den reaktion som på lämpligt sätt antytts tidigare är kärnan i undantagshantering.

Olika typer av undantag

Det är viktigt att veta att inte alla undantag är desamma. Det finns olika typer av undantag för olika fel som uppstått. Till exempel, om du försöker dividera ett tal med noll, uppstår ett ZeroDivisionError. Och ett TypeError uppstår när du försöker en operation med en ogiltig datatyp. Här är en komplett lista över typer av undantag.

Hur man hanterar undantag

Som förklarats tidigare är undantag nödsignaler gjorda av funktioner vi anropar. Vår kod bör därför lyssna på dessa nödsignaler och reagera på lämpligt sätt när de ljuder. För att hantera undantag på rätt sätt använder vi Python Try Except-konstruktioner. Den grundläggande strukturen för konstruktionen är som följer:

try:
    # Code to try and run
except:
    # Code to run if an exception is raised
finally:
    # Code to run in the end, whether or not an exception is raised

Som du kan se består konstruktionen av tre nyckelord som förklaras nedan:

Prova

Nyckelordet try markerar början på en Python Try Except-konstruktion. Dessutom markerar det ett kodblock som potentiellt kan skapa ett undantag. Det är en instruktion till Python-tolken att försöka köra kod i blocket. Om ett undantag görs, stannar programmet omedelbart och hoppar för att exekvera koden som skrivits inuti undantagsblocket.

bortsett från

Nyckelordet except markerar kodblocket som kommer att exekveras om ett undantag görs när försöksblocket körs. Du kan definiera flera utom block för olika typer av undantag som kan höjas. Detta kommer att illustreras senare.

till sist

Nyckelordet final är det tredje och sista nyckelordet som används i Python Try Except. Det markerar ett kodblock som kommer att exekveras oavsett om ett undantag görs eller inte.

Ett exempel

Här är ett exempel på hur sökorden ovan kan hantera ett undantag. Vi kommer att modifiera det tidigare exemplet till detta.

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except:
    print("Something went wrong")
finally:
    print("This code will be executed no matter what")

Om du kör ovanstående kod med 5, en giltig ingång, som din inmatning, får du följande:

Och om du kör det med ”hej” som indata får du följande:

Så när inget undantag togs upp när koden kördes i försöksblocket, gick datorn vidare till det slutliga blocket. Men när ett undantag gjordes under exekvering av kod i försöksblocket, flyttade datorn till undantagsblocket och sedan till slutblocket.

Du kan också hantera undantag för specifika typer av fel. Till exempel, om du vill hantera ValueError och KeyboardInterrupt-undantag på ett specifikt sätt, kan du ändra ovanstående kod så här:

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except ValueError:
    print("Value can't be converted to int")
except KeyboardInterrupt:
    print("Received a keyboard interrupt")
except:
    print("Catch-all exception block")
finally:
    print("This code will be executed no matter what")

I koden ovan har vi 3 utom block. Det första utom blocket fångar endast ValueError-undantag, medan det andra bara fångar KeyboardInterrupt-undantag. Det sista undantagsblocket har ingen associerad undantagstyp att lyssna efter. Som ett resultat fångar den upp resten av undantag som inte fångas upp av de två första blocken.

När du kör koden ovan bör du få en utdata som liknar denna:

När ett undantag tas upp kan du få mer information om undantaget i undantagsobjektet. För att få tillgång till undantagsobjektet använder du nyckelordet som. Den används enligt följande:

try:
    user_input = input("Enter a number: ")
    num = int(user_input)
    print("Your number doubled is:", num * 2)
except ValueError as e:
    print("Value Error:", e)
except KeyboardInterrupt as e:
    print("Keyboard Interrupt:", e)
except Exception as e:
    print("Some other exception", e)

Hur man tar upp undantag

Hittills har vi haft att göra med undantag som tagits upp av andra funktioner. Det är dock också möjligt för dig att ta upp undantag i din kod. För att skapa ett undantag använder vi nyckelordet höja. Vi anger också en klass som representerar vilken typ av undantag vi vill ta fram och det mänskliga läsbara meddelandet som är kopplat till undantaget.

Vi använder klassen Exception i följande exempel för att skapa ett generiskt undantag. Därefter skickar vi meddelandet till klassens konstruktör.

raise Exception('Something went wrong')

Om du kör kodavsnittet ovan som ett program får du utdata som liknar detta:

Du kan också ange olika typer av undantag. Du kan till exempel skapa ett TypeError-undantag när ett värde har fel datatyp:

def double(x):
    if isinstance(x, int):
        return x * 2
    else
        raise TypeError('x should be an int')

Eller om det angivna värdet ligger utanför de acceptabla gränserna kan du skapa ett ValueError:

def say_hello(name):
    if name == '':
        raise ValueError('Value outside bounds')
    else:
        print('Hello', name)

Du kan också skapa dina undantagstyper genom att underklassa klassen Exception. Här är ett exempel:

class InvalidHTTPMethod(Exception):
    pass

I exemplet ovan skapade vi en klass InvalidHTTPMethod, som ärver från klassen Exception. Vi kan använda det på samma sätt som tidigare för att ta upp undantag:

raise InvalidHTTPMethod('Must be GET or POST')

Vanliga användningsfall för undantagshantering

Undantagshantering används i många scenarier. Det föregående exemplet visade hur den kan hantera undantag på grund av användarinmatning. Det här avsnittet kommer att täcka ytterligare två situationer där undantagshantering är användbar. Dessa hanterar undantag som ett resultat av misslyckade nätverksbegäranden och hanterar undantag när filer läses.

Göra nätverksförfrågningar

I exemplet nedan gör vi en begäran till Google. Vi lyssnar efter undantag för att hantera dem. Dessa undantag definieras i objektet requests.exceptions.

import requests

try:
    response = requests.get("https://google.com")

    # Check if the response status code is in the 200-299 range (successful response)
    if 200 <= response.status_code < 300:
        print("Request was successful!")
    else:
        print(f"Request failed with status code: {response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"RequestException occurred: {e}")
except requests.exceptions.ConnectionError as e:
    print(f"ConnectionError occurred: {e}")
except requests.exceptions.Timeout as e:
    print(f"Timeout occurred: {e}")
except requests.exceptions.TooManyRedirects as e:
    print(f"TooManyRedirects occurred: {e}")
except requests.exceptions.HTTPError as e:
    print(f"HTTPError occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Läsa data från en fil

I det här sista exemplet läser vi data från hello.txt-filen. Vi hanterar också vanliga undantag som kan uppstå, såsom FileNotFound-felet och IOError.

try:
    with open(file_path, 'r') as file:
        data = file.read()
        print("File contents:")
        print(data)
except FileNotFoundError as e:
    print(f"FileNotFoundError occurred: {e}")
except IOError as e:
    print(f"IOError occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Slutsats

Den här artikeln undersökte vilka undantag som var och varför de togs upp. Vi har också fastställt att vi hanterar dem för att göra koden mer tillförlitlig och förhindra kraschar. Till sist tog vi upp hur man hanterar undantag samt hur man tar upp några undantag.

Kolla sedan in vanliga Python-feltyper och hur du löser dem.