Handboek · hoofdstuk 28Functies, lijsten en data in Python

In hoofdstuk 27 schreef je programma's van boven naar onder, met een variabele voor elke waarde. Voor een week meetdata werkt dat niet meer: 56 rijen met elk vijf waarden zijn 280 getallen. Drie nieuwe bouwstenen lossen dat op. Een functie geeft een berekening een naam, zodat je ze telkens opnieuw kan gebruiken. Een lijst bewaart veel waarden onder één naam. Een woordenboek koppelt een naam (een sleutel) aan een waarde. Samen met de csv-module om bestanden te lezen en matplotlib om te tekenen, heb je alles om van meetdata een besluit te maken.

Je gebruikte al veel functies: print(), round(), len(). Een eigen functie maak je met def:

def energie(vermogen, uren):
    """Energie in Wh van een toestel met dit vermogen (W) dat zoveel uren aanstaat."""
    return vermogen * uren

De eerste regel is de kop: het woord def, de naam, de parameters tussen haakjes en een dubbelepunt. Daaronder het ingesprongen lichaam. De tekst tussen drie aanhalingstekens is de docstring: wat de functie doet, met eenheden. Met return geeft de functie een waarde terug en stopt ze.

Een def voert nog niets uit; het maakt de functie alleen klaar. Pas bij een aanroep zoals energie(190, 16) draait het lichaam: de argumenten 190 en 16 worden de waarden van de parameters vermogen en uren, en de aanroep zelf krijgt de waarde 3040.

Het verschil tussen print en return is de klassieke valkuil bij functies. print toont iets op het scherm; return geeft een waarde terug aan de code die de functie aanriep. Een functie zonder return geeft de speciale waarde None ('niets') terug.

def gemiddelde_print(lijst):
    print(sum(lijst) / len(lijst))


def gemiddelde(lijst):
    return sum(lijst) / len(lijst)


a = gemiddelde_print([20, 22, 24])
b = gemiddelde([20, 22, 24])
print("a:", a, "- b:", b)

22.0
a: None - b: 22.0

De eerste functie toont 22.0, maar a is None: met a kan je niet verder rekenen. Rekenfuncties geven dus terug; alleen het hoofdprogramma toont.

Standaardwaarden. Een parameter mag een standaardwaarde krijgen, zoals decimalen=1. Laat je dat argument weg, dan geldt de standaardwaarde. Argumenten mag je ook met hun naam meegeven, in elke volgorde:

def komma(x, decimalen=1):
    return f"{x:.{decimalen}f}".replace(".", ",")


print(komma(3269.5))
print(komma(3269.5, 3))
print(komma(decimalen=0, x=3269.5))

3269,5
3269,500
3270

Lokale variabelen. Een variabele die je in een functie maakt, bestaat alleen tijdens die aanroep. Zo kunnen twee functies elk hun eigen totaal hebben zonder elkaar te storen. Wat een functie nodig heeft, geef je mee als argument; wat ze oplevert, geeft ze terug.

Een lijst zet je tussen vierkante haken, met komma's tussen de elementen. Elk element heeft een index: zijn plaats, vanaf 0. Met een negatieve index tel je van achteren: [-1] is het laatste element. Hier de hoogste temperatuur van elke dag van de meetweek:

>>> maxima = [28.1, 25.1, 21.1, 22.8, 27.4, 28.6, 25.1]
>>> maxima[0]
28.1
>>> maxima[5]
28.6
>>> maxima[-1]
25.1
>>> len(maxima)
7
>>> 28.6 in maxima
True
>>> maxima.index(28.6)
5

Een lijst kan groeien en veranderen. Je begint vaak met een lege lijst en voegt met append telkens een meting toe; een element vervang je via zijn index:

>>> metingen = []
>>> metingen.append(19.4)
>>> metingen.append(21.0)
>>> metingen
[19.4, 21.0]
>>> metingen[0] = 19.6
>>> metingen
[19.6, 21.0]
>>> len(metingen)
2

Een lijst mag waarden van elk type bevatten, ook teksten: dagen = ["ma", "di", ...]. Twee lijsten met evenveel elementen (dagen en maxima) horen vaak samen: het element met index 5 in de ene lijst hoort bij index 5 in de andere.

Met lijst[a:b] neem je een stuk (een slice): van index a tot, maar niet met, index b. Laat je a weg, dan begin je vooraan; laat je b weg, dan loop je tot het einde. Een derde getal is de stap, zoals bij range(). Het resultaat is een nieuwe lijst; de oude blijft ongewijzigd.

>>> maxima = [28.1, 25.1, 21.1, 22.8, 27.4, 28.6, 25.1]
>>> maxima[1:4]
[25.1, 21.1, 22.8]
>>> maxima[:3]
[28.1, 25.1, 21.1]
>>> maxima[5:]
[28.6, 25.1]
>>> maxima[-2:]
[28.6, 25.1]
>>> maxima[::2]
[28.1, 21.1, 27.4, 25.1]

Een tekst (str) is ook een reeks, van tekens. Daarom werkt slicing ook op tekst, en dat is handig bij datalogbestanden, waar de datum en het uur samen in één tekst staan:

>>> tijdstip = "2026-04-20 06:00"
>>> tijdstip[:10]
'2026-04-20'
>>> tijdstip[11:13]
'06'
>>> int(tijdstip[11:13])
6
>>> len(tijdstip)
16

Met tijdstip[:10] groepeer je straks de metingen per dag, met int(tijdstip[11:13]) per uur.

Een for-lus loopt niet alleen over range(), maar over elke lijst: de lusvariabele krijgt elke ronde het volgende element. Vier patronen komen steeds terug. Ophopen: een totaal vóór de lus, in de lus erbij tellen. Tellen of filteren: in de lus een if. Twee lijsten tegelijk: met zip(), en met enumerate() krijg je er een volgnummer bij. Een nieuwe lijst maken uit een oude: met append in een lus, of korter met een lijstomschrijving (list comprehension) tussen vierkante haken.

# patronen.py - vier manieren om over een lijst te lopen
dagen = ["ma", "di", "wo", "do", "vr", "za", "zo"]
maxima = [28.1, 25.1, 21.1, 22.8, 27.4, 28.6, 25.1]

totaal = 0                               # 1. ophopen
for t in maxima:
    totaal = totaal + t
print("som:", round(totaal, 1))

aantal = 0                               # 2. tellen met een voorwaarde
for t in maxima:
    if t > 26:
        aantal = aantal + 1
print("dagen boven 26 graden:", aantal)

for dag, t in zip(dagen, maxima):        # 3. twee lijsten tegelijk
    if t < 23:
        print("koele dag:", dag, t)

for nummer, dag in enumerate(dagen[:3], start=1):
    print(nummer, dag)

kelvin = [round(t + 273.15, 2) for t in maxima]     # 4. een nieuwe lijst
print(kelvin)

som: 178.2
dagen boven 26 graden: 3
koele dag: wo 21.1
koele dag: do 22.8
1 ma
2 di
3 wo
[301.25, 298.25, 294.25, 295.95, 300.55, 301.75, 298.25]

De lijstomschrijving [round(t + 273.15, 2) for t in maxima] leest als 'voor elke t in maxima: t in kelvin'. Met een if erachter filter je: [t for t in maxima if t > 26] geeft alleen de warme dagen.

In een lijst zoek je een waarde op met een getal (de index). In een woordenboek (dictionary, type dict) zoek je op met een sleutel, meestal een tekst. Je schrijft het tussen accolades, met paren sleutel: waarde. Een voorbeeld is de pintabel van de Arduino Mega van de klimaatmodule:

>>> pinnen = {"A0": "NTC reservoir", "A1": "LDR", "A2": "pH-module", "A3": "batterijdeler"}
>>> pinnen["A2"]
'pH-module'
>>> pinnen["D9"] = "pomp (MOSFET)"
>>> len(pinnen)
5
>>> "A5" in pinnen
False
>>> pinnen.get("A5", "vrij")
'vrij'

Over alle paren loop je met items():

for pin, onderdeel in pinnen.items():
    print(pin, "->", onderdeel)

A0 -> NTC reservoir
A1 -> LDR
A2 -> pH-module
A3 -> batterijdeler
D9 -> pomp (MOSFET)

Een woordenboek is ook de handigste manier om metingen per groep te verzamelen: de sleutel is de datum (of het dagdeel), de waarde een lijst met de metingen van die groep. Dat doe je verderop met de meetweek.

Een CSV-bestand (comma-separated values) is een tabel als gewone tekst: één rij per regel, de kolommen gescheiden door komma's. De eerste regel is meestal de kop met de namen van de kolommen. Elk rekenblad kan CSV openen en bewaren, elke datalogger kan het schrijven, en je leest het met een teksteditor. Daarom is het het meest gebruikte formaat voor meetdata.

Het bestand van de klimaatmodule heeft vijf kolommen: het tijdstip (datum en uur, zoals '2026-04-20 06:00'), de temperatuur in °C en de vochtigheid in % (gemiddelden over de drie uur die op dat tijdstip beginnen), en het verbruik en de zonnestroom in Wh in diezelfde drie uur. De eenheid staat in de naam van de kolom: temperatuur_C, verbruik_Wh. Een lege cel betekent: geen meting.

Met lijsten, woordenboeken en functies komen er nieuwe foutmeldingen bij. Lees ze zoals in hoofdstuk 27: van onder naar boven. Nieuw is dat een traceback door een functie heen loopt: dan staan er twee plaatsen, de aanroep en de regel in de functie. De echte meldingen van Python 3.13:

IndexError. Drie elementen hebben de indexen 0, 1 en 2. De laatste is temperaturen[-1] of temperaturen[len(temperaturen) - 1].

temperaturen = [19.4, 21.0, 23.5]
print(temperaturen[3])

Traceback (most recent call last):
  File "fouten.py", line 2, in <module>
    print(temperaturen[3])
          ~~~~~~~~~~~~^^^
IndexError: list index out of range

KeyError. De sleutel bestaat niet. Test eerst met in, of gebruik pinnen.get("A2", "vrij"). Bij een CSV-bestand is het vaak een tikfout in de kolomnaam.

pinnen = {"A0": "NTC", "A1": "LDR"}
print(pinnen["A2"])

Traceback (most recent call last):
  File "fouten.py", line 2, in <module>
    print(pinnen["A2"])
          ~~~~~~^^^^^^
KeyError: 'A2'

AttributeError. Een lijst kent geen push (dat is JavaScript); in Python is het append.

metingen = [19.4, 21.0]
metingen.push(23.5)

Traceback (most recent call last):
  File "fouten.py", line 2, in <module>
    metingen.push(23.5)
    ^^^^^^^^^^^^^
AttributeError: 'list' object has no attribute 'push'

TypeError. De functie heeft twee parameters en krijgt maar één argument. Geef ze allebei mee, of geef de parameter een standaardwaarde.

def energie(vermogen, uren):
    return vermogen * uren


print(energie(190))

Traceback (most recent call last):
  File "fouten.py", line 5, in <module>
    print(energie(190))
          ~~~~~~~^^^^^
TypeError: energie() missing 1 required positional argument: 'uren'

ZeroDivisionError. De traceback heeft nu twee niveaus: regel 5 riep de functie aan, en in de functie (regel 2) liep het mis. Een lege lijst heeft lengte 0. Zeg in de docstring dat de lijst niet leeg mag zijn, of test het: if len(lijst) == 0: return None.

def gemiddelde(lijst):
    return sum(lijst) / len(lijst)


print(gemiddelde([]))

Traceback (most recent call last):
  File "fouten.py", line 5, in <module>
    print(gemiddelde([]))
          ~~~~~~~~~~^^^^
  File "fouten.py", line 2, in gemiddelde
    return sum(lijst) / len(lijst)
           ~~~~~~~~~~~^~~~~~~~~~~~
ZeroDivisionError: division by zero

>>> a = [19.4, 21.0]
>>> b = a
>>> b.append(23.5)
>>> a
[19.4, 21.0, 23.5]
>>> c = a.copy()
>>> c.append(99)
>>> a
[19.4, 21.0, 23.5]