Tot nu toe leerde je heel wat mogelijkheden van de programmeertaal Python. Misschien ben je buiten onze lessen zelf al aan de slag gegaan met je kennis. Super, want programmeren leer je door het veel te doen. Maar een goed programma is ook gedocumenteerd en goed getest. Dat leer je in onze achtste les.

Hier vind je les 1 van de Python-cursus.

Verkeerde gewoontes leer je niet snel af, daarom dat we nu even een stapje terugdoen en nadenken over wat ‘goede code’ is. Na deze les kun je code produceren die niet alleen goed gedocumenteerd en goed getest is, maar weet je ook hoe je informatie over Python-modules opzoekt met de helpfunctie.

Code documenteren met commentaar

Tot nu toe schreven we onze code zonder enige vorm van documentatie. Als je met anderen samenwerkt aan een programma, is het belangrijk dat je die documenteert, zodat je anderen duidelijk maakt wat je met je code bedoelt. Maar ook als je helemaal alleen programmeert, is documentatie geen overbodige luxe. Zo begrijp je je eigen code nog als je er over een jaar opnieuw naar kijkt.

De eerste manier om je code te documenteren is met commentaar. Alles na het #-teken (hekje) tot het einde van de regel (behalve als het hekje ín een string voorkomt) is commentaar en wordt door Python genegeerd. Op die manier kun je een uitleg voor jezelf of anderen schrijven. Als je bijvoorbeeld in de functie is_palindroom van deel 6 in de war raakt met die indexen, schrijf er dan gerust wat commentaar bij:

if letters[0] != letters[-1]: # Als de eerste en de laatste letter verschillen

Het getuigt van goede stijl om twee spaties tussen je code en het erna volgende commentaarteken te houden en één spatie tussen het commentaarteken en je commentaar. Overigens kun je ook commentaar op een nieuwe losstaande regel beginnen, dan spreken we van een commentaarregel:

# Als de eerste en de laatste letter verschillen

if letters[0] != letters[-1]:

Het is de gewoonte om een commentaarregel te zetten op de regel vóór de regel waarover hij gaat.

Code uitcommentariëren

Code documenteren met docstrings

Commentaar gebruik je om te documenteren waarom je iets doet en hoe je het doet, maar voor gebruikers van je code is vooral belangrijk wat die doet. Om dat te documenteren, gebruik je docstrings: in het begin van elke module, elke klasse en elke functie of methode geef je met een string tussen drie dubbele aanhalingstekens aan wat het stuk code doet.

Zo zouden we onze klassen uit de vorige les als volgt kunnen documenteren:

"""Klassen om met tweedimensionale, driedimensionale en hogerdimensionale punten te werken."""

import math

class Point:
"""Stelt een punt voor in een willekeurig aantal dimensies."""

def __init__(self, *coordinates):
"""Initialiseer het punt met de opgegeven coördinaten."""
self.coordinates = list(coordinates)

def __repr__(self):
"""Geef een leesbare voorstelling van het punt terug."""
return 'Point(' + ', '.join(str(co) for co in self.coordinates) + ')'

def displacement(self, other_point):
"""Geef het verschil terug tussen dit punt en een ander punt.

De overeenkomstige coördinaten worden van elkaar afgetrokken.

Voorbeeld: het verschil tussen Point(1, 4, 2) en Point(3, 4, 1) is gelijk aan Point(2, 0, -1).
"""
return Point(*[a-b for a, b in zip(other_point.coordinates, self.coordinates)])

def distance(self, other_point):
"""Geef de Euclidische afstand terug tussen dit punt en een ander punt."""
relative_position = self.displacement(other_point)
return math.sqrt(sum(i**2 for i in relative_position.coordinates))
class Point2D(Point):
"""Stelt een tweedimensionaal punt voor."""

def __init__(self, x=0, y=0):
"""Initialiseer het punt met de opgegeven x- en y-coördinaten."""
Point.__init__(self, x, y)
self.x = x
self.y = y
def get_x(self):

"""De x-coördinaat van het punt."""
return self.coordinates[0]

def set_x(self, x):
self.coordinates[0] = x

x = property(get_x, set_x)

def get_y(self):
"""De y-coördinaat van het punt."""
return self.coordinates[1]

def set_y(self, y):
self.coordinates[1] = y

y = property(get_y, set_y)

Je ziet hier dat documentatie niet lang hoeft te zijn. De docstrings bij de module, de klassen en bij de meeste methodes zijn maar één regel lang.

De moeilijkste methode om te begrijpen is displacement en daarom is het zinvol om daar wat meer uitleg bij te geven. Bij een docstring van meer dan één regel raden we aan om na de eerste regel een lege regel te houden, en om de drie dubbele aanhalingstekens op het einde op een nieuwe regel te zetten. Dat geeft wat meer overzicht.

Merk op: bij onze eigenschappen x en y van de klasse Point2D documenteren we alleen de methode die de waarde van de eigenschap opvraagt. Zo toont de ingebouwde helpfunctie van Python (die we op het einde van deze les bespreken) deze documentatie bij de eigenschap.

Interactieve voorbeelden in docstrings

We hebben in de docstring van de methode displacement al een voorbeeld van het gebruik van de methode gegeven als documentatie. Maar dat bleef nogal informeel. We kunnen die documentatie ook in de vorm van echte Python-code doen die je in een interactieve terminalsessie zou kunnen invoeren. Zo kan de gebruiker die de documentatie leest, onmiddellijk de voorbeelden kopiëren uit de documentatie en plakken in de Python-interpreter om ze uit te proberen. Dat zou voor de methode displacement er dan als volgt uitzien:

def displacement(self, other_point):"""Geef het verschil terug tussen dit punt en een ander punt.

De overeenkomstige coördinaten worden van elkaar afgetrokken.

>>> Point(1, 4, 2).displacement(Point(3, 4, 1))Point(2, 0, -1)"""return Point(*[a-b for a, b in zip(other_point.coordinates, self.coordinates)])

Je ziet hier dat je de code na de >>> exact in een Python-terminalsessie zou kunnen invoeren en dan ook het resultaat zou krijgen dat hier staat. In feite hebben we wat hier staat gewoon eerst in de terminal van Thonny ingevoerd en dan samen met de uitvoer gekopieerd en hier in de docstring geplakt.

Code testen met doctest

Stel dat je nu ooit de code van de methode displacement aanpast omdat je denkt een verbetering te zien, maar er een fout in maakt, waardoor het resultaat verkeerd is. Dan kun je dat testen door de voorbeeldcode in je docstring uit te voeren in een Python-terminalsessie. Voer je de code uit en komt het resultaat niet overeen met de uitvoer in de docstring, dan klopt je code niet meer.

Maar zouden we die test niet automatisch kunnen doen? Jazeker! Python kent daarvoor de module doctest, die automatisch alle docstrings in een module kan testen op interactieve voorbeelden. Dat voer je als volgt uit in een Linux- of macOS-terminal of de Windows Opdrachtprompt:

python3 -m doctest -v point.py

Hierbij is point.py de naam van de module met je code erin. Je krijgt dan als uitvoer de tests die doctest in je docstrings ziet en het resultaat. Als je het alleen wilt zien als een test een fout vindt, haal dan de optie -v weg. Stel dat je bijvoorbeeld per ongeluk de * vergeten bent in de methode displacement om de lijst naar een willekeurig aantal argumenten voor de klasse Point om te zetten, dan zal doctest die fout opmerken met de volgende melding:

**********************************************************************

File "point.py", line 21, in point.Point.displacement

Failed example:

Point(1, 4, 2).displacement(Point(3, 4, 1))

Expected:

Point(2, 0, -1)

Got:

Point([2, 0, -1])

**********************************************************************

1 items had failures:

1 of

***Test Failed*** 1 failures.

Een goede manier van programmeren is dan ook dat je je code zoveel mogelijk documenteert met docstrings en daarin ook interactieve voorbeelden opneemt, die je na elke wijziging van je code automatisch test met doctest om je ervan te verzekeren dat je geen fouten hebt geïntroduceerd.

De helpfunctie gebruiken

Als je code is gedocumenteerd, hoef je niet je codebestand in Thonny te openen om de documentatie te bekijken. Je kunt dit in een interactieve Python-sessie, bijvoorbeeld in Thonny, maar ook in een Python-sessie in een Linux- of macOS-terminal of de Windows Opdrachtprompt. Het enige wat je hoeft te doen, is de functie help op te roepen met de naam van de module, klasse, functie of methode waarvoor je de documentatie wilt zien. Bijvoorbeeld in Thonny:

>>> help(Point.displacement)

Help on function displacement in module __main__:

displacement(self, other_point)

Geef het verschil terug tussen dit punt en een ander punt.

De overeenkomstige coördinaten worden van elkaar afgetrokken.

>>> Point(1, 4, 2).displacement(Point(3, 4, 1))

Point(2, 0, -1)

Overigens zijn alle standaardmodules van Python uitgebreid gedocumenteerd met docstrings. Daardoor kun je van alle modules, klassen, functies en methodes heel eenvoudig documentatie opvragen in je Python-terminalsessie. Let er wel op dat je een module eerst dient te importeren voordat je er documentatie van kunt opvragen met help.

Samenvatting

In deze les ging het minder over het programmeren zelf, maar over het documenteren en testen van je Python-programma’s en het uitzoeken van meer informatie over de standaard Python-modules of je eigen modules. Hoe complexer je programma’s zijn, hoe belangrijker dit soort zaken rond je code zijn. Maak er daarom een gewoonte van om documentatie en tests niet als een nabeschouwing te zien, maar al tijdens de ontwikkeling van je programma in je code te integreren. In de volgende les maken we het nog complexer: dan gaan we extra modules installeren die niet in Python ingebouwd zijn.

Opdracht 1

Uitwerking opdracht 1

Opdracht 2

Uitwerking opdracht 2

Cheatsheet

Je hebt vorige week al een aantal keer de leukste filmpjes vanaf de CES voorbij zien komen, gemaakt door Martin Verschoor van Power Unlimited Tech. De CES is inmiddels voorbij (tot volgend jaar, Las Vegas!), maar als toetje hebben we nog vijf bijzondere TikToks voor je verzameld.

Ook leuk: CES 2026: 4 opvallende dingen gespot door Martin van Power Unlimited Tech

Vechtende robots

Vliegend naar je werk met de jetbike

Vloeistof-speakers (en ja, dat ziet er gaaf uit)

Tip voor de Vierdaagse: extra steun voor je benen

Gewone fiets? Zo maak je er een e-bike van

Frustraties over een trage pc of ongewenste advertenties? Grote kans dat de standaard Windows-instellingen de boosdoener zijn. Met drie simpele ingrepen optimaliseer je direct de snelheid, privacy en veiligheid van je systeem. Wij zetten de belangrijkste aanpassingen op een rij, zodat je direct weer vlot en zorgeloos aan de slag kunt!

Of je nu net een gloednieuwe laptop uit de doos haalt of al jaren op dezelfde vertrouwde desktop werkt, de standaardinstellingen van Windows zijn zelden optimaal. Microsoft kiest vaak voor opties die hun eigen diensten promoten in plaats van jouw gebruiksgemak centraal te stellen. Gelukkig kun je met een paar gerichte ingrepen direct winst behalen. Pas deze drie essentiële instellingen aan voor meer privacy, snelheid en overzicht.

Schakel onnodige opstart-apps uit

Niets is zo frustrerend als een computer die er minutenlang over doet om startklaar te zijn. De grootste boosdoener hiervoor is vaak een overdaad aan programma's die automatisch opstarten zodra je de pc aanzet. Veel applicaties, van Spotify tot samenwerkingstools als Microsoft Teams, nestelen zich tijdens de installatie ongevraagd in je opstartproces. Dat vreet direct aan je systeemgeheugen en vertraagt de opstarttijd aanzienlijk.

Je lost dit eenvoudig op door naar de instellingen van Windows te navigeren en te zoeken naar de optie Opstart-apps. Hier zie je een duidelijk overzicht van alle software die met Windows mee start, inclusief de impact die elk programma heeft op de prestaties. Loop kritisch door deze lijst heen. Programma's die je niet dagelijks direct na het inloggen nodig hebt, kun je zonder risico uitschakelen door het schuifje om te zetten. Je verwijdert de software hiermee niet; je voorkomt alleen dat ze op de achtergrond draaien zonder dat je erom gevraagd hebt. Je pc zal hierdoor merkbaar vlotter reageren.

Weg met die advertenties en suggesties!

Windows is in de loop der jaren steeds meer veranderd in een platform waarop Microsoft eigen en gesponsorde diensten probeert te verkopen. Dat uit zich in zogenaamde 'suggesties' in je Startmenu, op je vergrendelingsscherm en zelfs in de Verkenner. Voor de meeste gebruikers voelt dat – terecht – als ongewenste reclame binnen een besturingssysteem waarvoor al betaald is. Het zorgt bovendien voor ruis en leidt af van waar je eigenlijk mee bezig bent.

Om deze stroom aan prikkels te stoppen, duik je in het menu Persoonlijke instellingen. Bij de instellingen voor het Startmenu en het Vergrendelingsscherm vind je opties die verwijzen naar het tonen van suggesties, tips of leuke weetjes. Vink deze opties uit om een schonere, rustigere interface te krijgen. Vergeet ook niet bij de privacy-instellingen de optie uit te zetten die Windows toestaat om je Instellingen-app te gebruiken voor het tonen van voorgestelde inhoud. Het resultaat is een professionelere werkomgeving die doet wat hij moet doen, zonder je continu te proberen te verleiden tot extra klikken.

Maak bestandsextensies zichtbaar

Een van de meest riskante standaardinstellingen in Windows is het verbergen van bestandsextensies voor bekende bestandstypen. Standaard zie je alleen de naam van een bestand, bijvoorbeeld 'factuur', maar niet of het een .pdf, .docx of een .exe is. Cybercriminelen maken daar dankbaar gebruik van door virussen te vermommen als onschuldige documenten. Een bestand dat 'foto.jpg.exe' heet, wordt door Windows dan getoond als 'foto.jpg', waardoor je denkt een afbeelding te openen terwijl je in werkelijkheid schadelijke software installeert.

Je kunt dit veiligheidsrisico direct verhelpen via de Bestandsverkenner. Zoek in de menubalk naar de optie Weergeven en navigeer vervolgens naar de instellingen voor weergeven. Hier vind je een optie genaamd Extensies voor bestandsnamen. Zorg dat deze optie aangevinkt staat. Hoewel het in het begin even wennen kan zijn om achter elk bestand een punt en drie of vier letters te zien staan, geeft het je volledige controle en inzicht. Je ziet nu in één oogopslag met wat voor type bestand je écht te maken hebt, en dat verkleint de kans op een succesvolle malware-infectie drastisch.