← Back to CoursesStemExpert
StemExpert
Intermediate · Oplossingen · 28. Functies, lijsten en data in Python
StemExpert · Brecht Corbeel · schoolium.me
StemExpert
I28. Functies, lijsten en data in Python — oplossingen
IIntermediate · deel I7 · Programmeren

Oplossingen · hoofdstuk 28Functies, lijsten en data in Python

Eigen functies, lijsten en woordenboeken, en een week meetdata van de klimaatmodule tot een besluit

Uitgewerkte oplossingen bij de 16 opdrachten van het werkboek. Voor de leerkracht, en voor wie zichzelf wil verbeteren nadat hij het eerst zelf probeerde.

5× oefenen6× toepassen5× uitdagen± 346 min
Een week meten levert honderden getallen op; een programma maakt er een besluit van.
Een week meten levert honderden getallen op; een programma maakt er een besluit van.
Voor de leerkrachtDeze pagina bevat de antwoorden. Druk het werkboek af zonder deze pagina.
Oefenen

Oefenen

één stap, direct toepassen
28.1

Twee functies schrijven

Oefenen3Programmeren15 min
Voor het energiebudget reken je met € 0,30 per kWh (hoofdstuk 4).
  1. a
    Schrijf een functie kosten(wh, prijs=0.30) met docstring die de kosten in euro geeft van een energie in Wh.
    def kosten(wh, prijs=0.30):
        """Kosten in euro van een energie in Wh, bij een prijs in euro per kWh."""
        return wh / 1000 * prijs
  2. b
    Wat kost het verbruik van de klimaatmodule (3269,5 Wh per dag) per dag en per jaar, als alles van het net zou komen? Wat per dag bij € 0,25 per kWh?
    Met het programma:
    0.98
    358.01
    0.82
    Per dag € 0,98, per jaar € 358,01; bij € 0,25 per kWh € 0,82 per dag. Let op het argument met zijn naam: kosten(3269.5, prijs=0.25).
  3. c
    Schrijf een functie kelvin(celsius) en test ze met 28,6 °C en met het absolute nulpunt.
    def kelvin(celsius):
        """Temperatuur in kelvin."""
        return celsius + 273.15
    Uitvoer van print(round(kelvin(28.6), 2), kelvin(-273.15)): 301.75 0.0. Het absolute nulpunt geeft 0.0 K.
28.2

print of return?

Oefenen4Analyseren12 min
Een leerling schrijft een functie voor het gemiddelde en gebruikt ze.
def gemiddelde(lijst):
    print(sum(lijst) / len(lijst))


g = gemiddelde([20, 22, 24])
print(round(g, 1))
  1. a
    Voorspel wat er op het scherm komt. Waarom loopt het programma vast?
    Eerst toont de functie 22.0; daarna loopt het vast, want g is None (de functie heeft geen return):
    22.0
    Traceback (most recent call last):
      File "gemiddelde.py", line 6, in <module>
        print(round(g, 1))
              ~~~~~^^^^^^
    TypeError: type NoneType doesn't define __round__ method
    round() kan niets afronden dat None is.
  2. b
    Verbeter de functie met één woord.
    def gemiddelde(lijst):
        return sum(lijst) / len(lijst)
    Nu is g = 22.0 en toont het programma 22.0 één keer (door de print in het hoofdprogramma).
28.3

Indexeren en snijden

Oefenen3Rekenen15 min
De rekenhulp gaf per maand de lichturen die de zonnestroom kan betalen:
lichturen = [9, 14, 16, 16, 16, 16, 16, 16, 16, 16, 11, 8]
  1. a
    Wat geeft Python voor elke uitdrukking?
    uitdrukkinguitkomst
    lichturen[0]9
    lichturen[11]8
    lichturen[-2]11
    lichturen[10:][11, 8]
    lichturen[:3][9, 14, 16]
    len(lichturen)12
    sum(lichturen)170
    lichturen.index(8)11
    lichturen.count(16)8
    sorted(lichturen)[:4][8, 9, 11, 14]
    lichturen[::3][9, 16, 16, 16]
    min(lichturen[3:9])16
  2. b
    Met welke slice krijg je de lichturen van de drie zomermaanden juni, juli en augustus?
    lichturen[5:8]: juni is de zesde maand en heeft dus index 5; de stop 8 (september) doet niet mee.
28.4

Voorspel: lijsten die veranderen

Oefenen4Analyseren12 min
Voorspel wat dit programma toont. Teken eerst de naamkaartjes en de lijsten.
a = [1, 2, 3]
b = a
c = a.copy()
b.append(4)
c[0] = 99
a[1] = a[1] * 10
print(a)
print(b)
print(c)
print(len(a) + len(c))
  1. a
    Schrijf de vier regels uitvoer op.
    Uitvoer:
    [1, 20, 3, 4]
    [1, 20, 3, 4]
    [99, 2, 3]
    7
  2. b
    Waarom verandert c niet mee met a, en b wel?
    b = a hangt een tweede naam aan dezelfde lijst: append via b en a[1] = ... veranderen allebei die ene lijst. c is een kopie van de lijst zoals ze toen was ([1, 2, 3]); daarna veranderde alleen c[0].
28.5

Een woordenboek: de pintabel

Oefenen4Programmeren15 min
De Arduino Mega van de klimaatmodule heeft een vaste pintabel: A0 NTC reservoir, A1 LDR, A2 pH-module, A3 batterijdeler; D2 vlotterschakelaar, D9 pomp (MOSFET).
  1. a
    Maak een woordenboek pinnen met de vier analoge pinnen en toon welk onderdeel op A2 zit.
    pinnen = {"A0": "NTC reservoir", "A1": "LDR", "A2": "pH-module", "A3": "batterijdeler"}
    print(pinnen["A2"])
  2. b
    Voeg D9 en D2 toe en toon alle pinnen gesorteerd op hun naam.
    pinnen["D9"] = "pomp (MOSFET)"
    pinnen["D2"] = "vlotterschakelaar"
    for pin in sorted(pinnen):
        print(pin, pinnen[pin])
    Het volledige programma toont:
    pH-module
    A0 NTC reservoir
    A1 LDR
    A2 pH-module
    A3 batterijdeler
    D2 vlotterschakelaar
    D9 pomp (MOSFET)
    False vrij
    sorted() op een woordenboek sorteert de sleutels, als tekst: daarom komt A0 vóór D2.
  3. c
    Wat gebeurt er bij pinnen["A7"]? Hoe vraag je A7 op zonder foutmelding, met 'vrij' als antwoord?
    Een KeyError: 'A7'. Met pinnen.get("A7", "vrij"), of eerst testen met "A7" in pinnen.
Toepassen

Toepassen

meerdere stappen, in een context
28.6

Trace: het maximum zoeken

Toepassen4Rekenen12 min
Speel de functie grootste() uit het handboek na voor de zonnestroom per dag: [7465, 5105, 1547, 3077, 6949, 7717, 4676].
  1. a
    Vul de trace-tabel in.
    Beste begint op 7465.
    ww > beste?beste daarna
    5105nee7465
    1547nee7465
    3077nee7465
    6949nee7465
    7717ja7717
    4676nee7717
  2. b
    Hoeveel vergelijkingen doet de functie voor een lijst met n waarden? En hoeveel keer verandert beste hier?
    n − 1 vergelijkingen (elke waarde behalve de eerste). Hier verandert beste 1 keer.
  3. c
    Een leerling begint met beste = 0 in plaats van de eerste waarde. Voor welke lijsten gaat dat mis?
    Voor lijsten met alleen negatieve getallen, zoals nachttemperaturen in de winter: het resultaat wordt 0, een waarde die niet in de lijst staat.
28.7

Een CSV-bestand lezen zoals Python het doet

Toepassen4Analyseren15 min
Een stuk uit klimaatmodule_week.csv:
tijdstip,temperatuur_C,vocht_pct,verbruik_Wh,zon_Wh
2026-04-22 06:00,19.2,83,595,25
2026-04-22 09:00,19.7,78,525,314
2026-04-22 12:00,,78,454,611
2026-04-22 15:00,21.1,76,483,484
  1. a
    Hoeveel kolommen en hoeveel gegevensrijen staan hier? Welke meting ontbreekt?
    Vijf kolommen, vier gegevensrijen (onder de kop). De temperatuur van woensdag 22 april om 12 uur ontbreekt.
  2. b
    Schrijf het woordenboek dat csv.DictReader geeft voor de rij van 12 uur.
    {'tijdstip': '2026-04-22 12:00', 'temperatuur_C': '', 'vocht_pct': '78', 'verbruik_Wh': '454', 'zon_Wh': '611'}. Alle waarden zijn tekst; de lege cel wordt de lege tekst ''.
  3. c
    Welk type heeft rij["zon_Wh"]? Wat is rij["zon_Wh"] + rij["zon_Wh"] voor die rij?
    str (tekst). '611' + '611' plakt de teksten aan elkaar: '611611', niet 1222. Eerst int() gebruiken.
  4. d
    Een Belgisch rekenblad bewaart CSV vaak met een puntkomma als scheidingsteken en een decimale komma. Hoe zien de kop en de eerste gegevensregel er dan uit? Wat verander je aan je programma?
    tijdstip;temperatuur_C;vocht_pct;verbruik_Wh;zon_Wh
    2026-04-22 06:00;19,2;83;595;25
    Lezen met csv.DictReader(bestand, delimiter=";"), en getallen omzetten met float(w.replace(",", ".")); eventueel openen met encoding="utf-8-sig". Een rekenblad kan ook de datum anders schrijven (22/04/2026 6:00): kijk het bestand na in een teksteditor voor je de slicing [:10] gebruikt.
28.8

Foutenjacht in een CSV-programma

Toepassen5Analyseren20 min
Dit programma moet het totale verbruik en de gemiddelde temperatuur van de meetweek tonen. Er zitten vier fouten in; drie geven een foutmelding.
# weektotaal.py - totaal verbruik en gemiddelde temperatuur van de week
import csv

verbruik = []
temperaturen = []
with open("klimaatmodule_week.csv", newline="", encoding="utf-8") as bestand:
    for rij in csv.DictReader(bestand):
        verbruik.append(rij["verbruik_Wh"])
        temperaturen.append(float(rij["temperatuur"]))

print("totaal verbruik:", sum(verbruik), "Wh")
print("gemiddelde temperatuur:", sum(temperaturen) / len(verbruik))
  1. a
    Python toont de drie meldingen na elkaar: telkens als je er één verbetert, verschijnt de volgende. Welke fouten zijn het, in volgorde, en hoe verbeter je ze?
    De echte meldingen, telkens na de vorige verbetering:
    Traceback (most recent call last):
      File "weektotaal.py", line 9, in <module>
        temperaturen.append(float(rij["temperatuur"]))
                                  ~~~^^^^^^^^^^^^^^^
    KeyError: 'temperatuur'
    Traceback (most recent call last):
      File "weektotaal.py", line 9, in <module>
        temperaturen.append(float(rij["temperatuur_C"]))
                            ~~~~~^^^^^^^^^^^^^^^^^^^^^^
    ValueError: could not convert string to float: ''
    Traceback (most recent call last):
      File "weektotaal.py", line 12, in <module>
        print("totaal verbruik:", sum(verbruik), "Wh")
                                  ~~~^^^^^^^^^^
    TypeError: unsupported operand type(s) for +: 'int' and 'str'
    1. KeyError: de kolom heet temperatuur_C. 2. ValueError: de lege cel van woensdag; test eerst if rij["temperatuur_C"] != "":. 3. TypeError: sum() kan geen teksten optellen; verbruik.append(int(rij["verbruik_Wh"])).
  2. b
    Na die drie verbeteringen toont het programma een gemiddelde van 21,07 °C. Waarom is dat fout, en wat is het juiste gemiddelde?
    Er wordt gedeeld door len(verbruik) (56 rijen), maar er zijn maar 55 temperaturen: een logische fout zonder melding. Met len(temperaturen):
    totaal verbruik: 14552 Wh
    gemiddelde temperatuur: 21.45
28.9

Gemiddelde temperatuur per dagdeel

Toepassen5Programmeren20 min
De beheerder wil weten hoe warm het gemiddeld is in de nacht (0-6 uur), de ochtend (6-12), de middag (12-18) en de avond (18-24), over de hele week.
  1. a
    Schrijf een programma met een woordenboek dat voor elk dagdeel een lijst temperaturen verzamelt uit klimaatmodule_week.csv, en daarna per dagdeel het gemiddelde en het aantal metingen toont.
    import csv
    
    dagdelen = {"nacht": [], "ochtend": [], "middag": [], "avond": []}
    with open("klimaatmodule_week.csv", newline="", encoding="utf-8") as bestand:
        for rij in csv.DictReader(bestand):
            if rij["temperatuur_C"] == "":
                continue
            uur = int(rij["tijdstip"][11:13])
            if uur < 6:
                deel = "nacht"
            elif uur < 12:
                deel = "ochtend"
            elif uur < 18:
                deel = "middag"
            else:
                deel = "avond"
            dagdelen[deel].append(float(rij["temperatuur_C"]))
    
    for deel, waarden in dagdelen.items():
        print(f"{deel:8} {sum(waarden) / len(waarden):5.1f} graden ({len(waarden)} metingen)")
    Uitvoer:
    nacht     18.4 graden (14 metingen)
    ochtend   21.0 graden (14 metingen)
    middag    25.7 graden (13 metingen)
    avond     21.0 graden (14 metingen)
  2. b
    Waarom heeft de middag één meting minder dan de andere dagdelen?
    De ontbrekende meting van woensdag om 12 uur valt in de middag: die wordt met continue overgeslagen.
28.10

Van blokken naar dagen

Toepassen5Programmeren20 min
Het verbruik staat per blok van drie uur in een lijst van 56 waarden, acht per dag. (De lijst kopieer je uit het bestand, of je leest ze in zoals in inlezen.py.)
  1. a
    Schrijf een functie dagtotalen(waarden, per_dag=8) die telkens acht opeenvolgende waarden optelt en een lijst met zeven dagtotalen teruggeeft. Gebruik slicing.
    def dagtotalen(waarden, per_dag=8):
        """Tel telkens 'per_dag' opeenvolgende waarden op: van blokken van 3 uur naar dagen."""
        totalen = []
        for start in range(0, len(waarden), per_dag):
            totalen.append(sum(waarden[start:start + per_dag]))
        return totalen
  2. b
    Schrijf een functie naar_kwh(lijst_wh) die een nieuwe lijst in kWh geeft (2 decimalen), met een lijstomschrijving.
    def naar_kwh(lijst_wh):
        """Nieuwe lijst met de waarden in kWh, op 2 decimalen."""
        return [round(w / 1000, 2) for w in lijst_wh]
    Met de 56 waarden uit het bestand toont het programma:
    [1663, 2021, 2891, 2517, 1710, 1623, 2127]
    [1.66, 2.02, 2.89, 2.52, 1.71, 1.62, 2.13]
    56 blokken, 7 dagen
  3. c
    Controleer je dagtotalen met de tabel van per_dag.py in het handboek.
    Dezelfde getallen als de kolom verbruik van per_dag.py: 1663, 2021, 2891, 2517, 1710, 1623, 2127 Wh.
28.11

De vochtigheid in een grafiek

Toepassen4Tekenen25 min
De kolom vocht_pct bevat de relatieve luchtvochtigheid. Op woensdag 22 april (de regendag) meet de module: 00 uur: 83 %, 03 uur: 82 %, 06 uur: 83 %, 09 uur: 78 %, 12 uur: 78 %, 15 uur: 76 %, 18 uur: 80 %, 21 uur: 83 %.
  1. a
    Teken de vochtigheid van woensdag op millimeterpapier, met de tijd (uur) horizontaal. Kies een schaal die het papier goed vult.
    Horizontaal 0 tot 24 uur (bv. 1 cm per 2 uur), verticaal 75 tot 85 % (1 cm per %): de waarden schommelen maar tussen 76 en 83 %. Een as die bij 0 begint, zou alles plat maken; zet dan wel duidelijk de getallen bij de as.
  2. b
    Welke regels van grafiek_week.py verander je om de vochtigheid van de hele week te tekenen? Schrijf ze.
    if rij["vocht_pct"] != "":
        dagen.append(i * 3 / 24)
        vocht.append(int(rij["vocht_pct"]))
    ...
    plt.plot(dagen, vocht, marker="o", label="relatieve vochtigheid")
    plt.ylabel("luchtvochtigheid (%)")
    Plus: een lege lijst vocht = [] bovenaan, de hulplijn op 26 weglaten en de titel aanpassen. Zo ziet de week eruit:01234567505560657075808590tijd (dagen sinds maandag 20 april, 0 uur)luchtvochtigheid (%)relatieve vochtigheid
  3. c
    Vergelijk met de temperatuurgrafiek: wat doet de vochtigheid als het warm wordt? Verklaar met wat je weet over waterdamp in lucht (F6).
    Als het warm wordt, daalt de relatieve vochtigheid: warme lucht kan meer waterdamp bevatten, dus dezelfde hoeveelheid damp is een kleiner deel van het maximum. Op de zonnige middagen zakt ze tot rond 60 %; 's nachts stijgt ze tot 85 %. Op de regendag blijft ze hoog, omdat het koeler blijft.
Uitdagen

Uitdagen

transfer, open problemen, leerlijnen combineren
28.12

Habitat: een week in de klimaatmodule

Uitdagen6Habitat50 min
Je analyseert de meetweek als beheerder van de klimaatmodule. Gebruik je eigen programma's (of die van het handboek) op klimaatmodule_week.csv. De module heeft twee LiFePO4-batterijen met samen 2457,6 Wh bruikbare energie (hoofdstuk 20).
  1. a
    Maak de tabel per dag: gemiddelde en hoogste temperatuur, verbruik, zonnestroom en saldo.
    dagT gem (°C)T max (°C)verbruik (Wh)zon (Wh)saldo (Wh)
    ma 20/422,628,116637465+5802
    di 21/421,225,120215105+3084
    wo 22/419,321,128911547-1344
    do 23/420,322,825173077+560
    vr 24/422,227,417106949+5239
    za 25/422,928,616237717+6094
    zo 26/421,325,121274676+2549
  2. b
    Op welke dag moet de batterij bijspringen? Welk deel van de bruikbare batterij-energie kost die dag? Wordt het de dag erna weer goedgemaakt?
    Alleen woensdag: 1344 Wh tekort, dat is 55 % van de 2457,6 Wh. Donderdag levert de zon 560 Wh meer dan de module verbruikt (met het laadrendement van 95 % uit hoofdstuk 16 en 20 ongeveer 532 Wh in de batterij): niet genoeg om alles goed te maken, vrijdag wel ruim.
  3. c
    Hoeveel uur was het warmer dan 26 °C, en wanneer? Stel twee maatregelen voor, telkens met hun gevolg voor het energiebudget.
    18 uur (6 blokken van 3 uur): maandag, vrijdag en zaterdag, telkens tussen 12 en 18 uur. Maatregelen: het kasdak eerder openen of de ventilatoren vroeger laten draaien (enkele wattuur extra, weinig tegenover het overschot op die zonnige dagen); een schaduwdoek (minder warmte, maar ook minder daglicht, dus moeten de lampen minder dimmen en stijgt het verbruik).
  4. d
    Schrijf voor je portfolio een besluit van vijf zinnen: werkt het energiebeheer in deze week, en wat zou je volgende week meten?
    Bijvoorbeeld: in deze aprilweek werkte het energiebeheer: de zonnestroom (36,5 kWh) was ruim het dubbele van het verbruik (14,6 kWh), en de lampen dimden op zonnige dagen, waardoor het dagverbruik daalde tot 1,6 kWh. Alleen de regendag vroeg 1,3 kWh uit de batterij, minder dan een kwart. Op drie middagen werd het warmer dan 26 °C: daar is ventilatie nodig. Volgende week meet ik om de 5 minuten, zodat korte pieken zichtbaar worden, en log ik ook de laadtoestand van de batterij.
Zo wordt dit beoordeeld
TabelAlle zeven dagen, met eenheden; de ontbrekende meting correct behandeld (niet als 0).
BatterijTekort berekend en als deel van 2457,6 Wh uitgedrukt; herstel de dag erna nagegaan.
WarmteWarme blokken correct geteld (per 3 uur); maatregelen concreet, met gevolg voor verbruik.
BesluitOnderbouwd met getallen uit de analyse; een zinvolle volgende meting (bv. per 5 minuten, of de temperatuur van het reservoir).
28.13

Een voortschrijdend gemiddelde

Uitdagen6Programmeren25 min
Metingen schommelen. Een voortschrijdend gemiddelde vervangt elke waarde door het gemiddelde van haar en de volgende n − 1 waarden, zodat de lijn gladder wordt. In E21 wordt dat een digitaal filter.
  1. a
    Schrijf een functie voortschrijdend(waarden, n=3) die een nieuwe lijst met de gemiddelden van telkens n opeenvolgende waarden teruggeeft. Gebruik slicing.
    def voortschrijdend(waarden, n=3):
        """Gemiddelde van telkens n opeenvolgende waarden; de nieuwe lijst is n - 1 korter."""
        uit = []
        for i in range(len(waarden) - n + 1):
            stuk = waarden[i:i + n]
            uit.append(sum(stuk) / n)
        return uit
  2. b
    Pas ze toe op de acht temperaturen van maandag. Hoeveel waarden heeft de nieuwe lijst, en waarom?
    temp = [18.6, 18.5, 19.9, 23.6, 28.0, 28.1, 23.7, 20.1]       # maandag
    glad = voortschrijdend(temp)
    print(len(temp), len(glad))
    print([round(t, 1) for t in glad])
    print(max(temp), round(max(glad), 1))
    8 6
    [19.0, 20.7, 23.8, 26.6, 26.6, 24.0]
    28.1 26.6
    Zes waarden: met n = 3 kan het venster maar op 8 − 3 + 1 = 6 plaatsen beginnen.
  3. c
    Wat gebeurt er met de hoogste waarde? Is dat erg voor de vraag 'hoe lang was het warmer dan 26 °C'?
    Het maximum zakt (van 28,1 naar 26,6 °C): pieken worden afgevlakt. Voor 'hoe lang boven 26 °C' is dat wel erg: je telt dan te weinig warme uren. Een filter kies je dus naar de vraag.
28.14

Onderzoek: hangt het verbruik af van de zon?

Uitdagen7Onderzoeken40 min
De correlatiecoëfficiënt van Pearson meet hoe goed twee reeksen samen op en neer gaan: is een perfect stijgend verband, een perfect dalend, geen lineair verband. Met de gemiddelden en : .
  1. a
    Schrijf een functie correlatie(x, y) volgens de formule, met zip en lijstomschrijvingen.
    def gemiddelde(w):
        return sum(w) / len(w)
    
    
    def correlatie(x, y):
        """Correlatiecoëfficiënt van Pearson van twee even lange lijsten (tussen -1 en 1)."""
        gx, gy = gemiddelde(x), gemiddelde(y)
        teller = sum([(a - gx) * (b - gy) for a, b in zip(x, y)])
        noemer = math.sqrt(sum([(a - gx) ** 2 for a in x]) * sum([(b - gy) ** 2 for b in y]))
        return teller / noemer
  2. b
    Bereken r tussen zonnestroom en verbruik (a) over alle 56 blokken en (b) alleen over de 35 blokken van 6 tot en met 18 uur.
    import csv
    import math
    
    
    def gemiddelde(w):
        return sum(w) / len(w)
    
    
    def correlatie(x, y):
        """Correlatiecoëfficiënt van Pearson van twee even lange lijsten (tussen -1 en 1)."""
        gx, gy = gemiddelde(x), gemiddelde(y)
        teller = sum([(a - gx) * (b - gy) for a, b in zip(x, y)])
        noemer = math.sqrt(sum([(a - gx) ** 2 for a in x]) * sum([(b - gy) ** 2 for b in y]))
        return teller / noemer
    
    
    alle_zon, alle_verbruik = [], []
    licht_zon, licht_verbruik = [], []
    with open("klimaatmodule_week.csv", newline="", encoding="utf-8") as bestand:
        for rij in csv.DictReader(bestand):
            z, v = int(rij["zon_Wh"]), int(rij["verbruik_Wh"])
            alle_zon.append(z)
            alle_verbruik.append(v)
            if 6 <= int(rij["tijdstip"][11:13]) <= 18:
                licht_zon.append(z)
                licht_verbruik.append(v)
    
    print("alle 56 blokken:", round(correlatie(alle_zon, alle_verbruik), 2))
    print("35 blokken met lampen aan:", round(correlatie(licht_zon, licht_verbruik), 2))
    Uitvoer:
    alle 56 blokken: -0.19
    35 blokken met lampen aan: -0.98
  3. c
    Verklaar het verschil tussen (a) en (b). Wat leert dit over het vergelijken van groepen die op een andere manier verschillen?
    Over de 35 blokken met lampen is r = −0,98: een sterk dalend verband, want de lampen dimmen bij daglicht. Over alle 56 blokken is r = −0,19, veel zwakker: 's nachts is de zonnestroom 0 én het verbruik laag (lampen uit), wat in de puntenwolk een groep linksonder geeft die tegen het dalende verband in werkt. Dag en nacht is een derde factor die beide reeksen beïnvloedt. Vergelijk dus alleen blokken die verder gelijk zijn (zoals in een eerlijke proef, hoofdstuk 2), en bewijs een oorzaak met kennis van het systeem, niet met r alleen (hoofdstuk 39).
Zo wordt dit beoordeeld
FunctieFormule correct, met docstring; getest op een eenvoudig geval (bv. x = y geeft 1).
BerekeningBeide r-waarden correct, de selectie van de blokken gemotiveerd.
InterpretatieHet verschil verklaard met een derde factor (dag en nacht); correlatie niet als bewijs gebracht.
28.15

Ontwerp: het logbestand van de klimaatmodule

Uitdagen6Ontwerpen30 min
In hoofdstuk 30 bouw je een datalogger die de metingen van de klimaatmodule op een SD-kaart schrijft. Ontwerp nu al het CSV-formaat, zodat je analyseprogramma's er meteen mee werken.
  1. a
    Welke kolommen neem je op (minstens zes), met welke naam en eenheid? Welke kolom is de sleutel om te groeperen?
    Bijvoorbeeld: tijdstip, temperatuur_lucht_C, temperatuur_reservoir_C, vocht_pct, licht_lux, pH, EC_mS_cm, CO2_ppm, verbruik_Wh, zon_Wh, laadtoestand_pct. Groeperen doe je op het tijdstip (datum en uur uit de tekst).
  2. b
    Kies het tijdformaat, het decimaalteken, het scheidingsteken en wat er in een cel staat als een sensor faalt. Motiveer.
    Tijd als '2026-04-20 06:00' (jaar eerst: sorteert vanzelf juist) en liefst in UTC of met de tijdzone erbij, want bij de overgang naar zomertijd komt een uur twee keer voor. Decimale punt en komma als scheiding: zo leest Python het zonder omzetten. Een lege cel bij een sensorfout, nooit 0 of −127: een lege cel valt op, een verzonnen getal niet.
  3. c
    De logger schrijft elke minuut een regel van ongeveer 60 tekens. Hoe groot wordt het bestand na een jaar? Kies: één bestand per dag, per week of per jaar?
    Een jaar heeft 525 600 minuten; 525 600 × 60 tekens ≈ 31,5 miljoen bytes, ongeveer 32 MB. Dat past makkelijk op een SD-kaart, maar één groot bestand is lastig om te openen en gaat helemaal verloren als het beschadigd raakt. Eén bestand per dag (±86 kB, zoals 2026-04-20.csv) is een goede keuze.
Zo wordt dit beoordeeld
KolommenRelevante grootheden (temperatuur lucht en reservoir, vocht, licht, pH, EC, CO₂, verbruik, zon, laadtoestand), eenheid in de naam, zonder spaties.
FormaatISO-tijd (jjjj-mm-dd uu:mm, met tijdzone of UTC), decimale punt en komma als scheiding, lege cel bij een fout; gemotiveerd.
OmvangJuiste orde van grootte en een onderbouwde keuze van de bestandsgrootte.
28.16

Debat: rekenblad of Python?

Uitdagen5Argumenteren20 min
Een klasgenoot vindt Python overdreven voor de meetweek: 'In een rekenblad heb ik dat gemiddelde in tien seconden, en ik zie meteen alle getallen.' Denk aan het verhaal van de vijf ontbrekende landen.
  1. a
    Geef twee sterke argumenten voor een rekenblad en twee voor Python, elk met een voorbeeld uit dit hoofdstuk.
    Rekenblad: je ziet alle data meteen, en een grafiek of een som is snel gemaakt, zonder iets te installeren. Python: elke stap staat zichtbaar in de code en is voor een nieuwe week opnieuw te draaien (per_dag.py werkt voor elk bestand in hetzelfde formaat), en ontbrekende waarden en honderdduizenden rijen gaan even vlot als 56.
  2. b
    Voor welke taak kies jij wat? Welke controle doe je in beide gevallen om een fout als die van de vijf landen te vermijden?
    Rekenblad voor een snelle blik op een klein bestand; Python voor een analyse die je herhaalt, deelt of in een verslag verantwoordt. Controle in beide: tel hoeveel waarden er echt meetellen (len(), of de functie AANTAL), vergelijk met wat je verwacht (8 per dag, 56 per week), en laat iemand anders de berekening overdoen.