Modules en debuggen in Python: fouten zoeken en testen

Een module bevat Pythoncode die een ander programma kan hergebruiken. De meeste modules zijn .py-bestanden. De standaardbibliotheek wordt met Python meegeleverd; code van derden moet je afzonderlijk installeren. Een pakket groepeert verwante modules, meestal in een map.

Stem de aanroep af op de import

Een import maakt namen aan in je programma. De vorm die je kiest, bepaalt hoe je de geïmporteerde code aanroept.

Puntnotatie betekent dat je een naam opzoekt binnen een module of object. In math.sqrt(16) vindt Python sqrt binnen math en roept die functie aan met 16. Het resultaat is 4.0. De constante math.pi heeft geen aanroephaakjes nodig, omdat het een waarde is en geen functie.

Na import math werpt alleen sqrt(16) de exceptie NameError op: het programma heeft een naam voor de module, maar geen afzonderlijke naam voor sqrt. Na alleen from math import sqrt werpt de omgekeerde fout, math.sqrt(16), ook NameError op omdat math niet is gebonden. Een alias geeft de geïmporteerde binding een andere naam dan de gebruikelijke: import statistics as stats maakt stats aan, niet beide namen.

Voer dezelfde berekening op twee manieren uit

Een rechthoekige driehoek heeft zijden van 3 en 4. Kwadrateer eerst de zijden en tel ze op; neem daarna de vierkantswortel.

import math

length = math.sqrt(3**2 + 4**2)
print(length)  # 5.0

De expressie binnen de aanroep wordt 9 + 16, daarna 25; sqrt geeft 5.0 terug. Met from math import sqrt schrijf je in plaats daarvan length = sqrt(3**2 + 4**2). Het modulevoorvoegsel maakt de herkomst van een functie zichtbaar en houdt de andere namen uit de naamruimte van je programma. De binding math zelf kan nog steeds een eerdere variabele met de naam math vervangen.

Houd namen duidelijk

Vermijd from math import *. Deze import met een jokerteken haalt openbare namen naar je programma zonder ze afzonderlijk te noemen. Zo verandert e = 5, gevolgd door die import, e in 2.718281828459045. Een import die er los van lijkt te staan kan daardoor een latere berekening veranderen. PEP 8 beveelt expliciete imports aan en plaatst imports bovenaan, met één module per regel: eerst de standaardbibliotheek, daarna pakketten van derden en ten slotte je eigen modules.

Python voert de code op moduleniveau van een module uit bij de eerste import tijdens een programma-uitvoering. Latere imports hergebruiken de geladen module; ze starten die niet opnieuw.

Kies de oplossing aan de hand van de fout

Voer in de interactieve shell import math uit en daarna dir(math) om de namen weer te geven. Voer help(math.sqrt) uit om de documentatie van een functie te lezen. De officiële Pythonbibliotheekdocumentatie legt de argumenten en het resultaat uit.

De standaardbibliotheek biedt geteste hulpmiddelen voor berekeningen en simulaties. Bij de keuze van een functie ga je uit van het resultaat dat je nodig hebt: een geheel aantal, een afgeronde meetwaarde, één willekeurig element of een lijst in een andere volgorde.

Afronden heeft meerdere betekenissen

Na import math geeft math.sqrt(16) het zwevendekommagetal 4.0 terug. math.pi en math.e leveren de constanten 3.141592653589793 en 2.718281828459045. math.factorial(5) vermenigvuldigt de gehele getallen van 1 tot en met 5 en geeft 120 terug.

Voor 23 vierkante meter muur en 10 vierkante meter per verfblik geeft de deling 2.3 blikken. Als je hele blikken koopt, heb je math.ceil(23 / 10) nodig, wat 3 teruggeeft. round(2.3) geeft 2 en levert te weinig verf op.

De ingebouwde functie round() hoef je niet te importeren. Voor een cirkel met straal 2 geeft round(math.pi * 2 ** 2, 2) de waarde 12.57. Afronden verandert de precisie van een getal; dat is iets anders dan genoeg hele verpakkingen kopen.

Controleer domeinen en vergelijkingen van zwevendekommagetallen

math.sqrt(-1) werpt ValueError op omdat er voor die invoer geen reële vierkantswortel bestaat. Ook bij berekende zwevendekommagetallen moet je opletten: door de binaire opslag is 0.1 + 0.2 == 0.3 gelijk aan False. math.isclose(0.1 + 0.2, 0.3) is True; gebruik dit om berekende zwevendekommagetallen bij benadering te vergelijken.

Kies de willekeurige bewerking

De module random gebruikt een algoritme om pseudowillekeurige resultaten te maken.

Zet random.shuffle(cards) op een eigen regel. Als je het resultaat weer aan cards toekent, verlies je de binding met de lijst doordat je die vervangt door None. Posities trekken is ook iets anders dan verschillende waarden vereisen: random.sample([1, 1], 2) geeft [1, 1] terug.

Voer een herhaalbare simulatie uit

import random

sevens = 0
for _ in range(1000):
    if random.randint(1, 6) + random.randint(1, 6) == 7:
        sevens += 1
print(sevens)

Zes van de 36 even waarschijnlijke paren hebben als som 7, dus het aantal ligt meestal rond 167, maar verschilt per uitvoering. Om bij het debuggen een reeks te reproduceren, roep je random.seed(42) aan voordat je de waarden genereert, met dezelfde Pythonversie en aanroepvolgorde. Gebruik voor wachtwoorden of beveiligingstokens secrets.

Vind andere veelgebruikte hulpmiddelen

statistics.mean([2, 4, 9]) geeft 5 terug; statistics.median([2, 4, 9]) geeft 4 terug. datetime.date.today() geeft de datum van vandaag. Na import sys bevat sys.argv de scriptnaam gevolgd door de argumenten: als je python greet.py Ada uitvoert, levert dat ['greet.py', 'Ada'] op.

Een functie is gemakkelijker te hergebruiken als die in een module met een duidelijke taak staat. Een ander programma kan die functie importeren en een test kan haar controleren zonder iemand te vragen de hele toepassing uit te voeren.

Scheid de functie van de aanroepende code

Sla deze code op als geometry.py:

"""Calculations for simple shapes."""
import math

def circle_area(radius):
    """Return the area of a circle with the given radius."""
    return math.pi * radius ** 2

Sla in dezelfde map deze aanroepende code op als main.py:

import geometry

print(geometry.circle_area(2))

Voer python main.py uit. Python vindt geometry, maakt de functie aan en daarna voert de aanroepende code die functie uit. Het afgedrukte resultaat is 12.566370614359172. Importeer zonder de uitgang .py. Een geldige modulenaam gebruikt letters, cijfers en underscores, met een geldig eerste teken; my_tools.py werkt met import my_tools, terwijl import my-tools ongeldige syntaxis is.

De strings aan het begin van de module en de functie zijn docstrings. Ze beschrijven het doel van de code en verschijnen in help(geometry) en help(geometry.circle_area).

Begrijp wat een import uitvoert

Bij de eerste import voert Python de instructies op moduleniveau op volgorde uit. Een def-instructie maakt een functie aan; ze voert de inhoud van die functie niet uit. Een onbeschermde print(circle_area(2)) onderaan geometry.py zou echter tijdens het importeren iets afdrukken.

Dat neveneffect is van belang wanneer een module invoervragen of een programmalus bevat. Een test die alleen circle_area nodig heeft, zou niet het programma hoeven te starten en de invoervragen hoeven te beantwoorden.

Bescherm de start en houd de functie beschikbaar

Voeg dit onder de herbruikbare functie toe in geometry.py:

def main():
    print(circle_area(2))

if __name__ == "__main__":
    main()

Python stelt __name__ in voor elke module. Bij directe uitvoering, python geometry.py, krijgt die variabele de waarde "__main__", waardoor de voorwaarde waar is en main() wordt aangeroepen. Bij het importeren van geometry krijgt ze de waarde "geometry", zodat Python de aanroep overslaat. De definities boven de voorwaarde blijven in beide gevallen beschikbaar.

Plaats circle_area zelf niet binnen de voorwaarde. Wie de module importeert, heeft die definitie ook nodig als de startvoorwaarde onwaar is. De voorwaarde bepaalt wanneer de toepassing start; ze verhindert niet dat Python de module laadt.

Weet waar Python zoekt

Python controleert ingebouwde modules zoals sys en daarna op volgorde de mappen in sys.path. Normaal gesproken staat de map van het uitgevoerde script als eerste op dat pad, gevolgd door mappen van de standaardbibliotheek en geïnstalleerde pakketten. Je eigen bestanden naast het uitgevoerde script bewaren is een eenvoudige indeling voor een beginnersproject. Een module buiten het zoekpad kan niet met een gewone import worden gevonden.

Door deze volgorde kan ook een bibliotheekmodule worden verborgen. Als je je programma opslaat als random.py, kan de instructie import random je eigen bestand laden in plaats van de bibliotheek. Een latere random.randint(1, 6) werpt dan AttributeError op. Geef het bestand een andere naam, bijvoorbeeld dice.py; Python 3.13 en later kunnen in de foutmelding een aanwijzing geven om het bestand te hernoemen.

Een geladen module wordt binnen dezelfde uitvoering hergebruikt. Als je in een interactieve shell het bestand bewerkt en opnieuw importeert, blijft de geladen versie behouden. Start de shell opnieuw voordat je je wijzigingen test.

Pakketten van derden voegen code toe die niet met Python wordt meegeleverd. PyPI, de Python Package Index op https://pypi.org, biedt onderdak aan deze projecten. pip downloadt en installeert ze voor een specifieke Pythoninstallatie.

Gebruik eerst de terminal en daarna Python

Een terminalopdracht en een Pythoninstructie horen op verschillende plaatsen thuis. De prompt >>> betekent dat je in de interactieve shell van Python zit. Als je daar pip install requests invoert, krijg je SyntaxError; Python kan dit niet als instructie lezen.

Voer in je terminal uit:

python -m pip install cowsay

Zet dit vervolgens in een Pythonprogramma:

import cowsay

cowsay.cow("Hello, Ada")

Het programma drukt een koe van teksttekens af naast een tekstballon met het bericht. De installatie maakt het pakket beschikbaar; de import maakt de binding ervoor aan in het programma.

Stem pip af op je interpreter

Met de vorm -m pip vraag je de genoemde Python om zijn eigen pip uit te voeren. Gebruik de opdracht waarmee je je programma’s start: vaak python3 op macOS of Linux, of py op Windows.

python3 -m pip install cowsay
python3 game.py

Beide regels kiezen dezelfde Pythonopdracht. Als een installatie meldt dat die is geslaagd, maar een script nog steeds ModuleNotFoundError opwerpt, vergelijk dan de Python waarmee is geïnstalleerd met die waarmee het script wordt uitgevoerd. Een editor kan een andere interpreter hebben geselecteerd dan je terminal. Gebruik de pip van de geselecteerde interpreter voordat je de import wijzigt.

Bekijk en onderhoud een installatie

Een exacte versie is nuttig als je het gedrag van die specifieke uitgave nodig hebt. Met show kun je controleren welke locatie pip daadwerkelijk heeft gewijzigd.

Controleer de naam in de documentatie

De distributienaam die je voor pip typt kan verschillen van de importnaam. Installeer beautifulsoup4 en gebruik daarna import bs4; installeer Pillow en gebruik daarna import PIL. De importnaam herhaaldelijk installeren is geen nuttige oplossing wanneer de documentatie een andere distributie noemt.

De standaardbibliotheek van Python, inclusief math, random en unittest, wordt al met Python meegeleverd. Deze modules vereisen geen installatie met pip.

Houd rekening met een beheerde installatie

Sommige besturingssystemen en pakketbeheerders beschermen hun Python met een foutmelding externally-managed-environment. Dit betekent dat een directe installatie wordt geblokkeerd om de beheerde installatie consistent te houden. Gebruik een virtuele omgeving, een afzonderlijke map met Python en pakketten voor het project. Forceer de installatie niet met sudo pip install.

Iedereen kan op PyPI publiceren. Controleer vóór de installatie de exacte spelling en lees de pagina en documentatie van het project. Namen die erop lijken kunnen pogingen tot typosquatting zijn. Geef de voorkeur aan gevestigde, onderhouden pakketten en installeer de pakketten die je programma echt nodig heeft.

Een stacktrace vertelt welke aanroepen actief waren toen een niet-afgehandelde exceptie het programma stopte. Hij geeft zowel een startpunt om te lezen als een weg terug naar de waarde die de fout veroorzaakte.

Begin bij de laatste regel

Bekijk dit volledige programma in scores.py:

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

def report(scores):
    avg = average(scores)
    print(f"Average: {avg:.1f}")

report([])

De laatste regel van het foutverslag is ZeroDivisionError: division by zero. Die noemt het exceptietype en beschrijft de mislukte bewerking. Begin daar en lees dan omhoog naar de codelocatie direct erboven.

Een vereenvoudigde stacktrace, zonder expressiemarkeringen, is:

Traceback (most recent call last):
  File "scores.py", line 8, in <module>
    report([])
  File "scores.py", line 5, in report
    avg = average(scores)
  File "scores.py", line 2, in average
    return sum(values) / len(values)
ZeroDivisionError: division by zero

Lees elk frame als een actieve aanroep

Een aanroepframe geeft het bestand, het regelnummer en de functie, gevolgd door de bijbehorende code. in <module> betekent code op moduleniveau. De oudste aanroep staat bovenaan; de meest recente staat onderaan. Als je van onderen leest, keer je die volgorde om zodat je kunt vragen wat er misging voordat je vraagt hoe de uitvoering daar terechtkwam.

1. Regel 2 deelt door len(values). Wil die deler nul zijn, dan moet values leeg zijn.
2. Regel 5 roept average(scores) aan, dus onderzoek de scores die report doorgaf.
3. Regel 8 geeft [] door, de lege lijst. Dat verklaart hoe de deler nul in de berekening terechtkwam.

De regel waar de fout optreedt en de oorzaak hangen samen, maar kunnen op verschillende plaatsen staan. Als je de deling vervangt zonder te bepalen wat een lege lijst moet betekenen, verberg je de ontwerpvraag. Ofwel moet de aanroepende code een lege lijst vermijden, ofwel moet voor de functie zijn vastgelegd wat ze bij lege invoer doet.

Gebruik markeringen zonder afhankelijk te zijn van hun exacte vorm

Python 3.11 en later kunnen de markeringen ^ en ~ toevoegen om het deel van een expressie te tonen waar de fout optreedt. Ze helpen wanneer één regel meerdere bewerkingen bevat. De precieze markering verschilt per versie, maar de aanroeplocaties en exceptiemelding geven nog steeds de leesvolgorde aan.

Een stacktrace kan frames uit de standaardbibliotheek of een geïnstalleerd pakket bevatten. Zoek het onderste frame in je eigen code en onderzoek de argumenten die je daar doorgaf. Een bibliotheekframe is een aanwijzing voor de locatie; het is geen bewijs dat de bibliotheek de programmeerfout bevat.

Herken een syntaxisfoutmelding

Een syntaxisfout in het script dat wordt gestart, verhindert dat script te draaien. Python meldt een bestand, regel, markering en melding zonder de gebruikelijke kop van een stacktrace. Zo ontbreekt bij if True de dubbele punt; bij total = sum([1, 2, 3] blijft een haakje open.

De gemarkeerde plaats is waar Python merkte dat het de code niet kon ontleden. Als die regel geldig lijkt, controleer dan de vorige regel op een niet-gesloten aanhalingsteken of haakje. Er is geen keten van aanroepen tijdens de uitvoering om te volgen wanneer het startscript niet is uitgevoerd.

Een gewone uitvoering stopt bij de eerste niet-afgehandelde exceptie. Herstel dat probleem en voer het programma opnieuw uit om eventuele latere problemen zichtbaar te maken.

De naam van een fout bakent de zoektocht af en de melding geeft meer details over de betrokken waarden. Een programma kan ook onjuist zijn zonder een exceptie op te werpen, dus de verwachte uitvoer controleren blijft onderdeel van het zoeken naar fouten.

Maak onderscheid tussen drie soorten problemen

IndentationError is een soort SyntaxError. Functie-inhoud moet zijn ingesprongen; een ontbrekend ingesprongen blok stopt de code voordat die wordt uitgevoerd. Controleer ook op niet-gesloten aanhalingstekens of haakjes en verkeerd gespelde gereserveerde woorden.

Lees namen en typen zorgvuldig

Een NameError betekent dat het programma op dat punt een naam niet kent. In prnt("hi") is de bedoelde ingebouwde functie print. Een naam kan ook vóór de toekenning zijn gebruikt, of een import kan ontbreken.

Een TypeError betekent dat een bewerking een ongeschikt type kreeg of een aanroep het verkeerde aantal argumenten kreeg. "Age: " + 30 mengt een string en een geheel getal. Schrijf "Age: " + str(30) of f"Age: {30}". Als area de parameters w en h nodig heeft, is area(3) ook een TypeError, ditmaal vanwege een ontbrekend argument.

De melding maakt onderscheid tussen deze oorzaken. In can only concatenate str (not "int") to str noemt Python de typen die bij elkaar kwamen. Na age = input("Age: ") is age tekst. age + 1 mislukt; bij invoer van een geheel getal voert int(age) + 1 een berekening uit.

Een ValueError betekent dat het type van de invoer wordt geaccepteerd, maar de waarde ongeschikt is. int("12.5") krijgt een string, een geaccepteerd invoertype, maar de tekst stelt geen geheel getal in de vereiste vorm voor. math.sqrt(-1) is nog een ongeschikte waarde voor een berekening met reële getallen.

Controleer posities, sleutels en attributen

Delen door nul mislukt ook met // en %. Een ontbrekende lijstpositie opzoeken is iets anders dan een ontbrekende dictionarysleutel opzoeken, ook al vraag je in beide gevallen om iets wat ontbreekt.

Ontdek een resultaat dat aannemelijk lijkt

def total_price(prices):
    total = 0
    for i in range(1, len(prices)):
        total += prices[i]
    return total

Voor [4, 6, 10] geeft dit 16 terug in plaats van 20. Er is geen exceptie: de indexen 1 en 2 bestaan, dus elke bewerking is toegestaan. De lus begint te laat en slaat index 0 over. De fout wordt zichtbaar wanneer je de uitvoer vergelijkt met het bedoelde totaal.

Zoek bij een onbekende exceptie het type en de algemene melding op in de officiële Pythondocumentatie. Laat je eigen paden en invoerwaarden weg uit een zoekopdracht; die verklaren zelden de algemene regel.

Een programmeerfout is een verschil tussen bedoeld en werkelijk gedrag. Bij het debuggen zoek en herstel je de oorzaak. Tijdens een zinvolle debugsessie zet je een waarneming om in een toetsbare verklaring en wijzig je de code op basis van bewijs.

Zorg dat de fout zich herhaalt

Leg specifieke invoer en het resultaat dat die oplevert vast. Gebruik voor de prijsfunctie die haar lus bij index 1 begint [4, 6, 10]. Het verwachte totaal is 20; het werkelijke totaal is 16. Met deze concrete waarden kun je controleren of elk onderzoek nog steeds over dezelfde programmeerfout gaat.

Het verschil is 4 en het werkelijke resultaat is gelijk aan 6 + 10. Een specifieke hypothese is dat de eerste prijs wordt overgeslagen. Die hypothese voorspelt iets wat je kunt onderzoeken: de lus zal index 0 nooit bezoeken.

Volg zes stappen

1. Reproduceer: zoek invoer die de programmeerfout steeds laat zien.
2. Vermeld het verwachte en werkelijke resultaat: bereken het verwachte resultaat onafhankelijk.
3. Vorm een hypothese: noem een mogelijke oorzaak en het voorspelde gedrag.
4. Toets de hypothese: onderzoek waarden met uitvoerinstructies, een uitvoeringstabel of een debugger.
5. Herstel de oorzaak: maak één gerichte wijziging.
6. Test opnieuw: voer de invoer waarbij het misging en eerder werkende gevallen uit.

Druk de index binnen de lus af. Voor deze invoer zijn de enige indexen 1 en 2, wat de voorspelling bevestigt. Als je range bij 0 laat beginnen, herstel je het overgeslagen element. Door direct over de prijzen te itereren hoef je geen index meer bij te houden:

def total_price(prices):
    total = 0
    for price in prices:
        total += price
    return total

De herstelde functie geeft 20 terug voor [4, 6, 10], 5 voor [5] en 0 voor []. Het geval met één element is nuttig omdat de foutieve lus daarvoor eerder 0 teruggaf.

Als je 4 bij elk antwoord optelt, herstel je het waargenomen totaal maar blijft de oorzaak bestaan. Voor [5] zou die noodoplossing 4 teruggeven; het ontbrekende bedrag hangt af van de invoer. Controleer of een voorgestelde oplossing al het bewijs verklaart voordat je die behoudt.

Baken een grotere zoektocht af

Bij verdeel en heers controleer je op een punt tijdens de uitvoering de waarden die bijdragen aan het verkeerde resultaat. Als een benodigde waarde al verkeerd is, onderzoek je de eerdere code die haar produceerde. Als de benodigde waarden nog juist zijn, volg je hoe ze later worden verwerkt. Herhaal dit binnen het overgebleven gedeelte.

Je kunt ook één functie afzonderlijk aanroepen of niet-gerelateerde code tijdelijk verwijderen. Een minimaal reproduceerbaar voorbeeld behoudt de kortste code en kleinste invoer waarbij het nog steeds misgaat. Bij een probleem dat je eerst in honderden records zag, maakt het vinden van één of twee records die het veroorzaken elk onderzoek gemakkelijker.

Controleer wat de gegevens werkelijk zijn

Een weergegeven 5 kan de string "5" zijn. "5" + "3" levert "53" op, terwijl optellen met getallen 8 geeft. Onderzoek type(value) om het type te controleren. Gebruik repr(value) om spaties en regeleindetekens zichtbaar te maken die een gewone print-instructie kan verbergen, zoals in ' Ada'.

Leg de code hardop uit, regel voor regel, inclusief wat elke lus daadwerkelijk doorloopt en wat elke functie teruggeeft. Dit is debuggen met een badeendje: door een stap uit te leggen ontdek je vaak het verschil tussen de bedoelde en de geschreven bewerking.

Wijzig één oorzaak tegelijk zodat je het resultaat aan de aanpassing kunt koppelen. Test zowel de gevallen die eerder werkten als het geval waarin het misging opnieuw.

Het eindantwoord van een programma verbergt de weg waarlangs het is ontstaan. Met tijdelijke uitvoerinstructies, een uitvoeringstabel en een debugger kun je die weg bekijken en een specifieke hypothese toetsen over waar het misgaat.

Druk een waarde op een bekend moment af

Voorzie diagnostische uitvoer van een label zodat de betekenis van een getal duidelijk is. Python 3.8 en later ondersteunen deze f-stringvorm:

print(f"{i=} {total=}")

Zet die voor de foutieve prijslus direct vóór total += prices[i]. Met prijzen [4, 6, 10] wordt afgedrukt:

i=1 total=0
i=2 total=6

Dit zijn totalen vóór elke optelling. Na de eerste uitvoerinstructie telt de lus 6 op; na de tweede telt ze 10 op. Een uitvoerinstructie na de optelling zou andere totalen tonen. Bepaal welk moment je vraag beantwoordt voordat je de uitvoer interpreteert.

Volg dezelfde code met de hand

Een uitvoeringstabel legt variabelen stap voor stap vast. Voor deze lus:

Er is geen iteratie voor index 0. Volg de werkelijke startwaarde en eindgrens die in de code staan, ook als je al weet wat de lus zou moeten doen. Een tabel helpt onderscheiden wat je verwacht van wat er gebeurt.

Pauzeer bij een onderbrekingspunt

Een debugger pauzeert een draaiend programma zodat je de huidige toestand kunt onderzoeken. Een onderbrekingspunt markeert een plaats om te pauzeren. Klik in editors zoals Thonny en VS Code naast een regelnummer en start de debugmodus; klik in IDLE met de rechtermuisknop op de regel en kies Set Breakpoint.

Kies na het pauzeren een stap op basis van de vraag die je onderzoekt:

Als de aanroepende code correcte argumenten doorgeeft maar een verkeerd antwoord ontvangt, ga dan de functie binnen. Als je alleen het teruggegeven resultaat hoeft te zien, voer de aanroep dan uit zonder de functie binnen te gaan. Onderzoek de waarden vóór en na de regel die de fout kan veroorzaken.

Gebruik de tekstdebugger van Python

Voeg breakpoint() in direct vóór de code die je wilt onderzoeken. Bij de standaardconfiguratie van de debugger start het programma op dat punt pdb. Typ deze opdrachten bij de prompt (Pdb):

• p total toont total.
• n voert de volgende regel uit zonder functies binnen te gaan.
• s gaat een functieaanroep binnen.
• c gaat verder met de uitvoering.
• q beëindigt de debugsessie.

Dit zijn debuggeropdrachten, geen regels om naar je programma te kopiëren.

Maak onderscheid tussen afgedrukte uitvoer en retourwaarden

Een functie kan het juiste getal afdrukken en toch None teruggeven omdat return total ontbreekt. Onderzoek de waarde die de aanroepende code ontvangt wanneer de fout na de functieaanroep optreedt. Correcte uitvoer binnen de functie bewijst niet dat de aanroepende code dat getal heeft ontvangen.

Gebruik uitvoerinstructies voor snel bewijs over lusiteraties en de debugger om een bepaald moment te onderzoeken. Verwijder na het herstellen van de programmeerfout tijdelijke uitvoerinstructies en breakpoint()-aanroepen zodat het voltooide programma normaal draait.

Een assertie legt vast wat waar moet zijn als je code correct werkt. Ze kan een programmeerfout stoppen dicht bij de plaats waar die ontstaat of het resultaat van een functie vergelijken met de waarde die je verwacht.

Schrijf een voorwaarde en een optionele melding

assert letter_grade(90) == "A", "90 should be an A"

Python evalueert de voorwaarde. Als letter_grade(90) de waarde "A" teruggeeft, is de voorwaarde waar en gaat de uitvoering verder zonder uitvoer. Als de functie "B" teruggeeft, werpt Python AssertionError op met de melding 90 should be an A. De stacktrace wijst naar de mislukte controle.

Zonder de melding controleert assert letter_grade(90) == "A" nog steeds het resultaat. De laatste exceptieregel bevat AssertionError, terwijl de stacktrace de expressie toont. Een nuttige melding noemt de verwachting waaraan niet is voldaan; ze moet je helpen de regel te vinden die wordt gecontroleerd.

Stop een interne fout vroegtijdig

Stel dat een interne berekening een niet-lege lijst vereist:

def average(values):
    assert len(values) > 0, "values must not be empty"
    return sum(values) / len(values)

Een lege lijst activeert nu de assertie vóór de deling. De controle documenteert de interne aanname van de functie en wijst direct aan wanneer daaraan niet is voldaan. Ze geeft een lege lijst geen gemiddelde en bepaalt niet hoe een toepassing moet reageren op ontbrekende gegevens van een gebruiker.

Houd gebruikersvalidatie actief

De optie -O van Python verwijdert assert-instructies. Een programma dat op een assertie vertrouwt om invoer van buitenaf af te wijzen, kan zich daardoor anders gedragen wanneer het is geoptimaliseerd. Controleer gebruikersinvoer en andere gegevens van buitenaf met gewone programmasturing:

def require_score(score):
    if score < 0 or score > 100:
        raise ValueError("score must be 0 to 100")
    return score

Hier meldt raise ValueError(...) een ongeschikte waarde. De if-instructie wordt ook onder -O uitgevoerd. Kies een assertie voor een interne programmeeraanname en een actieve invoercontrole voor gegevens die van buitenaf onjuist kunnen worden aangeleverd.

Vermijd een controle die nooit kan mislukken

assert is een instructie, geen functie. Schrijf de voorwaarde en de melding met een komma ertussen:

assert x > 10, "x too small"

Als je assert (x > 10, "x too small") schrijft, maak je een tuple met twee elementen. Een niet-lege tuple is waar, ook als het eerste element False is, dus de assertie slaagt. Python kan waarschuwen dat deze assertie altijd waar is. Haakjes rond alleen een voorwaarde, zoals in assert (x > 10), maken die tuple niet aan; de komma binnen de haakjes is het probleem.

Gebruik == om te vergelijken. assert total = 20 is ongeldige syntaxis omdat = een waarde toekent.

Vergelijk getallen met de bedoelde precisie

Gebruik voor een berekend zwevendekommagetal een controle op benaderende gelijkheid:

import math

assert math.isclose(0.1 + 0.2, 0.3)

Een exacte vergelijking mislukt hier omdat de opgeslagen som als zwevendekommagetal iets afwijkt van 0.3. Een eenvoudige geautomatiseerde test past hetzelfde idee van een assertie toe op een functie: assert total_price([4, 6, 10]) == 20. De verwachte waarde komt uit de regel van de functie, zodat de controle een verkeerde implementatie kan blootleggen.

Een unittest controleert een klein onderdeel van de code, meestal één functie, met gekozen invoer en een verwacht resultaat. Geautomatiseerde tests maken het gemakkelijk om dezelfde controles na wijzigingen te herhalen en helpen zo fouten op te sporen die terugkeren in eerder werkend gedrag.

Begin bij de specificatie

Stel dat een beoordelingsfunctie "A" moet teruggeven voor scores van minstens 90, "B" voor scores van minstens 80 maar lager dan 90, en "C" onder 80. De foutieve eerste voorwaarde is score > 90.

Tests moeten verschillende taken vervullen:

• Typische gevallen controleren gewone invoer binnen elk gebied, zoals 95 en 85.
• Grensgevallen controleren de waarden waar een regel verandert, zoals 90 en 89, of 80 en 79.
• Randgevallen controleren invoer zoals nul of een lege collectie wanneer de regels van de functie die toestaan.

Leid het verwachte antwoord af uit die regels. Als je het antwoord van het huidige programma naar een test kopieert, kun je de fout ervan behouden.

Zet de tests naast de module

Sla tests op in test_grade.py en de functie in grade.py. De start van de toepassing in grade.py hoort onder de __main__-voorwaarde, zodat het importeren van de functie het programma niet start.

from grade import letter_grade

def test_letter_grade():
    assert letter_grade(95) == "A"
    assert letter_grade(90) == "A"
    assert letter_grade(85) == "B"

Bij de foutieve regel slaagt de eerste assertie. De tweede mislukt omdat 90 niet groter is dan 90; de uitvoering stopt daar, vóór de derde assertie in deze functie. Door de eerste voorwaarde te veranderen in score >= 90 herstel je deze grens. Voer alle tests opnieuw uit om het betreffende geval en het eerdere gedrag te controleren.

Zorg dat de tests daadwerkelijk worden uitgevoerd

Een testfunctie definiëren roept haar niet aan. Voeg zonder testuitvoerder test_letter_grade() onderaan het testbestand toe en voer daarna python test_grade.py uit. Om pytest te gebruiken, installeer je het met python -m pip install pytest en voer je daarna pytest test_grade.py uit in de terminal. Het vindt de testfuncties en meldt hun resultaten. Laat handmatige aanroepen weg als een testuitvoerder ze beheert.

Een test die alleen letter_grade(90) aanroept, bevat geen vergelijking. Die kan succesvol eindigen terwijl het teruggegeven antwoord verkeerd is; de test mislukt alleen als de aanroep een onverwachte exceptie opwerpt. Een assertie verbindt de aanroep met het vereiste gedrag.

Test retourwaarden en eigenschappen van willekeurige resultaten

Een functie die alleen een totaal afdrukt, geeft None terug. Een vergelijking zoals assert print_total([4, 6]) == 10 mislukt daarom ook als het scherm 10 toont. Laat de berekening haar antwoord teruggeven en laat main het afdrukken verzorgen.

Willekeurige resultaten vereisen een andere verwachting. Van een dobbelsteenfunctie zonder ingestelde startwaarde kun je niet eisen dat die bij elke aanroep precies dezelfde uitkomst teruggeeft. Controleer of elk van 100 aanroepen een toegestane waarde van 1 tot en met 6 teruggeeft, of stel een startwaarde in voor een herhaalbare reeks. Een geslaagde grenscontrole controleert de grenzen voor die aanroepen; ze bewijst niet dat elke uitkomst even waarschijnlijk is.

Als een nieuwe programmeerfout verschijnt, voeg dan vóór de reparatie een test toe die daardoor mislukt. Bewaar die regressietest zodat latere wijzigingen hetzelfde gedrag opnieuw controleren. Geslaagde tests leggen vast wat er in de geteste gevallen gebeurde; met meer invoer kun je nog een andere fout ontdekken.

Python bevat unittest, een testraamwerk dat tests opspoort, uitvoert en afzonderlijke resultaten meldt. Installatie met pip is niet nodig. Je kunt de klassenstructuur als sjabloon gebruiken terwijl je functies leert testen.

Schrijf onafhankelijke testmethoden

Zet dit voor een functie in grade.py in test_grade.py:

import unittest
from grade import letter_grade

class TestLetterGrade(unittest.TestCase):
    def test_top(self):
        self.assertEqual(letter_grade(95), "A")

    def test_boundary(self):
        self.assertEqual(letter_grade(90), "A")

    def test_low(self):
        self.assertEqual(letter_grade(50), "C")

if __name__ == "__main__":
    unittest.main()

TestLetterGrade erft de testhulpmiddelen over van unittest.TestCase. Elke test is een methode waarvan de naam met test begint. self verwijst naar het huidige testobject; behoud dit in de parameterlijst van elke methode en vóór aanroepen van assertiemethoden. Je kunt deze structuur kopiëren zonder zelf klassen te ontwerpen.

Tests worden standaard alfabetisch op methodenaam uitgevoerd, dus test_boundary komt vóór test_low en test_top. Laat elke test de eigen benodigde invoer aanleveren en onafhankelijk van eerdere tests werken.

Kies een assertiemethode

Geef bij het vergelijken van waarden de voorkeur aan assertEqual(a, b) boven assertTrue(a == b): het verslag van de mislukte test toont de twee waarden. De unittest-methoden behouden hun controles ook wanneer Python onder -O draait.

Om een verwachte exceptie te controleren, plaats je de aanroep binnen assertRaises:

def test_score_too_high(self):
    with self.assertRaises(ValueError):
        letter_grade(120)

Deze test vereist dat de regel van de functie die score afwijst met ValueError. Als de functie terugkeert zonder exceptie, mislukt deze controle; een andere exceptie dan een assertie is een testfout.

Voer uit en lees het verslag

Voer python test_grade.py uit om de door de voorwaarde beschermde unittest.main() uit te voeren. Of voer python -m unittest uit om test*.py-bestanden in de huidige map op te sporen. python -m unittest -v drukt afzonderlijke testnamen en hun resultaten af.

In het korte verslag betekent . geslaagd, F dat een assertie is mislukt en E dat een andere exceptie is opgetreden. Voor een beoordelingsfunctie met score > 90 leveren de drie bovenstaande tests F.. op. Het verslag van de mislukte test test_boundary toont 'B' != 'A': het werkelijke resultaat is "B", terwijl het verwachte resultaat "A" is. De samenvatting vermeldt drie tests en één mislukte test.

Controleer de verwachting van de test aan de hand van de beoordelingsregels voordat je de functie wijzigt. Een verkeerde verwachting vereist een aanpassing van de test. Als er geen tests worden uitgevoerd, controleer dan de methodenamen, de voorwaarde voor directe uitvoering en de startopdracht. Noem je bestand ook geen unittest.py, want dat verbergt de standaardmodule.