PF/4 - Modular Python

PF

MODULAR PYTHON

04 2025-2026

We breiden onze kennis van loops verder uit, leren hoe libraries ons werk makkelijker, hoe we code kunnen testen met unit tests en hoe we modules importeren en exporteren om code te hergebruiken.

MODULAR PYTHON

LOOPS EXTENDED

LOOPS EXTENDED

Stel je voor dat je een gebruiker om een getal vraagt, maar je wilt zeker weten dat het groter is dan 5. In plaats van dit meerdere keren handmatig te herhalen zoals hieronder

gebruik je beter een while-loop om dit dynamisch te doen.

n = int(input("Geef me een nummer boven 5? "))

if n < 5:
    n = int(input("Geef me een nummer boven 5? "))
    if n < 5:
        n = int(input("Geef me een nummer boven 5? "))

while True:
    n = int(input("Geef me een nummer boven 5? "))
    if n > 5:
        break

WHILE

LOOPS EXTENDED

Met een continue en break kun je invoer elegant controleren. Stel dat je enkel positieve getallen wilt.

Of als je iets x keer wilt uitvoeren, zoals het printen van een naam:

while True:
    n = int(input("Geef me een positief nummer? "))
    if n < 0:
        continue  # Negatief? Vraag opnieuw
    else:
        break     # Positief? Stop de loop

while True:
    n = int(input("Hoeveel keer moet ik Milan printen? "))
    if n > 0:
        break

for _ in range(n):
    print("Milan")

CONTINUE - BREAK

LOOPS EXTENDED

Je code opsplitsen in functies is niet alleen een goede programmeerstijl maar zo houd je alles netjes en herbruikbaar.

def main():
    number = get_number()
    blub(number)

def get_number():
    while True:
        n = int(input("Hoeveel keer moet ik blub printen? "))
        if n > 0:
            return n

def blub(n):
    for _ in range(n):
        print("Blub")

main()

FUNCTIONS

LOOPS EXTENDED

Wanneer je met lijsten werkt, kun je direct over de items lopen, of je kunt ook indexen gebruiken als je de positie nodig hebt

students = ["Francisco", "Nanine", "Valerie", "Xander"]

for i in range(len(students)):
    print(i + 1, ":", students[i])

Uitvoer

1 : Francisco
2 : Nanine
3 : Valerie
4 : Xander

LISTS & INDEX

LOOPS EXTENDED

We kunnen ook expliciet zeggen dat iets geen waarde heeft. Dit gebeurd door het keyword 'None'. Hier gebruiken we dit om te zeggen dat een functie niets bruikbaars kon teruggeven.

def check_numbers(n):
    if n < 0:
        return None
    return n

print(check_numbers(3))   # Geeft 3 terug
print(check_numbers(-1))  # Geeft None terug

NONE

LOOPS EXTENDED

Wat als de gebruiker tekst typt in plaats van een getal? Dan krijg je normaal een fout! Maar met try / except kun je dit voorkomen:

def get_int():
    while True:
        try:
            x = int(input("What is x? "))
        except ValueError:
            # Je kan hier een foutmelding geven
            # print("Dat is geen geldig getal.")
            pass  # Negeer de fout en probeer opnieuw
        else:
            break
    return x

def main():
    x = get_int()
    print(f"x is {x}")

main()

ERROR HANDLING

MODULAR PYTHON

LIBRARIES

LIBRARIES

"A library is a collection of prewritten code, created either by others or by yourself, that can be imported and reused in a program. Instead of rewriting the same functionality multiple times, developers can use libraries to access ready-made functions and tools directly"

LIBRARY

LIBRARIES

In Python wordt een bibliotheek een module genoemd. Een module is een bestand met Python-code dat functies, variabelen en soms ook klassen bevat, die je eenvoudig in andere programma’s kunt hergebruiken.

Python heeft standaard al veel ingebouwde modules. We zullen even een paar modules onder de loep nemen.

random: genereert willekeurige getallen of keuzes.

statistics: berekent statistische waarden zoals gemiddelde of mediaan.

datetime: werkt met datums en tijden.

Meer modules ontdekken en wat ze kunnen? Ga dan naar de documentatie

MODULES

LIBRARIES

Om een module te importeren in je script doen we dit via het keyword import

Laten we een simpel programma schrijven waar we een muntje opgooien met een 50/50 kans.

import random

import random

# List met mogelijke uitkomsten
choices = ["Kop", "Munt"]

# Willekeurig een uitkomst kiezen
result = random.choice(choices)

# Resultaat weergeven
print("Uitkomst van de muntworp:", result)

RANDOM

LIBRARIES

In plaats van random.choice kunnen we nu enkel choice schrijven.

from random import choice

coin = choice(["Kop", "Munt"])
print(coin)

Vroeger moesten programmeurs opletten dat functies en variabelen geen naamconflicten veroorzaakten (bijvoorbeeld een eigen functie choice tegenover de geïmporteerde choice). Met from-import kun je specifieke functies laden, waardoor de code overzichtelijker blijft, vooral in kleine scripts.

In Python kun je niet alleen een hele module importeren, maar ook specifieke functies. Dit doen we met het sleutelwoord from.

FROM ... IMPORT

LIBRARIES

Dit kan handig zijn voor een raadspel, waarin een speler moet raden welk getal de computer heeft gekozen.

import random

number = random.randint(1, 10)
print(number)

import random

cards = ["Koning", "Koningin", "Boer", "Aas"]
random.shuffle(cards)

print("Geschudde kaarten:", cards)

Met randint() krijg je een willekeurig getal tussen a en b (beide inclusief)

De functie random.shuffle(seq) neemt een lijst en schudt de elementen door elkaar. Dit werkt zoals het schudden van een kaartspel.

RANDOM

LIBRARIES

import statistics

average = statistics.mean([90, 80])
print("Gemiddelde:", average)

Gemiddelde: 85

De statistics-module in Python helpt bij het uitvoeren van wiskundige berekeningen op datasets. Dit is handig voor data-analyse, wetenschappelijke berekeningen en machine learning.

Uitvoer

STATISTICS

LIBRARIES

from datetime import datetime

now = datetime.now()
print("Huidige datum en tijd:", now)

Huidige datum en tijd: 2025-08-30 14:23:45.678912

De datetime-module in Python helpt bij het werken met datums en tijden. Dit is handig voor het bijhouden van tijdstempels, het berekenen van tijdsverschillen , etc...

Uitvoer

DATETIME

LIBRARIES

Functie	Beschrijving	Voorbeeld
random.choice()	Kiest willekeurig een element uit een lijst	random.choice(["a", "b"])
random.randint(a,b)	Genereert een willekeurig geheel getal tussen a en b	random.randint(1, 10)
random.shuffle()	Schudt de elementen in een list door elkaar.	random.shuffle(kaarten)

Functie	Beschrijving	Voorbeeld
statistics.mean(data)	Bereken het gemiddelde van een lijst	statistics.mean([10, 20, 30])
statistics.median(data)	Bereken de mediaan (middelste waarde)	statistics.median([10, 20, 30])
statistics.stdev(data)	Bereken de standaardafwijking	statistics.stdev([10, 20, 30, 40])

Functie	Beschrijving	Voorbeeld
datetime.now()	Huidige datum en tijd ophalen.	`datetime.now()`
date.today()	Alleen de huidige datum ophalen.	date.today()
datetime(y, m, d)	Een specifieke datum aanmaken	datetime(2025, 12, 31)

OVERVIEW

LIBRARIES

OPDRACHT

Je gaat een Python-programma maken dat vier temperatuurmetingen van vandaag genereert en een kleine statistiek berekent.

Genereer vier metingen
- Gebruik random om vier temperaturen tussen -5°C en 35°C te genereren.
Datum toevoegen
- Gebruik datetime om vandaag als datum te gebruiken.
Bereken statistieken
- Gebruik statistics om het gemiddelde, minimum en maximum van de vier metingen te berekenen.
Print alles netjes

Datum: 2025-10-19
Metingen: [12, 18, 15, 8]
Gemiddelde: 13.25
Min: 8
Max: 18

MODULAR PYTHON

PACKAGES

PACKAGES

Met pakketten kun je extra functionaliteit aan Python toevoegen. Ze zijn gemaakt door anderen en beschikbaar op pypi.org. Installeren doe je eenvoudig met pip, de standaard package manager van Python.

We focussen nu op twee pakketten: cowsay en requests. Lees altijd de documentatie om te zien welke functies beschikbaar zijn.

cowsay: een knipoog naar een klassiek programma dat tekst toont met ASCII-art.

requests: een eenvoudige manier om HTTP-verzoeken te doen (later uitgebreider bij API’s).

PACKAGES

We zullen nu gebruik maken van een externe package 'cowsay' om ASCII-art te laten verschijnen.

Open de terminal en voer het volgende command uit.

COWSAY

pip install cowsay

Importeer nu het pakket in het script. Maak een bestand moo.py aan.

import cowsay
import sys

if len(sys.argv) == 2:
    cowsay.cow("Hallo, " + sys.argv[1])

sys.argv is een ingebouwde module die we kunnen gebruiken om argumenten mee te geven aan de uitvoering van ons bestand. Alles wat je na de naam van het bestand meegeeft zit in de sys.argv list.

Voer nu het script uit met een argument.

python moo.py Jan

PACKAGES

Ga nu zelf eens naar de documenatie van cowsay (pip docs) en test verschillende 'figuren' uit.

HAVE FUN

PACKAGES

Met de 'requests'-package kunnen we gegevens van het internet ophalen via een API.

REQUESTS

Een API (Application Programming Interface) is een systeem waarmee we gegevens van derden kunnen opvragen en gebruiken in onze eigen programma's. De meeste API’s zijn tegenwoordig beschikbaar via het internet.

Installeer de package requests door het volgende command uit te voeren.

pip install requests

PACKAGES

Maak een nieuw bestand songs.py en voeg volgende code toe.

REQUESTS

import requests
import sys
import json

if len(sys.argv) != 2:
    sys.exit("Gebruik: python songs.py <zoekterm>")

response = requests.get(f"https://itunes.apple.com/search?entity=song
&limit=1&term={sys.argv[1]}")

# Print de ruwe JSON-data
print(json.dumps(response.json(), indent=2))

# Toon alleen de tracknaam
o = response.json()
for result in o['results']:
    print("Tracknaam:", result['trackName'])

Proficiat, Je hebt je eigen spotify gemaakt!

PACKAGES

Nu gebruiken we code van anderen maar we kunnen evengoed onze eigen code hergebruiken als een package.

MY PACKAGE

Maak een nieuw bestand greetings.py en plaats volgende code.

def main():
    hello("wereld")
    goodbye("wereld")

def hello(name):
    print(f"Hallo, {name}")

def goodbye(name):
    print(f"Tot ziens, {name}")

main()

PACKAGES

We maken nu een ander bestand say.py waar we onze vorige code importeren.

MY PACKAGE

from greetings import hello
import sys

if len(sys.argv) == 2:
    hello(sys.argv[1])

Voer nu het script uit in de terminal.

python say.py <naam>

Wat gebeurd er? Wat zou de oorzaak hier van kunnen zijn? Bespreek.

PACKAGES

Wanneer we de functie 'hello' uitvoeren in say.py, wordt de hele code in greetings.py gelezen en uitgevoerd, inclusief de aanroep van main(). Dit kunnen we oplossen door 1 regel code.

NAME == MAIN

def main():
    hello("wereld")
    goodbye("wereld")

def hello(name):
    print(f"Hallo, {name}")

def goodbye(name):
    print(f"Tot ziens, {name}")

if __name__ == "__main__": #nieuwe regel
    main()

Pas greetings.py aan

Hiermee zorgen we dat main() alleen wordt uitgevoerd als het script direct wordt uitgevoerd, en niet als het wordt geïmporteerd.

PACKAGES

Met een virtual environment blijven pakketten per project gescheiden, voorkom je conflicten en kunnen anderen eenvoudig de juiste versies installeren.

VIRTUAL ENVIRONMENT

python -m venv venv
venv\Scripts\activate

We maken een virtual environment aan in de terminal.

Dit is voor Windows

python3 -m venv venv
source venv/bin/activate

Dit is voor Mac/Linux

Na deze commando’s verschijnt in de terminal (venv), wat aangeeft dat je je in de virtuele omgeving bevindt.

PACKAGES

Nu kunnen we eenvoudig pakketten installeren zonder het hele systeem te beïnvloeden. Daarnaast kunnen we een lijst van geïnstalleerde pakketten opslaan, zodat anderen die later gemakkelijk kunnen gebruiken.

VIRTUAL ENVIRONMENT

pip freeze > requirements.txt

We maken een virtual environment aan in de terminal.

pip install -r requirements.txt

Hiermee wordt een bestand requirements.txt gemaakt met een lijst van alle packages. Dit maakt het makkelijk voor anderen om dezelfde packages te installeren.

MODULAR PYTHON

UNIT TESTING

UNIT TESTING

DEFINITION

"Unit testing is the practice of automating the verification of your code. Instead of manually providing input, searching for errors, fixing them, and rerunning the program, unit tests automatically check whether the code behaves as expected, providing faster feedback and making it easier to detect and fix issues."

UNIT TESTING

CALCULATOR

We maken een eenvoudig programma waar we berekening kunnen testen en zullen deze door een aantal tests laten lopen.

Maak een bestand calculator.py aan en voer volgende code in

Handmatig testen van calculator.py is niet systematisch en kan fouten missen. Tijd voor unit tests.

def main():
     x = int(input("Wat is x? "))
     print("x in het kwadraat is", square(x))

def square(number):
     return number * number

if __name__ == "__main__":
     main()

UNIT TESTING

TEST CALCULATOR

Laten we een nieuw bestand maken, test_calculator.py, om onze calculator.py te testen. Testbestanden krijgen vaak de prefix test_. Hierin testen we bijvoorbeeld de functie square():

Maak een bestand test_calculator.py aan en voer volgende code in

from calculator import square

def main():
     test_square()

def test_square():
     if square(2) != 4:
        print("2 in het kwadraat was niet 4")
     if square(3) != 9:
        print("3 in het kwadraat was niet 9")

if __name__ == "__main__":
     main()

UNIT TESTING

TEST CALCULATOR

Wanneer we dit bestand uitvoeren krijgen we geen output wat op zich een goed teken is. Stel je nu voor dat we een fout hadden gemaakt in onze functie square().

Introduceer volgende fout in calculator.py

def square(number):
     return number + number  # Fout: moet vermenigvuldigen in plaats van optellen

Als we nu test_calculator.py uitvoeren, krijgen we als resultaat dat 3 in het kwadraat niet 9 was. Dit is de eerste aanwijzing dat er iets mis is, en dit benadrukt waarom we veel tests moeten uitvoeren.

UNIT TESTING

ASSERT

De vorige methode werkt, maar is omslachtig. Met assert kunnen we controleren of een uitdrukking waar is; anders genereert Python automatisch een AssertionError.

Verander test_square() naar onderstaande code.

def test_square():
     assert square(2) == 4
     assert square(3) == 9
     assert square(-2) == 4
     assert square(-3) == 9
     assert square(0) == 0

Bij het uitvoeren van het script worden fouten nu automatisch weergegeven. Bij een mislukking ziet de output er bijvoorbeeld zo uit:

AssertionError: assert 6 ==

UNIT TESTING

PYTEST

Hoewel assert handig is, is de foutoutput soms moeilijk te lezen. Met de populaire Python-bibliotheek pytest kunnen we tests automatisch uitvoeren en resultaten overzichtelijk weergeven.

Om pytest te gebruiken, installeer je volgende package.

pip install pytest

Dit zal een veel nettere output geven waarin je precies kunt zien welke tests zijn mislukt en waarom.

Na installatie kunnen we onze tests uitvoeren met pytest i.p.v python

py -m pytest test_calculator.py

UNIT TESTING

HELLO.PY

Tests zijn niet enkel voor getallen maar kunnen voor elke soort datatypes gedaan worden. We nemen een voorbeeld waar we een naam vragen.

Plaats volgende code in een bestand genaamd hello.py

def main():
    name = input("Wat is je naam? ")
    hello(name)

def hello(to="world"):
    return f"Hello, {to}"

if __name__ == "__main__":
    main()

UNIT TESTING

ASSERT HELLO

Het is handing om onze tests te verdelen in meerdere functies om het overzichtelijker te maken.

Maak een bestand test_hello.py aan en voer volgende code in.

from hello import hello

def test_hello():
    assert hello("Niels") == "Hello, Niels"
    assert hello() == "Hello, world"

Na het uitvoeren van de test zie je snel waar een fout kan zitten. Bij meerdere tests kun je ze in een tests/-map plaatsen; pytest detecteert dan automatisch bestanden die beginnen met test_ of eindigen op _test.py.