Ga naar hoofdinhoud

Exceptions & foutafhandeling in Python

Fouten en exceptions kunnen leiden tot programmacrashes of onverwacht gedrag, en Python heeft een robuuste set tools om de stabiliteit van je code te verbeteren.
· 11 min lezen

Verken met AI

Fouten en exceptions kunnen leiden tot onverwacht gedrag of zelfs het stoppen van een programma. Python biedt diverse functies en mechanismen om deze problemen af te handelen en de robuustheid van je code te verbeteren. In deze tutorial leren we over verschillende fouttypen en ingebouwde functies met voorbeelden. 

  • Een fout is een kritiek probleem in code waarvan je tijdens runtime meestal niet kunt herstellen, zoals onjuiste syntax of verkeerde inspringing.
  • Een exception is een runtime-gebeurtenis die de normale programmastroom verstoort maar kan worden opgevangen en afgehandeld, zodat het programma kan doorgaan.

Hoewel exceptions tijdens runtime optreden, worden sommige fouten zoals SyntaxError en IndentationError al door de parser opgevangen voordat het programma überhaupt draait.

Simpel gezegd: een fout is een kritisch probleem dat een normale applicatie niet zou moeten opvangen, terwijl een exception een conditie is die een programma wél zou moeten opvangen. 

try except else finally-proces in Python

Laten we meer leren over fouten en exceptions aan de hand van verschillende voorbeelden. Om ze makkelijk te draaien, kun je gratis een DataLab-werkboek aanmaken met Python vooraf geïnstalleerd en alle codevoorbeelden erbij.

Fouten in Python

Hier is een voorbeeld van een syntaxfout waarbij een return buiten de functie niets betekent. We zouden fouten niet in een programma moeten afhandelen. In plaats daarvan moeten we een functie maken die de string retourneert. 

return "DataCamp"
Input In [1]
    return "DataCamp"
    ^
SyntaxError: 'return' outside function

We hebben de functie gemaakt, maar met de verkeerde inspringing. We zouden inspringfouten niet tijdens runtime moeten afhandelen. Dit lossen we handmatig op of met codeformatteertools.

def fun():
return "DataCamp"    
Input In [2]
    return "DataCamp"
    ^
IndentationError: expected an indented block

Exceptions in Python

We kregen een ZeroDivisionError (Exception). We kunnen die tijdens runtime afhandelen met try- en except-blokken.

test = 1/0
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Input In [4], in <cell line: 1>()
----> 1 test = 1/0

ZeroDivisionError: division by zero

NameError-exceptions komen vaak voor wanneer een variabele niet wordt gevonden. We kunnen de exception ook afhandelen door de variabele te vervangen of een waarschuwing te printen. 

y = test
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [5], in <cell line: 1>()
----> 1 y = test

NameError

Ingebouwde Python-exceptions

Hier is de lijst met standaard Python-exceptions met beschrijvingen:

  1. AssertionError: wordt opgegooid wanneer de assert-instructie faalt.

  2. EOFError: wordt opgegooid wanneer de input()-functie het einde-van-bestand bereikt.

  3. AttributeError: wordt opgegooid wanneer het toewijzen of refereren van een attribuut faalt.

  4. TabError: wordt opgegooid wanneer inspringing uit inconsistente tabs of spaties bestaat. 

  5. ImportError: wordt opgegooid wanneer het importeren van een module faalt. 

  6. IndexError: treedt op wanneer de index van een sequentie buiten bereik is

  7. KeyboardInterrupt: wordt opgegooid wanneer de gebruiker interrupt-toetsen invoert (Ctrl + C of Delete).

  8. RuntimeError: treedt op wanneer een fout in geen enkele andere categorie valt. 

  9. NameError: wordt opgegooid wanneer een variabele niet in de lokale of globale scope wordt gevonden. 

  10. MemoryError: wordt opgegooid wanneer programma's te weinig geheugen hebben. 

  11. ValueError: treedt op wanneer een bewerking of functie een argument met het juiste type maar de verkeerde waarde krijgt. 

  12. ZeroDivisionError: wordt opgegooid wanneer je een waarde of variabele door nul deelt. 

  13. SyntaxError: wordt door de parser opgegooid wanneer de Python-syntax onjuist is. 

  14. IndentationError: treedt op bij onjuiste inspringing.

  15. SystemError: wordt opgegooid wanneer de interpreter een interne fout detecteert.

Je vindt een volledige lijst met fouten en exceptions in Python in de documentatie. 

Leer over Python-exceptions in onze cursus Object-Oriented Programming in Python. Je leert hoe je classes maakt en gebruikmaakt van overerving en polymorfisme om code te hergebruiken en te optimaliseren.

Exception handling met try, except, else en finally

Nu we over fouten en exceptions hebben geleerd, gaan we ze afhandelen met try-, except-, else- en finally-blokken. 

Wat bedoelen we met afhandelen? Normaal gesproken stoppen deze fouten de code-executie en tonen ze het foutbericht. Om stabiele systemen te bouwen, moeten we deze fouten voorzien en met alternatieve oplossingen of waarschuwingen komen. 

In deze sectie leren we wat elk blok doet en hoe we ze kunnen gebruiken om robuuste code te schrijven. 

De try- en except-instructie 

De eenvoudigste manier om exceptions in Python af te handelen is met het try- en except-blok.  

  1. Voer de code uit onder de try-instructie.

  2. Wanneer er een exception wordt opgegooid, voer de code uit onder de except-instructie. 

In plaats van te stoppen bij een fout of exception, gaat onze code door met alternatieve oplossingen. 

try except-instructie in Python

Eenvoudig voorbeeld

In het eerste voorbeeld proberen we de ongedefinieerde variabele x te printen. Normaal zou dat een fout opleveren en de uitvoering stoppen, maar met het try- en except-blok kunnen we de stroom veranderen. 

  • Het programma voert de code onder de try-instructie uit. 
  • Omdat we weten dat x niet is gedefinieerd, wordt de except-instructie uitgevoerd en de waarschuwing geprint.
try:
   print(x)
except:
   print("An exception has occurred!")
An exception has occurred!

Voorbeeld met meerdere except-instructies

In het tweede voorbeeld gebruiken we meerdere except-instructies om meerdere typen exceptions af te handelen.

  •  Als een ZeroDivisionError-exception wordt opgegooid, print het programma "You cannot divide a value with zero."
  • De rest van de exceptions printen “Something else went wrong.”

Dit stelt ons in staat flexibele code te schrijven die meerdere exceptions tegelijk aankan zonder te crashen. 

Let op: Vermijd een kale except:-clausule zonder specifiek exceptietype — die vangt alles, inclusief KeyboardInterrupt en SystemExit, wat je programma onmogelijk kan maken om af te sluiten en niet-gerelateerde bugs kan verbergen. Vang altijd de specifieke exception die je verwacht, zoals except ZeroDivisionError:.

try:
   print(1/0)
        except ZeroDivisionError:
   print("You cannot divide a value with zero")
except:
   print("Something else went wrong")
You cannot divide a value with zero

Bestand laden-voorbeeld

Kijk nu naar een praktischer voorbeeld. 

In de code hieronder lezen we het CSV-bestand, en wanneer FileNotFoundError wordt opgegooid, print de code de fout en een extra bericht over het data.csv-bestand. 

Ja, we kunnen standaardfoutmeldingen printen zonder de uitvoering te onderbreken. 

try:
   with open('data.csv') as file:
       read_data = file.read()
except FileNotFoundError as fnf_error:
   print(fnf_error)
   print("Explanation: We cannot load the 'data.csv' file")

[Errno 2] No such file or directory: 'data.csv'
Explanation: We cannot load the 'data.csv' file

try met else-clausule

We hebben try en except behandeld, en nu leren we over de else-instructie.

Wanneer de try-instructie geen exception oplevert, gaat de code het else-blok in. Het is het middel of de fallback wanneer je verwacht dat een deel van je script een exception kan geven. Het wordt meestal gebruikt in een korte setup- of verificatiesectie waar je bepaalde fouten niet verborgen wilt laten raken. 

Let op: In het try-except-blok gebruik je else na alle except-instructies. 

try met else-clausule in Python

Eenvoudig voorbeeld

We voegen de else-instructie toe aan het ZeroDivisionError-voorbeeld. Zoals je ziet wordt, wanneer er geen exceptions zijn, de print-functie onder de else-instructie uitgevoerd en het resultaat getoond. 

try:
   result = 1/3
except ZeroDivisionError as err:
   print(err)
else:
   print(f"Your answer is {result}")
Your answer is 0.3333333333333333

IndexError met else-voorbeeld

Laten we verder leren door een eenvoudige functie te maken en die in verschillende scenario's te testen. 

De functie find_nth_value() heeft x (lijst) en n (indexnummer) als argumenten. We hebben een try-, except- en else-blok gemaakt om de IndexError-exception af te handelen. 

x = [5,8,9,13]

def find_nth_value(x,n):
    try:
        result = x[n]
    except IndexError as err:
        print(err)
    else:
        print("Your answer is ", result)

De lijst x heeft vier waarden, en we testen de 6e en 2e index. 

# Testing
find_nth_value(x,6)
find_nth_value(x,2)
  • Bij n=6 werd de IndexError-exception opgegooid en kregen we de standaardmelding “list index out of range”. 
  • Bij n=2 werd geen exception opgegooid en printte de functie het resultaat onder de else-instructie. 
list index out of range
Your answer is  9

Het keyword finally in Python

Het keyword finally in het try-except-blok wordt altijd uitgevoerd, ongeacht of er wel of geen exception is. Het finally-blok voert altijd uit na try, except en else, ongeacht of een exception is opgegooid of opgevangen. Het is erg handig voor het opruimen van resources en het sluiten van objecten, vooral bestanden sluiten.

finally-keyword in Python

De functie divide is gemaakt om ZeroDivisionError-exceptions af te handelen en het resultaat te tonen wanneer er geen exceptions zijn. Wat de uitkomst ook is, finally draait altijd om “Code by DataCamp” in groene kleur te printen.

def divide(x,y):
    try:
        result = x/y
    except ZeroDivisionError:
        print("Please change 'y' argument to non-zero value")
    except:
        print("Something went wrong")
    else:
        print(f"Your answer is {result}")
    finally:
        print("\033[92m Code by DataCamp\033[00m")

In de eerste test delen we 1 door 0, wat de ZeroDivisionError-exception zou moeten opleveren en het bericht printen. Zoals je ziet, staat er een extra regel na het foutbericht. 

divide(1,0)
Please change 'y' argument to non-zero value
 Code by DataCamp

Als we geldige input toevoegen, wordt het resultaat getoond door uitvoering van de else- en finally-blokken.

divide(3,4)
Your answer is 0.75
 Code by DataCamp

In plaats van een integer hebben we een string als tweede argument toegevoegd, wat een andere exception dan ZeroDivisionError opleverde met een ander bericht. 

divide(1,'g')
Something went wrong
 Code by DataCamp

In alle drie scenario’s is er één overeenkomst: de code draait altijd de printfunctie onder de finally-instructie.

Ben je nieuw in Python en wil je coderen als een echte programmeur? Probeer dan ons Python Programming skill track. Je leert efficiënte code schrijven, Python-functies, software engineering, unit testing en objectgeoriënteerd programmeren. 

Geneste exception handling in Python

We hebben geneste exception handling nodig wanneer we het programma voorbereiden om meerdere exceptions na elkaar af te handelen. We kunnen bijvoorbeeld een extra try-except-blok toevoegen onder de else-instructie. Dus als de eerste instructie geen exception oplevert, controleer dan de tweede instructie met de rest van de code. 

De divide-functie aanpassen

We hebben de divide-functie uit het vorige voorbeeld aangepast en een genest try-except-blok toegevoegd onder de else-instructie. Als er dus geen AttributeError is, draait else en controleert de nieuwe code op de ZeroDivisionError-exception.

def divide(x,y):
    
    try:
        value = 50
        x.append(value)
    
    except AttributeError as atr_err:
        print(atr_err)
        
    else:
        try:
            result = [i / y for i in x]
            print( result )
 except ZeroDivisionError:
            print("Please change 'y' argument to non-zero value")

    finally:
        print("\033[92m Code by DataCamp\033[00m")

In het eerste scenario geven we de lijst met vier waarden x en noemer 3. Het script voegt 50 toe aan de lijst, deelt elke waarde in de lijst door 3 en toont het resultaat. 

x = [40,65,70,87]
divide(x,3)

De functie werd succesvol uitgevoerd zonder exceptions op te gooien.

[13.333333333333334, 21.666666666666668, 23.333333333333332, 29.0, 16.666666666666668]
 Code by DataCamp

In plaats van een lijst hebben we een integer aan het eerste argument gegeven, wat AttributeError opleverde.

divide(4,3)
'int' object has no attribute 'append'
 Code by DataCamp

In het laatste scenario hebben we de lijst opgegeven, maar is 0 het tweede argument, wat de ZeroDivisionError-exception onder de else-instructie heeft opgeworpen. 

divide(x,0)
Please change 'y' argument to non-zero value
 Code by DataCamp

Voorbeeld bestand bewerken

Bekijk meer praktische voorbeelden van een bestand laden, tekst schrijven en het bestand sluiten. 

De functie file_editor() zal:

  • De FileNotFoundError-exception controleren voor de open()-functie.
  • Als de buitenste exception niet wordt opgegooid, controleren op de exception van de write()-functie.
  • Hoe dan ook, na het openen van het bestand, het bestand sluiten via de finally-instructie. 
  • Als de buitenste try-instructie de exception opwerpt, de foutmelding met een ongeldig bestandspad retourneren. 
def file_editor(path,text):
    try:
      data = open(path)

      try:
        data.write(text)

      except:
        print("Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.")

      finally:
        data.close()

    except:
      print(f"{path} file is not found!!")

In het eerste scenario geven we het bestandspad en de tekst op.

path = "data.txt"
text = "DataLab: Share your data analysis in a cloud-based environment--no installation required."

file_editor(path,text)

De buitenste exception wordt opgegooid. 

data.txt file is not found!!

Om de file not found-exception op te lossen, moeten we een bestand data.txt aanmaken met het Linux-commando echo. 

!echo "File by DataCamp" > "data.txt"

bestand bewerken in Workspace

Daarna roepen we de functie file_editor() opnieuw aan.

file_editor(path,text)

De binnenste exception wordt opgegooid, omdat de write()-functie de tekst niet kan toevoegen.

Unable to write the data. Please add an append: 'a' or write: 'w' parameter to the open() function.

Om dit op te lossen, moeten we de derde regel wijzigen van data = open(path) naar data = open(path, 'a'). Hiermee kunnen we de nieuwe tekst aan het bestand toevoegen. 

Na het opnieuw uitvoeren van de functie hebben we de tekst succesvol aan het bestand toegevoegd. 

file_editor(path,text)

screenshot bestand bewerken in Workspace

Geneste exception handling wordt niet aanbevolen omdat het de afhandeling complexer maakt; ontwikkelaars gebruiken meerdere try-except-blokken om eenvoudige sequentiële exception handling te maken. 

Let op: je kunt ook een genest try-except-blok onder de try- of except-instructie toevoegen. Het hangt gewoon af van je vereisten. 

Exceptions opwerpen (raise) in Python

Naast het opvangen van exceptions kun je ze bewust opwerpen met het keyword raise. Dit is nuttig om bedrijfsregels af te dwingen of invoer te valideren. Het geeft een signaal dat er iets mis is voordat het verderop voor een lastigere fout zorgt.

Om een exception op te werpen, gebruiken we het keyword raise gevolgd door een exceptionnaam. 

Voorbeeld ValueError opwerpen

We kunnen eenvoudig exceptions opwerpen door een raise-keyword toe te voegen in de if/else-instructie. 

In het voorbeeld werpen we ValueError op als de waarde groter is dan 1.000. We hebben de waarde naar 2.000 gezet, waardoor de if-instructie TRUE werd en ValueError met het aangepaste bericht werd opgegooid. Het aangepaste foutbericht helpt je het probleem snel te vinden. 

value = 2_000
if value > 1_000:   
    # raise the ValueError
    raise ValueError("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)

----> 4     raise ValueError("Please add a value lower than 1,000")
      5 else:
      6     print("Congratulations! You are the winner!!")

ValueError: Please add a value lower than 1,000

Voorbeeld exception opwerpen

We kunnen ook een willekeurige ingebouwde Python-exception opwerpen als aan de conditie is voldaan. In ons geval hebben we een generieke Exception met het foutbericht opgegooid.

if value > 1_000:   
    # raise the Exception
    raise Exception("Please add a value lower than 1,000")
else:
    print("Congratulations! You are the winner!!")
---------------------------------------------------------------------------
Exception                                 Traceback (most recent call last)
----> 3     raise Exception("Please add a value lower than 1,000")
      4 else:
      5     print("Congratulations! You are the winner!!")

Exception: Please add a value lower than 1,000

Voorbeeld opgegooide exception afhandelen

We kunnen ook een eigen exception maken en die afhandelen met het try-except-blok. 

In het voorbeeld hebben we een value error-voorbeeld onder de try-instructie toegevoegd.  

Hoe werkt dit? In plaats van de exception te gooien en het programma te beëindigen, toont het het door ons opgegeven foutbericht.

value = 2_000
try:
    if value > 1_000:
          
        # raise the ValueError
        raise ValueError("Please add a value lower than 1,000")
    else:
        print("Congratulations! You are the winner!!")
              
# if false then raise the value error
except ValueError as e:
        print(e)

Dit type exception handling helpt ons ons voor te bereiden op fouten die niet door Python worden gedekt en specifiek zijn voor jouw applicatievereisten. 

Please add a value lower than 1,000

Exception chaining met raise ... from

Naast losse exceptions opwerpen kun je exceptions ketenen met raise ... from. Dit bewaart de oorspronkelijke exception als context, waardoor tracebacks veel duidelijker worden wanneer de ene fout door een andere wordt veroorzaakt.

try:
    open("config.json")
except FileNotFoundError as e:
    raise RuntimeError("App failed to start: config file missing") from e
FileNotFoundError: [Errno 2] No such file or directory: 'config.json'

The above exception was the direct cause of the following exception:

RuntimeError: App failed to start: config file missing

Het deel from e zet het attribuut __cause__ op de nieuwe exception, zodat iedereen die de traceback leest precies kan zien wat deze triggerde. Dit is vooral nuttig in grotere applicaties waar exceptions door meerdere lagen code gaan.

Wat is er nieuw in Python 3.10 - 3.13 voor exception handling?

Sinds dit blogbericht oorspronkelijk is geschreven, zijn er in nieuwere Python-versies zoals 3.10 en 3.11 belangrijke ontwikkelingen bijgekomen:

1. Structurele pattern matching in Python 3.10

Python 3.10 introduceerde structurele pattern matching, dat kan worden gebruikt om exceptions eleganter af te handelen door fouttypen in een match-instructie te matchen. Dit is vooral handig bij het afhandelen van meerdere exceptietypen op een beter leesbare manier. Voorbeeld:

try:
    result = 1 / 0
except Exception as e:
    match e:
        case ZeroDivisionError():
            print("You cannot divide by zero.")
        case NameError():
            print("Variable not defined.")
        case _:
            print("An unexpected error occurred.")

2. Fijnmazige foutlocaties in tracebacks (Python 3.11)

Tracebacks in Python 3.11 tonen nu precieze foutlocaties, waardoor exceptions makkelijker te debuggen zijn.

Voor Python 3.11:

value = (1 + 2) * (3 / 0)
ZeroDivisionError: division by zero

Met Python 3.11 wijzen tracebacks exact de subexpressie aan die de exception veroorzaakt:

ZeroDivisionError: division by zero
       (1 + 2) * (3 / 0)
                      ^

3. Exceptiongroepen en except* (Python 3.11)

Python 3.11 introduceerde exceptiongroepen om meerdere exceptions in één blok af te handelen met except*. Dit is nuttig voor het beheren van asynchrone code of scenario's waarin meerdere exceptions kunnen worden opgegooid. Voorbeeld:

try:
    raise ExceptionGroup("Multiple errors", [ValueError("Bad value"), TypeError("Bad type")])
except* ValueError as ve:
    print(f"Handling ValueError: {ve}")
except* TypeError as te:
    print(f"Handling TypeError: {te}")

4. add_note-methode voor exceptions (Python 3.11)

Exceptions hebben nu een add_note()-methode, waarmee ontwikkelaars aangepaste notities aan exceptions kunnen toevoegen voor betere debugging. Voorbeeld:

try:
    raise ValueError("Invalid input")
except ValueError as e:
    e.add_note("This happened while processing user input.")
    e.add_note("Consider validating input before processing.")
    raise
ValueError: Invalid input
Notes:
- This happened while processing user input.
- Consider validating input before processing.

5. PEP 654: Betere afhandeling van geneste exceptions 

Met exceptiongroepen zijn geneste exceptions nu makkelijker te debuggen en af te handelen, vooral in complexe workflows zoals multiprocessing of asynchrone taken.

6. Verbeterde foutmeldingen (Python 3.12)

Python 3.12 zette een langlopende inspanning voort om foutmeldingen specifieker en bruikbaarder te maken. Zo suggereren NameError-meldingen nu gelijkende variabelen die in scope zijn, en geven attribute errors op veelvoorkomende types gerichtere hints:

# Python 3.12+
my_list = [1, 2, 3]
my_list.appendd(4)
AttributeError: 'list' object has no attribute 'appendd'. Did you mean: 'append'?

7. Gekleurde tracebacks (Python 3.13)

Python 3.13 introduceerde standaard gekleurde tracebacks in de interactieve interpreter. Fouttypen, regelnummers en berichten worden nu in verschillende kleuren gemarkeerd, waardoor je veel sneller kunt scannen en begrijpen wat er misging — vooral in lange tracebacks met meerdere gekoppelde exceptions.

Conclusie

Zowel unit testing als exception handling zijn kerndelen van Python-programmeren die je code productieklaar en foutbestendig maken. In deze tutorial hebben we geleerd over exceptions en fouten in Python en hoe je ze afhandelt. Verder hebben we complexe geneste try-except-blokken behandeld en aangepaste exceptionblokken gemaakt op basis van vereisten.  

Deze tools en mechanismen zijn essentieel, maar het meeste werk wordt gedaan met eenvoudige try- en except-blokken. Waar try zoekt naar exceptions die door de code worden opgegooid en except die exceptions afhandelt. 

Vind je dit verwarrend en weet je niet waar je moet beginnen? Volg dan onze cursus Introduction to Functions in Python om scoping, lambda-functies en foutafhandeling te begrijpen. Je kunt je ook inschrijven voor de Python Programmer career track om carrièrebepalende skills op te doen en een professionele Python-ontwikkelaar te worden. 

Abid Ali Awan

Auteur

Abid Ali Awan

LinkedInTwitter

Als gecertificeerd data scientist haal ik met passie het maximale uit de nieuwste technologie om innovatieve machinelearning-toepassingen te bouwen. Met een sterke achtergrond in spraakherkenning, data-analyse en -rapportage, MLOps, conversationele AI en NLP heb ik mijn vaardigheden aangescherpt in het ontwikkelen van intelligente systemen die echt impact maken. Naast mijn technische expertise ben ik ook een sterke communicator met een talent om complexe concepten terug te brengen tot heldere, beknopte taal. Daardoor ben ik uitgegroeid tot een veelgelezen blogger over data science, waar ik mijn inzichten en ervaringen deel met een groeiende community van data-professionals. Op dit moment richt ik me op contentcreatie en redactie, waarbij ik met large language models werk aan krachtige en aansprekende content die zowel bedrijven als individuen helpt het beste uit hun data te halen.

FAQs

Wat is het verschil tussen een fout en een exception in Python?

Een fout in Python is doorgaans een ernstiger probleem dat voorkomt dat het programma doorgaat, zoals een syntaxfout, wat aangeeft dat de codestructuur onjuist is. Een exception daarentegen is een conditie die de normale programmastroom onderbreekt maar binnen het programma kan worden afgehandeld met try-except-blokken, zodat het programma kan blijven draaien.

Kun je meerdere exceptions in één try-except-blok opvangen?

Ja, in Python kun je meerdere exceptions in één try-except-blok opvangen door een tuple met exceptietypen te gebruiken. Bijvoorbeeld: except (TypeError, ValueError):. Dit handelt zowel een TypeError als een ValueError in hetzelfde blok af.

Hoe maak je een custom exception in Python?

Je kunt een custom exception maken door een nieuwe class te definiëren die erft van de ingebouwde Exception-class. Bijvoorbeeld:

class MyCustomError(Exception):
    pass
Wat is het doel van het else-blok in een try-except-structuur?

Het else-blok wordt uitgevoerd als het try-blok geen exception opwerpt. Het is handig voor code die alleen moet draaien als het try-blok slaagt, zodat de code schoon blijft en foutafhandeling gescheiden is van het normale pad.

Waarom is het finally-blok belangrijk bij exception handling?

Het finally-blok wordt altijd uitgevoerd, ongeacht of er een exception wordt opgegooid. Het wordt meestal gebruikt voor opruimacties, zoals bestanden sluiten of resources vrijgeven, om te garanderen dat deze acties altijd plaatsvinden.

Hoe kun je exceptions onderdrukken in Python?

Je kunt exceptions onderdrukken met de contextlib.suppress-contextmanager. Daarmee kun je exceptietypen opgeven die genegeerd moeten worden. Bijvoorbeeld:

from contextlib import suppress
with suppress(FileNotFoundError):
    open('non_existent_file.txt')
Wat gebeurt er als een exception niet wordt opgevangen in een Python-programma?

Als een exception niet wordt opgevangen, propageren ze omhoog in de call stack, en als ze onafgehandeld blijven, beëindigen ze het programma. Er wordt dan een traceback naar de console geprint die laat zien waar de exception optrad.

Kun je een exception opnieuw opwerpen nadat je die hebt opgevangen?

Ja, je kunt een exception opnieuw opwerpen met de raise-instructie zonder argumenten in een except-blok. Dit is handig wanneer je een fout wilt loggen of iets anders wilt doen voordat je de exception verder laat propagëren.

Is er een manier om alle exceptions in Python af te handelen?

Hoewel je alle exceptions kunt opvangen met een kale except:-clausule, is dat doorgaans niet aan te raden omdat je onverwachte exceptions kunt opvangen en debuggen moeilijker wordt. Vang liever specifieke exceptions of gebruik except Exception: om te voorkomen dat systeembeëindigende exceptions zoals SystemExit en KeyboardInterrupt.

Hoe onderscheid je een syntaxfout en runtime-exceptions qua moment van optreden?

Syntaxfouten worden gedetecteerd tijdens het compileren: de Python-interpreter vangt deze fouten voordat het programma wordt uitgevoerd. Runtime-exceptions treden op tijdens de uitvoering wanneer de interpreter een bewerking tegenkomt die hij niet kan uitvoeren, zoals delen door nul of een niet-bestaande variabele benaderen.

Onderwerpen

Python

Gerelateerd

Meer bekijken →