Bestanden en excepties in Python

Een tekstbestand bewaart informatie nadat een programma stopt. Python gebruikt een bestandsobject, teruggegeven door open(), om met die informatie te werken. Openen verbindt het programma met het bestand; een leesbewerking haalt de tekst op.

Kies wat je leest

De standaardmodus is "r", voor lezen. Een losse naam wordt opgezocht in de huidige werkmap. Als het bestand daar ontbreekt, werpt open() FileNotFoundError op.

with open("fruit.txt", encoding="utf-8") as f:
    text = f.read()

Stel dat het bestand drie regels heeft, “apple”, “banana” en “cherry”, allemaal met een regelafsluiting. text is 'apple\nbanana\ncherry\n'. De escapesequentie \n stelt één regeleindeteken voor. Een laatste regel kan ook zonder regeleindeteken eindigen.

readline() geeft '' terug aan het einde van het bestand. Een lege regel met een regelafsluiting geeft '\n' terug, dus een lege regel en het einde van het bestand zijn verschillend.

Houd de positie bij

Door te lezen gaat de bestandspositie vooruit. Nadat f.read() het bestand heeft uitgelezen, geeft een volgende aanroep '' terug; een lus over datzelfde object heeft niets meer te lezen. Open het bestand opnieuw om opnieuw te beginnen, of bewaar de benodigde tekst of regels in een variabele. read() en readlines() laden de rest van het bestand in het geheugen. Door rechtstreeks over het bestand te lopen, kun je een groot bestand regel voor regel verwerken.

Regels behouden hun regeleindetekens. print(line) voegt zelf een regeleindeteken toe, waardoor extra lege regels op het scherm kunnen ontstaan. Gebruik print(line, end="") om de oorspronkelijke regelafstand te behouden, of verwijder de regelafsluiting vóór het afdrukken. line.rstrip("\n") verwijdert regeleindetekens aan het einde; line.strip() verwijdert ook spaties aan beide uiteinden.

Zet tekst om in getallen

Zelfs cijfers komen binnen als strings. Dit bestand bevat de scores “72”, “85” en “90”:

scores = []
with open("scores.txt", encoding="utf-8") as f:
    for line in f:
        scores.append(int(line))
total = sum(scores)
print(total, round(total / len(scores), 2))

De lijst is [72, 85, 90], dus drukt het programma 247 82.33 af. int() accepteert spaties en regeleindetekens rondom de waarde. Een lege string of een woord zoals "forty" werpt ValueError op.

Lees tekens met de juiste tekencodering

Een tekencodering koppelt tekens aan opgeslagen bytes. UTF-8 kan tekens zoals “é” en emoji weergeven. Gebruik voor UTF-8-bestanden expliciet encoding="utf-8". Python 3.15 schakelt standaard de UTF-8-modus in; oudere installaties kunnen een lokale tekencodering gebruiken. Een onjuiste tekencodering kan verminkte tekst of UnicodeDecodeError opleveren. Een expliciete tekencodering zet een bestand dat met een andere codering is opgeslagen niet om naar UTF-8.

Het with-blok sluit het bestand wanneer het eindigt. Een gesloten bestand kan niet worden gelezen: een volgende f.read() werpt ValueError op.

Een open bestand gebruikt bronnen van het besturingssysteem. Tekst die wordt geschreven, kan ook in een buffer in het geheugen wachten voordat die het bestand bereikt. Sluiten geeft de bronnen vrij en schrijft de gebufferde uitvoer weg. Een with-instructie regelt dat opruimen op een duidelijke plek in de code.

Lees binnen het blok, gebruik het resultaat daarna

with open("notes.txt", encoding="utf-8") as f:
    text = f.read()
print(len(text))

De dubbele punt begint het blok. De ingesprongen regel wordt uitgevoerd terwijl f open is. Wanneer de uitvoering de niet-ingesprongen print() bereikt, is het bestand gesloten, maar blijft text een gewone string. De naam f verwijst nog steeds naar het bestandsobject; f.closed is nu True.

Hetzelfde patroon werkt voor een lijst:

with open("fruit.txt", encoding="utf-8") as f:
    lines = f.readlines()
for line in lines:
    print(line.strip().upper())

De lus gebruikt gegevens die al in lines zijn ingelezen. Als je f.readlines() buiten het blok zou plaatsen, zou die proberen een gesloten bestand te lezen en ValueError opwerpen.

Opruimen wanneer het uitvoeringsverloop verandert

Bekijk een functie die de eerste regel teruggeeft:

def first_line(path):
    with open(path, encoding="utf-8") as f:
        return f.readline().rstrip("\n")

De retourwaarde wordt binnen het blok voorbereid. Python verlaat daarna het blok en sluit het bestand voordat de aanroepende code die waarde ontvangt. Het bestand sluit ook wanneer een exceptie het blok verlaat. Een handmatige f.close() na een instructie die een fout veroorzaakt, zou nooit worden bereikt.

Bestandsobjecten ondersteunen dit gedrag omdat het contextbeheerders zijn: objecten die de voorbereiding en het opruimen rond een with-blok regelen. Je kunt dat gedrag gebruiken zonder zelf een contextbeheerder te schrijven.

Open samen een invoer- en een uitvoerbestand

with open("in.txt", encoding="utf-8") as src, open("out.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line.upper())

Elke invoerregel wordt omgezet naar hoofdletters en naar de uitvoer geschreven. Beide bestanden sluiten wanneer het blok eindigt. Als de tweede opening mislukt, wordt het eerste bestand, dat al door with is geopend, gesloten wanneer Python de instructie verlaat.

Opruimen en foutherstel hebben verschillende taken

with vangt geen bestandsfouten op. Als open() notes.txt niet kan vinden, werpt de functie FileNotFoundError op voordat de inhoud van het blok wordt uitgevoerd. Als het omzetten van een regel met int() binnen het blok mislukt, sluit het bestand en wordt de exceptie verder naar buiten doorgegeven. Voor herstel of het tonen van een melding is een overeenkomende except-clausule nodig.

Een ontbrekende dubbele punt aan het einde van de with-regel veroorzaakt SyntaxError.

Schrijven begint met een keuze over bestaande gegevens. De modus bepaalt of Python een bestand leest, vervangt, uitbreidt of aanmaakt. Maak die keuze voordat je open() aanroept, want vervangen gebeurt onmiddellijk.

Kies de modus

Als je de enige kopie van belangrijke gegevens opent met "w", vernietig je de oude inhoud, zelfs als er geen write() volgt. Gebruik een apart uitvoerbestand terwijl je leert gegevens te transformeren. "x" is handig wanneer het vervangen van een bestaand bestand moet worden geweigerd.

Door "b" toe te voegen, zoals in "rb", kies je de binaire modus voor ruwe bytes. Tekstmodi werken met strings en een tekencodering; binaire modi accepteren geen encoding-argument.

Bepaal waar regels eindigen

with open("todo.txt", "w", encoding="utf-8") as f:
    f.write("buy milk\n")
    f.write("call Sam\n")

Het bestand heeft de twee regels “buy milk” en “call Sam”. write() voegt precies de opgegeven string toe, zonder automatisch scheidingsteken. Zonder de regeleindetekens zou het bestand "buy milkcall Sam" op één regel bevatten.

write() geeft het aantal geschreven tekens terug. Zo geeft f.write("Ana,92\n") 7 terug. Dat is een aantal tekens, niet noodzakelijk het aantal gecodeerde bytes op schijf. De methode accepteert een string; f.write(42) werpt TypeError op. Zet een getal eerst om, bijvoorbeeld met f.write(f"{score}\n").

Vergelijk de hulpmiddelen voor uitvoer

print() kan naar een bestand schrijven:

with open("total.txt", "w", encoding="utf-8") as f:
    print("Total:", 247, file=f)

De uitvoertekst is "Total: 247\n". print() zet zijn argumenten om, scheidt ze met spaties en voegt standaard aan het einde een regeleindeteken toe.

writelines() krijgt een sequentie van strings, maar voegt geen regelafsluitingen in. f.writelines(["a", "b"]) schrijft "ab". Om één element per regel te krijgen, neem je een regeleindeteken op in elke string, of voeg je de strings samen met "\n" en voeg je aan het einde een regeleindeteken toe.

Bewaar eerdere uitvoeringen

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("Program started\n")

Als er aanvankelijk geen bestand is, leveren twee uitvoeringen twee regels op. Met "w" zou elke uitvoering de eerdere regel vervangen. De toevoegmodus vult geen ontbrekend regeleindeteken aan: als de bestaande tekst midden op een regel eindigt, begint de nieuwe tekst er direct achter.

Voor een rapport doorloop je paren zoals [("Ana", 92), ("Ben", 78)] en schrijf je f"{name}: {score}\n". De opmaak gebeurt vóór het schrijven, dus f"{82.333:.1f}" levert de tekst "82.3" op. Daarna sluit with de uitvoer en schrijft de gebufferde tekst weg aan het einde van het blok.

Veel bestandstaken bestaan uit een lus met een keuze erin. Lees een regel, verwijder ongewenste witruimte, bepaal of de regel van belang is en werk een resultaat bij. Door deze stappen gescheiden te houden, maak je een programma gemakkelijker te controleren.

Doorloop een logbestand

Stel dat server.log deze records bevat, met een lege regel vóór het laatste record:

2026-03-01 08:14 INFO Server started
2026-03-01 08:20 ERROR Disk almost full
2026-03-01 09:02 INFO User login: maya
2026-03-01 09:15 WARNING Slow response
2026-03-01 10:40 ERROR Database timeout

2026-03-01 11:05 INFO Backup finished

Elk niet-leeg record heeft een datum, tijd, niveau en bericht. Splits slechts drie keer om het bericht bij elkaar te houden:

errors = 0
with open("server.log", encoding="utf-8") as f:
    for line in f:
        line = line.strip()
        if not line:
            continue
        parts = line.split(maxsplit=3)
        if parts[2] == "ERROR":
            errors += 1
            print(parts[3])
print(errors, "errors")

Voor het tweede record is parts[2] gelijk aan "ERROR" en parts[3] aan "Disk almost full". Dat bericht wordt afgedrukt en de teller stijgt naar 1. De latere fout verhoogt de teller naar 2. Het programma drukt beide berichten af en daarna “2 errors”.

Controleer het bedoelde deel

Overal zoeken zou ook overeenkomen met “INFO No ERRORS today”. Controle van het niveauveld beantwoordt de vraag over het logbestand nauwkeuriger.

Na strip() is een lege regel ""; splitsen levert [] op. Als je dan parts[2] met een index benadert, wordt IndexError opgeworpen. De continue slaat die regel over voordat een index wordt gebruikt. Een niet-leeg maar onvolledig record vereist ook een lengtecontrole wanneer zulke records mogelijk zijn.

Tel categorieën of schrijf een gefilterd bestand

Een dictionary bevat een telling per niveau. Stel voor elk record level = parts[2] in en daarna counts[level] = counts.get(level, 0) + 1. Voor het logbestand hierboven zijn de tellingen {'INFO': 3, 'ERROR': 2, 'WARNING': 1}. De standaardwaarde 0 begint een categorie wanneer die voor het eerst verschijnt.

Om overeenkomende records op te slaan, open je een apart doelbestand in dezelfde with-instructie en schrijf je een regel wanneer het niveau overeenkomt. Bewaar de oorspronkelijke line als de witruimte van belang is; als je opgeschoonde tekst schrijft, voeg dan het regeleindeteken weer toe. Open het bronbestand zelf nooit met "w": het zou worden leeggemaakt voordat het lezen begint.

Maak onzichtbare tekens zichtbaar

print(repr(line)) maakt spaties en regeleindetekens aan het einde zichtbaar, bijvoorbeeld 'Disk full \n'. strip() verwijdert beide, terwijl rstrip("\n") de spaties behoudt. Bij gewoon lezen als tekst worden herkende regelafsluitingen van Windows, Unix en oude Macsystemen omgezet naar "\n". Een laatste regel zonder afsluiting blijft zonder afsluiting. Met een bestandsnaam die via input("File name: ").strip() wordt opgehaald, werkt dezelfde lus voor verschillende invoerbestanden.

Een pad beschrijft een locatie in een mappenboom. Het kan beginnen bij de wortel van die boom of bij de huidige werkmap van het programma. Een bestand kan op de computer bestaan en toch ontbreken op de locatie waar je programma om vraagt.

Lees een pad vanaf het beginpunt

Stel dat een map met de naam project een map scripts en een map data bevat. Je voert python scripts/report.py uit terwijl je in project werkt. Het openen van "data/notes.txt" zoekt in project/data, ook al staat het script in project/scripts.

Als je hetzelfde script daarentegen start terwijl je in project/scripts werkt, verwijst dat relatieve pad naar een locatie in project/scripts/data. Het script is niet verplaatst; het beginpunt is veranderd.

from pathlib import Path
print(Path.cwd())

Dit drukt de huidige werkmap af. os.getcwd() na import os geeft dezelfde informatie als string. Editors en hulpmiddelen om programma’s te starten kunnen een werkmap kiezen, dus bekijk die wanneer de locatie onduidelijk is.

Doorloop mappen

In een relatief pad betekent . de huidige map en .. de bovenliggende map. Vanuit project/scripts gaat ../data/notes.txt omhoog naar project en daarna omlaag naar data. Als je .. toevoegt zonder de beginmap te controleren, kan een programma op de verkeerde locatie terechtkomen.

Een absoluut pad is handig om één exacte locatie aan te geven, maar een pad zoals C:/Users/Maya/Desktop/data.csv bindt gedeelde code aan de mappen van één persoon. Gebruik een relatief pad met een duidelijk beginpunt, of stel het pad samen vanuit de eigen map van het script wanneer de gegevens daar thuishoren.

Houd backslashes van Windows intact

Windows toont gewoonlijk backslashes tussen mappen. In een gewone Pythonstring begint een backslash een escapesequentie: \n wordt een regeleindeteken en \t een tab. De letterlijke waarde "C:\new\table.txt" bevat daarom niet het pad dat je bedoelde.

Deze vormen behouden het bedoelde pad:

raw = r"C:\new\table.txt"
escaped = "C:\\new\\table.txt"
forward = "C:/new/table.txt"

Python op Windows accepteert schuine strepen. Een ruwe string voorkomt dat backslashes escapesequenties worden, maar kan niet eindigen op één enkele backslash. Zo is r"C:\data\" ongeldige syntaxis.

Controleer zowel de naam als de map

Let op verschillen in spelling en verborgen extensies: een bestand dat wordt weergegeven als “notes.txt” kan in werkelijkheid “notes.txt.txt” heten. Ook hoofdletters en kleine letters zijn van belang. Linux maakt meestal onderscheid tussen Data.csv en data.csv; de gebruikelijke instellingen van Windows en macOS doen dat niet. Door de werkelijke hoofdletters en kleine letters over te nemen, blijft een project op verschillende systemen bruikbaar.

De standaardmodule pathlib geeft een pad een eigen object. Met een Path kun je mapnamen samenvoegen, een bestandsnaam bekijken en veelvoorkomende bestandstaken uitvoeren zonder handmatig strings met scheidingstekens samen te stellen.

Voeg samen en bekijk

from pathlib import Path
p = Path("reports") / "2026" / "sales.csv"
print(p.name)
print(p.stem)
print(p.suffix)
print(p.parent)

De eerste drie resultaten zijn “sales.csv”, “sales” en “.csv”. De bovenliggende map is het pad reports/2026, weergegeven met het scheidingsteken van het systeem. Hier voegt / padonderdelen samen; de operator deelt geen getallen. Het oudere os.path.join() voegt ook padonderdelen als strings samen.

Een Path beschrijft een locatie, ook voordat daar iets bestaat. p.exists() controleert of er iets op die locatie bestaat. p.is_file() en p.is_dir() maken onderscheid tussen een bestand en een map. Een controle op bestaan kan niet garanderen dat later openen lukt: het bestand kan verdwijnen of de toegang kan tussen die bewerkingen veranderen. Handel openingsfouten af wanneer het programma moet kunnen herstellen.

Lees of schrijf een klein bestand

open() accepteert direct een Path. Voor een klein bestand regelen deze hulpmethoden ook het openen en sluiten:

p = Path("greeting.txt")
p.write_text("Hello\n", encoding="utf-8")
text = p.read_text(encoding="utf-8")

text wordt "Hello\n". write_text() vervangt bestaande inhoud, net als openen met "w"; het is geen hulpmethode om tekst toe te voegen. read_text() laadt het hele bestand, dus gebruik een bestandslus wanneer je een groot bestand regel voor regel moet verwerken.

Begin vanuit de map van het script

Een gegevensbestand dat naast een script wordt meegeleverd, moet vanuit dat script worden gevonden, onafhankelijk van de werkmap:

base = Path(__file__).resolve().parent
scores_path = base / "data" / "scores.txt"
with open(scores_path, encoding="utf-8") as f:
    scores = f.readlines()

__file__ duidt het scriptbestand aan. resolve() maakt het pad absoluut en parent selecteert de map waarin het staat. In een interactieve shell is __file__ niet gedefinieerd, dus hoort dit patroon in een script thuis.

Vind bestanden en bereid uitvoermappen voor

for p in sorted(Path("logs").glob("*.txt")):
    text = p.read_text(encoding="utf-8")
    print(p.name, len(text.splitlines()))

glob("*.txt") selecteert overeenkomende paden in logs. iterdir() levert de inhoud van de map zonder dat patroon als filter. Sorteren maakt de volgorde voorspelbaar. splitlines() telt de tekstregels zonder de laatste regelafsluiting als een extra lege regel te behandelen.

Schrijven maakt een bestand aan, maar geen ontbrekende bovenliggende mappen. Maak die eerst aan:

folder = Path("output") / "daily"
folder.mkdir(parents=True, exist_ok=True)
(folder / "report.txt").write_text("Ready\n", encoding="utf-8")

parents=True maakt ontbrekende mappen boven daily aan. exist_ok=True accepteert een map die al bestaat. Het verandert een bestaand gewoon bestand niet in een map.

Een CSV-bestand slaat een tabel op als tekst. De records zijn rijen en de velden zijn kolomwaarden. Komma’s scheiden gewoonlijk de velden, maar velden tussen aanhalingstekens kunnen komma’s en zelfs regeleinden bevatten. Gebruik de module csv om die waarden bij elkaar te houden.

Laat een lezer aanhalingstekens verwerken

name,quiz1,quiz2
Ana,8,9
Ben,7,6
"Lopez, Maria",10,8

De eerste rij is een kopregel met kolomnamen. De laatste gegevensrij heeft drie velden, geen vier: de komma binnen de aangehaalde naam hoort bij de naam. Een dubbel aanhalingsteken binnen een veld tussen aanhalingstekens wordt tweemaal geschreven. Als je elke regel met split(",") zou splitsen, zou je die regels negeren en de naam in stukken breken.

import csv
with open("grades.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        print(row[0], average)

De lezer geeft lijsten met strings terug. next(reader) leest de kopregel één keer, waarna de lus de gegevens kan verwerken. Het programma drukt “Ana 8.5”, “Ben 6.5” en “Lopez, Maria 9.0” af. In de eerste gegevensrij levert het omzetten van "8" en "9" samen 17 op; delen door 2 geeft daarna 8,5.

Stem bestandsverwerking en tabelinterpretatie op elkaar af

Open CSV-bestanden met newline="", zodat de module csv zelf regelafsluitingen verwerkt. Dit is van belang wanneer een veld tussen aanhalingstekens een regeleinde bevat. Eén CSV-record kan meerdere fysieke bestandsregels beslaan, dus regels afzonderlijk splitsen is geen vervanging voor een CSV-lezer.

De lezer laat waarden standaard als strings staan. Zonder conversie voegt row[1] + row[2] de strings "8" en "9" samen tot "89". Als je vergeet de kopregel over te slaan, probeert het programma "quiz1" om te zetten en werpt het ValueError op.

Als een bestand leeg kan zijn, leest next(reader, None) een kopregel als die aanwezig is en geeft anders None terug. Een volledig lege CSV-regel wordt []. Sla zulke rijen over met if not row: continue voordat je een index gebruikt. Een niet-lege rij met te weinig velden vereist ook een lengtecontrole; alleen lege rijen overslaan beschermt row[2] niet tegen elk kort record.

Sluit aan bij de opmaak van het bestand

reader = csv.reader(f, delimiter=";", skipinitialspace=True)

Dit kiest puntkomma’s als scheidingstekens en verwijdert spaties direct erna. Kies het scheidingsteken dat het bestand daadwerkelijk gebruikt; een ander scheidingsteken kiezen zet decimale komma’s niet om in decimale punten. float("2,50") werpt nog steeds ValueError op.

Sommige exportbestanden uit spreadsheetprogramma’s beginnen met een UTF-8-bytevolgordemarkering. Als je zo’n bestand leest met encoding="utf-8", kan "\ufeff" aan het begin van het eerste veld blijven staan, waardoor de kop "name" verandert in "\ufeffname". Voor die opmaak verwijdert encoding="utf-8-sig" de markering; hiermee kun je ook UTF-8-bestanden zonder markering lezen.

Een CSV-schrijver zet waarden om in correct gescheiden velden en plaatst ze waar nodig tussen aanhalingstekens. Geef de schrijver rijen als sequenties van waarden en laat hem de leestekens verwerken. Zo voorkom je uitvoer die er goed uitziet totdat een naam of bericht een komma bevat.

Schrijf een kopregel en gegevens

import csv
with open("summary.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "average"])
    writer.writerow(["Ana", 8.5])
    writer.writerow(["Lopez, Maria", 9.0])

Het bestand bevat de rijen name,average, Ana,8.5 en "Lopez, Maria",9.0. De schrijver zet getallen om in tekst. Hij plaatst de naam met een komma tussen aanhalingstekens en verdubbelt elk dubbel aanhalingsteken binnen een veld tussen aanhalingstekens. None wordt een leeg veld, dus als je het bestand terugleest, krijg je None niet automatisch terug.

writerow() krijgt één rij. writerows() krijgt een sequentie van rijen, zoals [["Ana", 8.5], ["Ben", 6.5]]. Als je "Ana" rechtstreeks aan writerow() doorgeeft, krijgt die drie tekens en ontstaat A,n,a. Gebruik ["Ana"] voor een rij met één veld.

Laat CSV de regelafsluitingen regelen

Gebruik newline="" wanneer je het uitvoerbestand opent. De standaardschrijver sluit records af met "\r\n". Als je ook in tekstmodus regeleindetekens laat vertalen, kan Windows een extra wagenterugloop toevoegen, waardoor in sommige lezers ongewenste lege regels ontstaan. Het argument newline voorkomt die tweede omzetting.

Zet het ene bestand om in het andere

with open("grades.csv", newline="", encoding="utf-8") as src, open("summary.csv", "w", newline="", encoding="utf-8") as dst:
    reader = csv.reader(src)
    writer = csv.writer(dst)
    next(reader)
    writer.writerow(["name", "average"])
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        writer.writerow([row[0], round(average, 2)])

Voor de cijferregels “Ana,8,9”, “Ben,7,6” en "Lopez, Maria",10,8 zijn de gemiddelden 8,5, 6,5 en 9,0. De lezer verwijdert de CSV-aanhalingstekens uit de invoerveldwaarde; de schrijver voegt de benodigde aanhalingstekens weer toe aan de uitvoer. round() bepaalt de numerieke waarde die wordt geschreven, maar dwingt geen weergave met twee decimalen af. Gebruik een opmaak zoals f"{average:.2f}" wanneer je precies twee decimalen wilt.

Voeg toe zonder de kopregel te herhalen

Controleer voordat je een bestand opent om tekst toe te voegen of het een kopregel nodig heeft:

from pathlib import Path
p = Path("sales.csv")
needs_header = not p.exists() or p.stat().st_size == 0
with open(p, "a", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    if needs_header:
        writer.writerow(["item", "quantity"])
    writer.writerow(["coffee", 4])

Ook een bestaand leeg bestand heeft een kopregel nodig. Als je de kopregel bij elke uitvoering schrijft, komen kolomnamen midden in de gegevens terecht. Dit patroon gaat ervan uit dat één programma het bestand bijwerkt; een controle op bestaan voorkomt niet dat andere programma’s het bestand wijzigen.

Code die op positie werkt, zoals row[2], is afhankelijk van de kolomvolgorde. Met een lezer op basis van dictionary’s kun je de waarde die je nodig hebt bij naam noemen. Een dictionary koppelt sleutels aan waarden; hier levert de kopregel de sleutels en levert elk gegevensrecord de bijbehorende waarden.

Lees velden op naam

import csv
with open("inventory.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    rows = list(reader)

Voor de kopregel product,stock,price en de rij notebook,12,2.50 is de eerste dictionary {'product': 'notebook', 'stock': '12', 'price': '2.50'}. reader.fieldnames geeft de namen uit de kopregel. De kopregel wordt automatisch ingelezen; een aanroep van next(reader) zou het eerste gegevensrecord overslaan.

Gebruik row["stock"] om de voorraad te selecteren, ook als de kolommen een andere volgorde krijgen. Zet de waarde om met int() om hoeveelheden te vergelijken. De waarden blijven strings; kolomnamen geven de lezer geen numerieke typen.

Filter en tel op

Stel dat de tabel een voorraad van 12 notitieboeken tegen een prijs van 2,50 bevat, 3 pennen tegen 1,20, 0 nietmachines tegen 7,95 en 25 mappen tegen 0,80.

low = [r for r in rows if int(r["stock"]) < 5]
value = sum(int(r["stock"]) * float(r["price"]) for r in rows)

low bevat de rijen voor de pen en de nietmachine. De waarde is € 53,6: de notitieboeken dragen 30 bij, de pennen 3,6, de nietmachines 0 en de mappen 20. Het filter gebruikt de voorraad, terwijl het totaal zowel de voorraad als de prijs gebruikt.

Maak onderscheid tussen ontbrekende sleutels en ontbrekende waarden

Namen in de kopregel moeten precies overeenkomen. Name en name zijn verschillende sleutels. Een spatie na een komma kan onderdeel worden van een kolomnaam; skipinitialspace=True verwijdert spaties direct na scheidingstekens.

Een kopregel name,quiz1,quiz2 met gegevens Ben,7 levert {'name': 'Ben', 'quiz1': '7', 'quiz2': None} op. De sleutel bestaat, maar de waarde ontbreekt. int(None) werpt TypeError op. Een aanwezig leeg veld is "", en omzetting daarvan werpt ValueError op. Een sleutel die niet in de kopregel voorkomt, veroorzaakt daarentegen KeyError bij het opzoeken.

Bij de gegevens Cara,1,2,3 worden extra velden verzameld als None: ['3']; de benoemde velden bevatten nog steeds "Cara", "1" en "2". Controleer de indeling van een rij wanneer nauwkeurige totalen van elk veld afhangen.

Schrijf geselecteerde kolommen

with open("reorder.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["product", "stock"])
    writer.writeheader()
    for r in low:
        writer.writerow({"product": r["product"], "stock": r["stock"]})

fieldnames bepaalt de uitvoervolgorde, ongeacht de volgorde in de dictionary. Ontbrekende dictionarysleutels worden lege velden. Extra sleutels werpen standaard ValueError op: een voorraaddictionary met price doorgeven aan deze schrijver met twee kolommen mislukt. Maak de kleinere dictionary zoals getoond, of kies extrasaction="ignore" wanneer het weglaten van extra velden de bedoeling is.

Een exceptie is een object dat tijdens de uitvoering een probleem aangeeft. Het opwerpen ervan onderbreekt de normale uitvoering. Als geen exceptieafhandelaar de exceptie afhandelt, beëindigt Python het programma met een stacktrace, een overzicht van de aanroepen die tot de fout hebben geleid.

Begin onderaan

def average(values):
    return sum(values) / len(values)

def report():
    scores = []
    print(average(scores))

report()

De stacktrace eindigt met ZeroDivisionError: division by zero. Begin daar: het type benoemt het soort probleem en de melding geeft details. Het onderdeel direct daarboven verwijst naar de deling in average(). Eerdere onderdelen tonen de aanroep vanuit report() en de oorspronkelijke aanroep van report(). De lijst is leeg, dus de lengte is 0. De gemelde regel is waar het probleem zichtbaar wordt; de eerdere toekenning van de lege lijst verklaart hoe het ontstond.

Kies het passende type

int("abc") ontvangt een toegestaan invoertype, een string, maar kan die waarde niet als geheel getal interpreteren. "5" + 3 mengt daarentegen typen die niet bij elkaar kunnen worden opgeteld. Een string die cijfers bevat, blijft een string.

Bestandsbewerkingen hebben specifiekere typen: FileNotFoundError voor een ontbrekend pad, PermissionError voor geweigerde toegang en FileExistsError voor het aanmaken van een bestaand bestand met "x". Een map als gewoon bestand openen kan IsADirectoryError opwerpen. Bytes decoderen met een ongeschikte tekencodering kan UnicodeDecodeError opwerpen.

Begrijp de stamboom

Exceptieklassen vormen een hiërarchie. Een exceptieafhandelaar voor een bovenliggende klasse kan de onderliggende klassen opvangen:

• OSError is het bovenliggende type van veelvoorkomende bestandssysteemfouten, waaronder FileNotFoundError en PermissionError.
• LookupError is het bovenliggende type van IndexError en KeyError.
• ArithmeticError is het bovenliggende type van ZeroDivisionError.
• UnicodeDecodeError valt onder ValueError.

Deze takken stammen af van Exception, dat afstamt van BaseException. KeyboardInterrupt en SystemExit stammen daarentegen rechtstreeks af van BaseException. Door dat onderscheid laat except Exception onderbreking door de gebruiker en beëindiging van het programma ongemoeid.

Maak onderscheid tussen syntaxis-, uitvoerings- en logische problemen

Een ontbrekende dubbele punt of een ontbrekend sluitend haakje kan verhinderen dat Python een script ontleedt. De daaruit volgende SyntaxError treedt op voordat het script wordt uitgevoerd, dus een try in datzelfde script kan de fout niet opvangen. Een uitvoeringsexceptie treedt op terwijl geldige code wordt uitgevoerd. Een logische fout levert een verkeerd antwoord op zonder noodzakelijkerwijs een exceptie op te werpen, bijvoorbeeld door een totaal door het verkeerde aantal te delen.

Een try-instructie voert code uit waarbij een fout kan optreden en biedt een herstelpad voor geselecteerde excepties. De exceptieafhandelaar moet passen bij het probleem dat het programma verwacht en waarop het weet te reageren.

Volg het uitvoeringsverloop

while True:
    try:
        age = int(input("Age: "))
        break
    except ValueError:
        print("Please enter a whole number, like 34.")
print("Next year you will be", age + 1)

Als de gebruiker “twenty” typt, werpt int() ValueError op. Python slaat de rest van de try over, inclusief break, en voert de overeenkomende exceptieafhandelaar uit. Daarna vraagt de lus opnieuw om invoer. Als de gebruiker “34” typt, wordt de try voltooid via break, zodat het programma de lus verlaat en “Next year you will be 35” afdrukt.

Een exceptieafhandelaar hervat de uitvoering niet bij de mislukte instructie. De uitvoering gaat verder na de try-instructie, tenzij de exceptieafhandelaar zelf dat verloop verandert. Als geen exceptieafhandelaar overeenkomt, wordt de exceptie verder naar buiten doorgegeven.

Handel verschillende fouten verschillend af

try:
    result = int(a) / int(b)
except ValueError:
    print("Both values must be whole numbers.")
except ZeroDivisionError:
    print("The second value cannot be 0.")

Een mislukte conversie en een deler die nul is, vereisen verschillende meldingen. Als de reactie hetzelfde moet zijn, groepeer je typen in een tuple: except (ValueError, ZeroDivisionError):. Haakjes werken in heel Python 3. Python 3.14 staat ook een lijst zonder haakjes toe wanneer er geen as-gedeelte is; de tuplevorm blijft in alle versies duidelijk.

Python controleert clausules van boven naar beneden en voert de eerste overeenkomst uit. Zet FileNotFoundError vóór het bovenliggende type OSError als een ontbrekend bestand een speciale reactie vereist. Als je ze omdraait, wordt de specifieke exceptieafhandelaar onbereikbaar.

Gebruik de melding zonder andere programmeerfouten te verbergen

try:
    quantity = int(text)
except ValueError as err:
    print("Cannot read quantity:", err)

err is het exceptieobject; als je het afdrukt, zie je de melding. type(err).__name__ geeft de klassenaam. Python verwijdert de binding van err wanneer de exceptieafhandelaar eindigt, dus kopieer de melding binnen het blok naar een andere variabele als je die later nodig hebt.

Houd de try klein. Zet latere berekeningen buiten de conversieafhandeling wanneer fouten daarin een andere behandeling vereisen. except Exception: kan programmeerfouten verbergen, zoals een niet-gedefinieerde variabele. Een kale except: is nog breder: die vangt ook KeyboardInterrupt en SystemExit op.

Probeer de bewerking opnieuw, niet een ruwe benadering ervan

Met text.isdigit() controleer je niet alles wat int() accepteert. "-5" en " 34" doorstaan die controle niet, maar worden wel omgezet; "²" doorstaat de controle wel, maar wordt niet door int() omgezet. Door de conversie te proberen en ValueError op te vangen, gebruik je de eigen regels van de conversie.

Doe iets zichtbaars of leg iets vast wanneer je ongeldige gegevens afhandelt. Een lege except ValueError: pass kan het programma laten doorgaan met ontbrekende resultaten zonder vast te leggen wat er misging.

Een try-instructie kan de bewerking waarbij een fout kan optreden, het herstel, de werkzaamheden na succes en het opruimen van elkaar scheiden. Een exceptie kan ook een functie verlaten en door de aanroepende code worden afgehandeld.

Geef werkzaamheden na succes een eigen blok

try:
    x = 10 / int(text)
except ValueError:
    print("not a number")
except ZeroDivisionError:
    print("zero")
else:
    print("result", x)
finally:
    print("done")

Met text = "4" drukt het programma “result 2.5” en “done” af. Met "abc" drukt het “not a number” en “done” af; met "0" drukt het “zero” en “done” af.

else wordt uitgevoerd wanneer de try normaal en zonder exceptie wordt voltooid. Het wordt niet uitgevoerd nadat een exceptieafhandelaar een fout heeft hersteld. Het wordt ook overgeslagen wanneer return, break of continue de try voortijdig verlaat. Fouten die binnen else worden opgeworpen, worden niet opgevangen door de eerdere except-clausules van die instructie, zodat werkzaamheden na succes niet per ongeluk dezelfde exceptieafhandelaars gebruiken als de bewerking waarbij een fout kan optreden.

Laat opruimen bij elke uitgang plaatsvinden

finally wordt uitgevoerd wanneer de uitvoering de instructie verlaat: na succes, na een afgehandelde exceptie en voordat een niet-afgehandelde exceptie verder wordt doorgegeven. Het wordt ook uitgevoerd voordat een op handen zijnde terugkeer wordt voltooid.

def label():
    try:
        return "from try"
    finally:
        print("finally ran")

value = label()
print(value)

Dit drukt “finally ran” af en daarna “from try”. De terugkeer wachtte terwijl het opruimen plaatsvond. Voor bestanden regelt with het sluiten al, zodat handmatig sluiten in finally meestal niet nodig is.

Zet geen instructie die het blok verlaat, zoals return, break of continue, in finally. Als je het opruimblok op die manier verlaat, kan een op handen zijnde exceptie worden weggegooid of een retourwaarde worden overschreven. Python 3.14 en later geven voor dit patroon een SyntaxWarning. Gebruik het opruimblok alleen om op te ruimen.

Volg een exceptie naar de aanroepende code

def read_scores(path):
    with open(path, encoding="utf-8") as f:
        return [int(line) for line in f]

try:
    scores = read_scores("scores.txt")
except FileNotFoundError:
    print("The score file is missing.")

Als het openen mislukt, heeft read_scores() geen exceptieafhandelaar, dus wordt FileNotFoundError doorgegeven aan de aanroep binnen de buitenste try. De aanroepende code handelt de exceptie af en drukt de melding af. Als een regel geen geheel getal is, volgt een ValueError dezelfde route, maar de exceptieafhandelaar voor een ontbrekend bestand komt daar niet mee overeen.

Kies het niveau dat zinvol kan reageren

Een leesfunctie weet mogelijk hoe ze gegevens moet ophalen, maar niet of een ontbrekend bestand moet leiden tot opnieuw proberen, een taak overslaan of gecontroleerd stoppen. Door de exceptie de aanroepende code te laten bereiken die met de gebruiker communiceert, blijft die keuze daar. Als je de exceptie te vroeg opvangt en een lege lijst teruggeeft, kan het verschil tussen een leeg bestand en een mislukte leesactie verborgen blijven.

Een programma handelt een fout gecontroleerd af wanneer het beheerst en bruikbaar op een probleem reageert. Het kan opnieuw vragen, een overgeslagen rij melden of stoppen met een duidelijke melding. Kies die reactie op basis van waarvoor het resultaat wordt gebruikt.

Probeer een ontbrekend bestand opnieuw

while True:
    name = input("File name: ").strip()
    try:
        with open(name, encoding="utf-8") as f:
            text = f.read()
    except FileNotFoundError:
        print(f"No file named '{name}'. Please try again.")
    else:
        break
print(len(text.splitlines()), "lines")

Een mislukte opening slaat de toekenning over en bereikt de exceptieafhandelaar. De lus vraagt opnieuw om invoer. Een geslaagde leesactie bereikt else, verlaat de lus en laat text beschikbaar voor de eindtelling. with sluit het bestand op beide manieren waarop een eenmaal betreden blok kan worden verlaten.

Gebruik voor verschillende bestandsproblemen eerst FileNotFoundError, dan PermissionError en daarna een algemene OSError-afhandelaar als andere bestandssysteemfouten een reactie vereisen. De specifieke clausules moeten eerst komen. Ongeldige bytes decoderen is een ander probleem; een melding over een ontbrekend pad zou dat niet beschrijven.

Handel elke gegevensrij afzonderlijk af

Stel dat voor een snel verkoopoverzicht de CSV-rijen na de kopregel coffee,4, tea,two, muffin,3, cookie, en juice,5 zijn.

import csv
total = 0
skipped = 0
with open("sales.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader, None)
    for row in reader:
        try:
            if len(row) != 2:
                raise ValueError("expected two fields")
            quantity = int(row[1])
        except ValueError as err:
            skipped += 1
            print(f"sales.csv, ending line {reader.line_num}: {err}")
        else:
            total += quantity
print("Total:", total, "Skipped:", skipped)

De geldige hoeveelheden tellen op tot 12. Het woord “two” en de lege hoeveelheid worden afgewezen, dus het aantal overgeslagen rijen is 2. De rijcontrole maakt van een onverwacht aantal velden ook een gemelde gegevensfout voordat een index wordt gebruikt. Door try binnen de lus te plaatsen, kan het volgende record worden verwerkt nadat er één mislukt; als je de lus binnen één try plaatst, verlaat je de lus bij de eerste fout.

Meld locaties nauwkeurig

Voor de vijf records van één regel eindigen de ongeldige waarden op bestandsregels 3 en 5. enumerate(reader, start=2) zou hier met die regelnummers overeenkomen, maar door een regeleinde tussen aanhalingstekens kan een CSV-record meer dan één regel beslaan. reader.line_num geeft aan hoeveel fysieke regels de lezer heeft verwerkt. Door dit de eindregel te noemen, blijven meldingen nauwkeurig voor records die meerdere regels beslaan.

Bepaal of een gedeeltelijk resultaat aanvaardbaar is

Een snelle verkennende telling kan gemelde overgeslagen rijen toestaan. Een financieel totaal of een cijfertotaal kan elk record vereisen: stop en vraag om gecorrigeerde gegevens in plaats van een gedeeltelijk totaal als volledig te presenteren. Noem het bestand, de locatie en het probleem zodat het kan worden opgelost.

Na import sys schrijft sys.exit("Could not open sales.csv") de melding naar de foutuitvoer en stopt het programma met afsluitcode 1. Dit werpt SystemExit op, wat except Exception niet opvangt. Houd exceptieafhandelaars specifiek, zodat een niet-gerelateerde programmeerfout niet ten onrechte als een bestandsprobleem wordt aangeduid.

Een functie moet een signaal geven wanneer ze geen geldig resultaat kan opleveren. raise werpt op dat punt een exceptie op, zodat het ongeldige pad niet kan doorgaan alsof de bewerking is geslaagd.

Controleer vóór het rekenen

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError(f"amount must be positive, got {amount}")
    if amount > balance:
        raise ValueError(f"amount {amount} is more than the balance {balance}")
    return balance - amount

withdraw(100, 30) geeft 70 terug. withdraw(100, 150) werpt een fout op over het saldo; withdraw(100, -5) werpt een fout op over een niet-positief bedrag. Geen van beide mislukte aanroepen bereikt de aftrekking.

Een opgeworpen exceptie volgt dezelfde afhandelingsregels als een ingebouwde fout. Als een overeenkomende exceptieafhandelaar binnen de functie de exceptie opvangt, kan de uitvoering daar doorgaan. Anders verlaat de exceptie de functie en bereikt ze de aanroepende code. Als geen exceptieafhandelaar wordt gevonden, toont Python een stacktrace.

Laat de aanroepende code de reactie kiezen

balance = 100
amount = 150
try:
    balance = withdraw(balance, amount)
except ValueError as err:
    print(f"Cannot withdraw: {err}")

De functie meldt waarom ze geen geld kan opnemen. De aanroepende code besluit een melding te tonen. Omdat de functieaanroep mislukt voordat een waarde wordt teruggegeven, vervangt de toekenning het oude saldo niet door een resultaat. Andere aanroepende code zou om een lager bedrag kunnen vragen of een transactie kunnen annuleren zonder de functie te wijzigen.

Als de functie in plaats daarvan een waarschuwing afdrukt en None teruggeeft, kan de aanroepende code een ongeldige waarde meenemen naar een latere berekening. Door een exceptie op te werpen blijft de fout verbonden met de oorzaak en krijgt de aanroepende code een afzonderlijk foutpad.

Kies een betekenisvol type

Een negatief numeriek bedrag heeft een onaanvaardbare waarde. Een lijst die wordt opgegeven waar een getal nodig is, heeft een ongeschikt type. Het exceptietype maakt deel uit van het gedrag van de functie: aanroepende code gebruikt het om exceptieafhandelaars te kiezen. Kies een type niet alleen omdat het bekend is.

Schrijf een bruikbare melding

Een melding moet benoemen wat werd verwacht en wat werd ontvangen. f"age must be between 0 and 130, got {age}" wijst op een oplossing. Een melding als “fout” geeft geen bruikbare details. Laat de melding over de mislukte bewerking gaan; code die met de gebruiker communiceert, kan de bredere context toevoegen.

raise ValueError("amount must be positive") maakt een exceptie met een melding. raise ValueError is ook geldig en maakt er een zonder melding. Een gewone string is geen exceptie: raise "error" werpt TypeError op omdat opgeworpen objecten moeten afstammen van BaseException.

Soms merkt een functie een fout op, maar kan ze die niet volledig afhandelen. Ze moet mogelijk dezelfde fout doorgeven, omzetten in een bruikbaardere fout of een specifiek programmaprobleem een eigen exceptietype geven.

Werp de huidige fout opnieuw op

def read_text(path):
    try:
        with open(path, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Missing: {path}")
        raise

De kale raise binnen de exceptieafhandelaar werpt de huidige exceptie opnieuw op. Alleen een melding afdrukken zou de exceptieafhandelaar beëindigen en de functie None laten teruggeven; opnieuw opwerpen maakt de mislukte leesactie zichtbaar voor de aanroepende code. Een kale raise heeft een actieve exceptie nodig om opnieuw op te werpen.

Zet om met behoud van de oorzaak

def read_price(row):
    try:
        text = row["price"]
    except KeyError as err:
        raise ValueError("row has no 'price' column") from err
    return float(text)

Een ontbrekende sleutel wordt een ValueError met een melding over de rij. from err legt de oorspronkelijke KeyError vast als directe oorzaak. De stacktrace toont de oorspronkelijke fout, het verband ertussen en de nieuwe fout. De aanroepende code kan het omgezette type afhandelen terwijl de onderliggende oorzaak voor het debuggen beschikbaar blijft.

Deze exceptieafhandelaar is beperkt tot het opzoeken. Een aanwezige waarde zoals "free" mislukt later bij float(text) met een eigen ValueError; die wordt niet ten onrechte als een ontbrekende kolom gemeld.

Definieer een afzonderlijk type

class InsufficientFundsError(ValueError):
    pass

Dit patroon maakt een zelfgedefinieerde exceptieklasse. De naam eindigt volgens afspraak op Error. De naam tussen haakjes is het bovenliggende type, dus deze klasse is een soort ValueError.

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(
            f"balance {balance}, requested {amount}"
        )
    return balance - amount

try:
    withdraw(100, 150)
except InsufficientFundsError as err:
    print("Not enough money:", err)

Het programma drukt “Not enough money: balance 100, requested 150” af. Aanroepende code kan onvoldoende saldo onderscheiden van een andere ongeldige waarde. Als een ValueError-afhandelaar vóór deze specifieke exceptieafhandelaar zou staan, zou het bovenliggende type de exceptie als eerste opvangen.

Kies het bovenliggende type voor de gewenste afhandeling

Als je afleidt van ValueError, kunnen zowel een specifieke exceptieafhandelaar als een bredere afhandelaar voor waardefouten het zelfgedefinieerde type opvangen. Rechtstreeks afleiden van Exception maakt een aparte tak voor gewone fouten, zodat except ValueError de exceptie niet zou opvangen. Een zelfgedefinieerd type is handig wanneer aanroepende code een afzonderlijke reactie nodig heeft; een duidelijk ingebouwd type en een duidelijke melding zijn voldoende wanneer dat niet zo is.