🐍Programmeren in Python

Waarom programmeren?

Welkom in de cursus programmeren! Misschien vraag je je af: waarom is het belangrijk om te kunnen programmeren? Kort door de bocht: het hoort bij de opleiding Industriële ICT. Maar ook los daarvan zijn er goede redenen:

• Baankansen: bedrijven zoeken mensen die met één of meer programmeertalen uit de voeten kunnen, en er zijn te weinig opgeleide mensen.
• Leren falen: een programma werkt of het werkt niet. Door veel fouten te maken en te herstellen kom je steeds een stapje verder. Falen is noodzakelijk om te leren.
• Kritisch denken en problemen oplossen: programmeren draait om het doorgronden van complexe problemen en het logisch bedenken van een creatieve oplossing (computational thinking).
• Maken: het is een manier om je ideeën tot leven te wekken: een spel, een tool, een app.
• Snappen hoe de wereld werkt: wie weet hoe een algoritme werkt, begrijpt beter hoe een “filterbubbel” of een aanbeveling op sociale media ontstaat.

Waarom Python?

Er bestaan honderden programmeertalen. De structurele manier van denken blijft in bijna alle talen dezelfde; alleen de schrijfwijze verschilt hier en daar. Toch kiezen we, zeker om te beginnen, voor Python:

• Het is één van de meest gebruikte programmeertalen ter wereld.
• Het wordt gebruikt voor heel diverse toepassingen: webapplicaties, games, interne tools, wetenschappelijk onderzoek, kunstmatige intelligentie, Raspberry Pi, …
• Python is efficiënt: je programma doet meer met minder regels code en is makkelijk te lezen en te debuggen.
• Het is gratis en werkt op Windows, macOS en Linux.
• Er is een grote, behulpzame community van beginnende en ervaren programmeurs.

De vier basisstructuren

Elk computerprogramma is opgebouwd volgens een bepaalde logica. Een goed gestructureerd programma gebruikt vier basisstructuren:

In deze cursus bouwen we ze op in die volgorde. Eerst leren we werken met getallen, tekst en lijsten en schrijven we programma’s die gewoon regel na regel lopen (sequentie). Daarna leren we keuzes maken (selectie) en herhalen (iteratie).

Zo werkt deze cursus

• In de “Probeer zelf”-blokken pas je Python-code aan en klik je op ▶ Uitvoeren. Je code draait meteen in je browser; je hoeft niets te installeren om te oefenen.
• Vraagt je programma iets met input()? Typ dan in het vak Invoer de antwoorden, één per regel.
• Bij de oefeningen schrijf je zelf een programma. Met ▶ Uitvoeren test je het, met ✅ Controleer wordt gecontroleerd of je de gevraagde onderdelen gebruikt.
• Later installeren we Python ook op je eigen computer, zodat je echte programma’s maakt die je op je pc opslaat.
• Er is zelden maar één juiste oplossing. Als je programma doet wat gevraagd wordt, is dat prima: kijk daarna gerust hoe het nog korter of duidelijker kan.

Python installeren

Om op je eigen computer te programmeren, moet Python geïnstalleerd zijn. De officiële website python.org geeft duidelijke instructies voor elk besturingssysteem. Python is freeware.

1. Ga naar python.org → Downloads en download de nieuwste versie voor jouw besturingssysteem.
2. Start het installatiebestand. Vink onderaan “Add Python to PATH” aan en kies Install Now.
3. Na de installatie vind je Python (en de IDLE) in je startmenu. Pin de IDLE vast aan je startmenu of taakbalk: je gebruikt hem veel.

Controleren of Python al geïnstalleerd is, kan in het opdrachtprompt (Windows) of de Terminal (macOS/Linux):

Opdrachtprompt (op macOS/Linux typ je python3 --version)C:\Users\sam> python --version
Python 3.12.4

De Python IDLE en de shell

Een IDE (integrated development environment) is software die een programmeur helpt bij het ontwikkelen. Python levert standaard een IDLE mee (integrated development and learning environment). Later kan je overstappen op een uitgebreidere editor zoals Visual Studio Code.

Open je de IDLE, dan kom je in de Python Shell. Daar kan je commando’s uittesten en meteen zien hoe Python reageert. Het teken >>> betekent dat Python op jouw invoer wacht.

Python Shell>>> 6+7
13
>>> print("Hallo")
Hallo

In de shell werk je nog niet aan een echt programma. Kies File → New File (Ctrl+N) om een nieuw programma te schrijven, sla het op met de extensie .py en voer het uit met Run → Run Module (F5). Dat komt later in deze cursus.

Bewerkingen met getallen

Python kan rekenen zoals je rekenmachine, maar met andere symbolen:

Merk op dat het antwoord van een deling als 3.0 getoond wordt en niet als 3. Waarom dat zo is, zie je in het hoofdstuk over datatypes.

De volgorde van bewerkingen

Wat is het antwoord op 3+5*2: 16 of 13? Python respecteert de volgorde van bewerkingen, zoals in de wiskundeles. Het product heeft voorrang op de som, dus het juiste antwoord is 13.

• Bewerkingen van hetzelfde niveau worden opgelost van links naar rechts: 13-6+5 geeft 12 en 12/4*3 geeft 9.0.
• Uitzondering: machten worden opgelost van rechts naar links: 2**3**2 is 2⁹ = 512, niet 64.
• Twijfel je? Gebruik haakjes: die hebben altijd voorrang.

Geheeltallige deling en rest

Twee bijzondere bewerkingen zijn erg nuttig bij delingen:

De geheeltallige deling (floor division) geeft aan hoeveel keer een getal in een ander past: het resultaat is altijd naar beneden afgerond. De rest (modulo) is wat overblijft. Dat gebruik je om bijvoorbeeld seconden om te zetten in minuten en seconden, of om te controleren of een getal even of oneven is.

Variabelen

Een variabele koppelt een naam aan een waarde van een bepaald datatype. De koppeling gebeurt met het =-teken. Je houdt eigenlijk een stukje geheugen vrij. Later roep je de waarde terug op met de naam van de variabele.

Python Shell>>> leerkracht1 = "C. Gratessolle"
>>> leerkracht2 = "F. Meyers"
>>> aantal_leerlingen = 8
>>> School = "PROVIL"
>>> lievelingsgetal = 3.1415
>>> leerkracht1
'C. Gratessolle'
>>> aantal_leerlingen
8
>>> school
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    school
NameError: name 'school' is not defined

Merk op: hoofdletters tellen mee. School bestaat wel, maar school niet, en Python geeft een NameError.

Regels voor namen van variabelen

• Namen bestaan enkel uit letters, cijfers en underscores (_).
• Ze mogen beginnen met een letter of underscore, niet met een cijfer.
• Geen spaties in namen; gebruik een underscore: aantal_leerlingen.
• Gebruik geen namen die al een betekenis hebben in Python (zoals print, list, float).
• Kies korte, duidelijk beschrijvende namen.
• Namen zijn hoofdlettergevoelig (School ≠ school): gebruik bij voorkeur enkel kleine letters.
• Let op de kleine letter i en het cijfer 1, of de hoofdletter O en het cijfer 0.

Rekenen met variabelen

Het is de bedoeling dat je bewerkingen uitvoert met de waarden achter de variabelen. Het resultaat kan je in een nieuwe variabele bewaren:

eerste_getal = 3
tweede_getal = 5
som = eerste_getal + tweede_getal
print(som)        # 8

Een variabele mag ook een bewerking met zichzelf bevatten. getal = getal + 1 betekent letterlijk: “neem de huidige waarde van getal, tel er 1 bij op en bewaar het weer in getal”. Korter schrijf je dat als getal += 1.

Datatypes

Een computer wil weten tot welk datatype (klasse) een variabele behoort. De drie eenvoudigste, “primitieve” datatypes ken je al stilzwijgend. Een vierde, bool, zie je in het hoofdstuk over selectie:

• Cijfers kunnen ook in een string staan (denk aan een gsm-nummer): "0499123456" is tekst, geen getal.
• Er is dus een verschil tussen 3 en 3.0. Een deling van twee gehele getallen geeft vaak een kommagetal, daarom geeft 12/4 de float 3.0.
• Kommagetallen schrijf je met een punt, niet met een komma.

Functies en type()

Een functie is te vergelijken met een niet-doorzichtige doos met een ingang en een uitgang: je geeft input mee, de functie doet iets en geeft een output terug. Hoe ze het precies doet, moet je niet weten. Een functie heeft een naam, gevolgd door twee haakjes waartussen je de input zet.

Python bevat heel wat ingebouwde functies, en later leer je ook zelf functies maken. De eerste functie die je leert kennen is type(): die geeft het datatype van een waarde of variabele.

Het datatype string

Een string is “een sliert van tekens”. Daarin kan alles: kleine letters, hoofdletters, cijfers, leestekens, Griekse symbolen, haakjes, valutasymbolen, … Ook de spatie is een teken zoals een ander!

Een string herken je aan de aanhalingstekens. Die geven aan waar de string begint en eindigt, maar zijn zelf geen onderdeel van de tekst. Je hebt vier mogelijkheden:

Je moet met hetzelfde teken eindigen als beginnen. De verschillende mogelijkheden bestaan voor het geval je tekst zelf een aanhalingsteken bevat. Stel dat je Harry Potter & The Philosopher’s Stone wil opslaan:

>>> boek = 'Harry Potter & The Philosopher's Stone'
SyntaxError: invalid syntax          # Python denkt dat de string stopt na "Philosopher"

>>> boek = "Harry Potter & The Philosopher's Stone"     # kies dubbele aanhalingstekens
>>> boek = 'Harry Potter & The Philosopher\'s Stone'     # of een backslash voor het teken

De drievoudige aanhalingstekens gebruik je voor tekst over meerdere regels. Een nieuwe regel kan ook met \n in de tekst.

Tekst tonen met print()

In de shell zie je de ruwe vorm van een waarde (met aanhalingstekens, en \n in plaats van een nieuwe regel). Met print() toon je een waarde netjes: de aanhalingstekens vallen weg en een \n wordt een echte nieuwe regel. Voor int en float is er geen verschil.

Strings optellen en vermenigvuldigen

Met strings kan je ook bewerkingen doen: je kan ze optellen (aan elkaar plakken, dat gebeurt heel vaak) en vermenigvuldigen met een geheel getal (herhalen).

Python Shell>>> "Frank" + "Meyers"
'FrankMeyers'
>>> "Frank" + " " + "Meyers"
'Frank Meyers'
>>> "Frank" * 5
'FrankFrankFrankFrankFrank'

Zo kan je mooie zinnen opbouwen met variabelen. Overschrijf je de variabelen, dan geeft exact dezelfde print() meteen de nieuwe tekst.

len() en str()

De functie len() telt het aantal tekens in een string, spaties inbegrepen.

Wil je dat aantal tonen in een zin? Dan loop je tegen een fout aan:

Python Shell>>> user = "Christophe"
>>> aantal_tekens = len(user)
>>> print("Uw naam bestaat uit " + aantal_tekens + " tekens.")
TypeError: can only concatenate str (not "int") to str

aantal_tekens is een int, en een string kan je enkel met een string optellen. De oplossing is de functie str():

Sommige functies werken enkel met een bepaald datatype. len(1989) geeft een fout omdat een getal geen lengte heeft, maar len(str(1989)) geeft 4: het aantal cijfers.

Index en slicing van strings

Elk teken in een string heeft een index: zijn plaats. Zet de index tussen vierkante haakjes achter de string. Python begint te tellen bij 0! Het eerste teken staat op index 0.

De indexen van "Harry Potter" 0  1  2  3  4  5  6  7  8  9  10 11
 H  a  r  r  y  ␣  P  o  t  t  e  r
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

• De laatste index is de lengte min één. Vraag je een index buiten de string, dan krijg je een IndexError.
• Met een negatieve index tel je van achter: user[-1] is altijd het laatste teken.
• Met de methode .find() zoek je de index van een teken. Bij meerdere voorkomens geeft Python het eerste; bij een teken dat er niet in zit geeft het -1.

Slicen

Een stuk uit een string halen noemen we slicen: variabele[beginindex:eindindex].

• Python slicet van de beginindex tot (niet tot en met!) de eindindex.
• Geen beginindex? Dan begin je bij het eerste teken. Geen eindindex? Dan ga je tot het einde.
• user[:] geeft de hele string; zijn begin- en eindindex gelijk, dan krijg je de lege string "".

De opmaak van strings aanpassen

Met enkele methoden pas je de hoofdletters aan. Handig als een gebruiker zijn naam op verschillende manieren intypt (PIETER, PiEteR, pieter) en jij die eenduidig als Pieter wil tonen.

Tenslotte kan je witruimte toevoegen: "\n" voegt een nieuwe regel toe en "\t" een tab.

Van shell naar programma

Tot nu toe speelde je vooral in de shell. In een echt programma schrijf je je code in een bestand (met de extensie .py). Python voert die code lijn per lijn uit, dus sequentieel.

• In IDLE: File → New File (Ctrl+N), typ je code en sla op met Ctrl+S. Geef het bestand een duidelijke naam en zet het in een logische map.
• Uitvoeren: dubbelklik op het .py-bestand (het programma draait in de zwarte console van Windows) of kies Run → Run Module (F5) om het in de shell te laten draaien.

Ieder programma begint met een probleemstelling: als programmeur bedenk je hoe je die kan oplossen. Vaak test je eerst kleine stukjes in de shell voor je het hele programma schrijft.

Invoer van de gebruiker: input()

Met input() vraag je een waarde aan de gebruiker. Je geeft de vraag als tekst mee en bewaart het antwoord meteen in een variabele.

Belangrijk: wat je met input() krijgt is altijd een string, ook als de gebruiker een getal typt. Willen we met dat getal rekenen, dan moeten we het omzetten.

Ons eerste programma: een naam analyseren

De probleemstelling: het programma vraagt om een volledige naam, groet de gebruiker in een mooie zin en vertelt uit hoeveel tekens de naam bestaat.

programma1.pygebruiker = input("Type jouw naam hier: ")
aantal_tekens = len(gebruiker)

print("Hartelijk welkom, " + gebruiker + "!")
print("Jouw naam bestaat uit " + str(aantal_tekens) + " tekens.")

input("Druk op 'enter' om te stoppen...")

• We vragen de naam met input() en bewaren ze in gebruiker.
• We tellen de tekens met len() en bewaren dat in aantal_tekens.
• We tonen een mooie zin met print() en plakken strings aan elkaar met +.
• We zetten het aantal (een int) om naar een string met str().

Nu breiden we uit: het programma isoleert de voornaam en achternaam uit de volledige naam, toont ze met een beginhoofdletter (ongeacht hoe de gebruiker typte) en toont de eerste en laatste letter van beide als hoofdletter. Dat kan voor elke naam werken, door de spatie te zoeken met .find() en te slicen:

Rekenen met getallen: int() en float()

Vraag je met input() een getal, dan is dat een string. "7" * 2 geeft "77" en "7" + 1 geeft een TypeError. Je moet eerst omzetten:

• Verwacht je een geheel getal? Gebruik int(). Verwacht je een kommagetal (of ben je niet zeker)? Gebruik float().
• int("3.1415") geeft een ValueError: je kan een tekst met komma niet rechtstreeks naar een int omzetten. Doe eerst float(), dan eventueel int() (de decimalen vallen weg).

Commentaar en afronden

Met het teken # zet je een regel (of het einde van een regel) in commentaar. Python negeert die tekst; het dient om je programma te structureren en te verduidelijken.

Kommagetallen kunnen rare uitkomsten geven, zoals 15.000000000000002. Met round() rond je bedragen netjes af op twee decimalen.

Ons tweede programma: de solden

Probleemstelling: een winkelketen wil klanten tijdens de solden helpen. Het programma vraagt de prijs van een product en het kortingspercentage, en zegt in een mooie zin hoeveel je moet betalen en hoeveel je bespaart.

Wat is een lijst?

Een list is een verzameling van items in een welbepaalde volgorde: de letters van het alfabet, automerken, de namen van je klas, … De items moeten geen relatie met elkaar hebben. Kies voor de naam van een lijst een meervoud (letters, namen), want ze bevat meerdere elementen.

Je maakt een lijst met vierkante haakjes, en de elementen scheid je met komma’s. Een element haal je op met zijn index, net zoals bij strings: het eerste element heeft index 0, het laatste index -1.

Items veranderen en toevoegen

De meeste lijsten zijn dynamisch: tijdens het programma komen er items bij of gaan er weg. Een game met aliens die neergeschoten worden en weer verschijnen, werkt zo.

• Wijzigen: lijstnaam, index en de nieuwe waarde: automerken[1] = "fiat".
• Achteraan toevoegen: .append(). Handig om met een lege lijst [] te beginnen en er items aan toe te voegen.
• Op een bepaalde plaats toevoegen: .insert(index, waarde).

Items verwijderen

Er zijn drie manieren, afhankelijk van wat je weet en wat je met het verwijderde item wil doen:

• De waarden in een lijst zijn hoofdlettergevoelig. .remove("league of legends") geeft een ValueError als er League of Legends staat.
• .remove() verwijdert enkel de eerste gevonden waarde, ook al staat ze meerdere keren in de lijst. (Alle voorkomens verwijderen leer je bij de while-lus.)
• Met len() vraag je op uit hoeveel items een lijst bestaat.

Een lijst sorteren

Gebruikers leveren gegevens vaak in een onvoorspelbare volgorde aan. Je kan een lijst blijvend of tijdelijk ordenen:

Door een volledige lijst “loopen”

Je wil vaak dezelfde taak uitvoeren voor elk item in een lijst: iedere naam groeten, elk getal verwerken, iedereen dezelfde mail sturen. Dat kan in Python met de for-lus. Je herhaalt geen code, en het maakt niet uit of de lijst tien of tien miljoen items heeft.

namen = ["Bart", "Fred", "Ilse", "Sofie", "Jan"]

for naam in namen:
    print("Hallo, " + naam + "!")

De regel for naam in namen: betekent letterlijk: “voor elk item naam in de lijst namen …”.

• De hulpvariabele (hier naam) krijgt bij elke ronde de waarde van het huidige item. Kies een passende naam: het enkelvoud van de lijstnaam (for cat in cats, for leerling in leerlingen).
• Na de regel met for staat een dubbele punt (:).
• De regels die herhaald moeten worden, springen 4 spaties in. Zoveel regels als je wil, alle ingesprongen. De eerste regel die niet meer ingesprongen is, zit niet meer in de lus.

Let op met inspringen en de dubbele punt

In Python is inspringen (4 spaties) betekenisvol: het bepaalt wat bij de lus hoort. Hier maak je snel fouten. Bekijk wat er gebeurt:

• Vergeet je in te springen bij de regel na de for? Dan krijg je een IndentationError: expected an indented block.
• Vergeet je het inspringen bij de tweede print? Dan staat die buiten de lus en wordt hij maar één keer uitgevoerd, na de lus.
• Spring je in zonder lus? Dan geeft Python een IndentationError: unexpected indent.
• Vergeet je de dubbele punt? Dan krijg je een SyntaxError.

Getallenreeksen met range()

Soms heb je een reeks getallen nodig: jaartallen, scores, tafels, …

• range(5) is 0, 1, 2, 3, 4: vanaf 0 en met stapgrootte 1. Ideaal om een stuk code vijf keer te herhalen.
• Met een derde getal geef je de stapgrootte: range(2, 11, 2) geeft 2, 4, 6, 8, 10.
• Met list() zet je een reeks om in een echte lijst: list(range(1, 6)) geeft [1, 2, 3, 4, 5].

Een lijst opbouwen met een lus

Je kan een lijst opbouwen door met een lege lijst te beginnen en er in een lus telkens een item aan toe te voegen met .append(). Zo maak je de machten van 2:

machten_van_twee = []
for macht in range(1, 11):
    resultaat = 2 ** macht
    machten_van_twee.append(resultaat)
print(machten_van_twee)

Voor lijsten met enkel getallen bestaan handige functies:

Slicen en kopiëren van een lijst

Een deel van een lijst neem je met slicen, exact zoals bij strings: klas[3:7], klas[:3], klas[5:]. Je kan ook door een slice loopen.

Onveranderlijke lijsten: tuples

Soms wil je een lijst die niet mag veranderen, zoals de afmetingen van een kast. Python noemt een onveranderlijke lijst een tuple. Je maakt ze met ronde haakjes.

• Index, slicen, for, len(), … werken zoals bij een lijst.
• Methoden die de lijst zouden veranderen (.append(), .reverse(), …) werken niet. Een item aanpassen geeft een TypeError: 'tuple' object does not support item assignment.
• Wil je toch andere waarden, dan moet je de hele tuple overschrijven.

De methoden uit de module

Soms wil je dat Python iets totaal willekeurig doet: in games, bij het genereren van wachtwoorden, bij een dobbelsteen. Daarvoor bestaat de module random. Een module is een verzameling extra functies die je eerst moet importeren, bovenaan je programma:

import random

• Vergeet import random niet, anders werken de methoden niet.
• Gebruik de naam random nooit voor een eigen variabele: je overschrijft dan de module.
• Bij randint(a, b) horen beide grenzen bij de mogelijke uitkomsten (anders dan bij range()).

Ideeën om mee te bouwen

• Een worp met een dobbelsteen: random.randint(1, 6).
• Kop of munt: random.choice(["kop", "munt"]).
• Een willekeurige volgorde (afspeellijst, groepjes): random.shuffle(lijst).
• Een wachtwoord: kies 15 keer een willekeurig teken uit een lijst of string met alle toegelaten tekens en plak ze aan elkaar.

Wat is een voorwaardelijke structuur?

Tijdens het programmeren wil je vaak één of meer voorwaarden controleren en afhankelijk daarvan een bepaalde actie uitvoeren: “als de gebruiker minstens 18 is, dan …, anders …”. Zo voer je een deel van het programma al dan niet uit. Dat doe je in Python (en in alle andere talen) met het if-statement.

Met elke nieuwe structuur die je leert, nemen je mogelijkheden enorm toe. In dit hoofdstuk kan je bovendien de programma’s uit vorige hoofdstukken verbeteren.

De opbouw van if en else

In dit voorbeeld loopen we door een lijst automerken. Is het merk gelijk aan bmw, dan tonen we het in hoofdletters, anders met een beginhoofdletter:

cars = ['audi', 'bmw', 'subaru', 'toyota']

for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

Algemene opbouwif <voorwaarde>:
    <uitvoering als de voorwaarde behaald wordt>
else:
    <uitvoering als de voorwaarde niet behaald wordt>

• Achter de voorwaarde staat een dubbele punt, en de code die erbij hoort springt in (4 spaties). Zoveel regels als je wil. Een regel die niet meer inspringt, hoort er niet meer bij.
• Het else-deel mag je weglaten als er enkel iets moet gebeuren wanneer de voorwaarde klopt.
• Je mag een if in een andere if zetten (genest).

Meerdere voorwaarden: elif

Wil je meer dan twee mogelijkheden onderscheiden, dan gebruik je elif (samentrekking van else if). Python overloopt de voorwaarden van boven naar onder en voert enkel het eerste deel uit waarvan de voorwaarde klopt. De volgorde is dus belangrijk!

Algemene opbouwif <voorwaarde 1>:
    <uitvoering als voorwaarde 1 behaald wordt>
elif <voorwaarde 2>:
    <uitvoering als voorwaarde 2 behaald wordt>
else:
    <uitvoering in alle andere gevallen>

Voorbeeld: een robot-leerkracht (in de toekomst) beoordeelt het jaartotaal van elke leerling. Voor elk bereik van punten hoort een eigen commentaar.

Voorwaarden controleren

De kern van elke if is een expressie die True of False oplevert: een voorwaardelijke test. Klopt hij (True), dan voert Python de bijhorende code uit; klopt hij niet (False), dan negeert Python ze. Zo leer je een nieuw datatype kennen: bool (boolean), dat maar twee waarden kan hebben: True of False (met hoofdletter!).

in, bool-variabelen en lege lijsten

Met in controleer je of een waarde in een lijst zit (bv. een nieuwe gebruikersnaam in een lijst met bestaande) of een stukje tekst in een string. Ook hier telt hoofdlettergevoeligheid.

Je kan True en False ook in een variabele bewaren en die rechtstreeks in een voorwaarde gebruiken: if status:. En een lijst zelf als voorwaarde: if gewenste_toppings: is True als de lijst minstens één element bevat, en False als ze leeg is. Handig om te testen of een lijst leeg is.

Uitgewerkt voorbeeld: een pizza samenstellen

We werken met twee lijsten: de gewenste toppings van de klant en de toppings die het restaurant heeft. Het programma controleert elke gewenste topping.

• Het eerste if gewenste_toppings: controleert of de lijst niet leeg is. Is ze leeg, dan koos de klant een standaardpizza.
• Daarna loopen we door de gewenste toppings en gebruiken we een if ... in ... in de for-lus: dat wordt voor elk element opnieuw gecontroleerd. Dit is een genest programma: een selectie in een iteratie in een selectie.

Introductie

Tot nu toe programmeerde je met een opeenvolging van instructies (sequentie) en keuzes (selectie). Een derde structuur is de herhaling of iteratie: instructies herhalen aan een hoog tempo is één van de grote voordelen van een computer. Er zijn twee soorten:

• een for-lus: een gekend aantal herhalingen;
• een while-lus: herhalen zolang een voorwaarde klopt.

De for-lus

Met de for-lus herhaal je een deel van het programma een gekend aantal keer. Je loopt door een lijst, een string, een tuple of een range(). De ingesprongen regels worden voor elk item herhaald.

• Voor een gewone herhaling gebruik je meestal range(n): dat loopt van 0 tot en met n-1. Wil je de teller tonen als nummering, dan is dat i + 1.
• Bij range(2, 5, 2) zijn de grenzen tot (niet tot en met) de bovengrens, en is de laatste waarde de stapgrootte.
• Je kan ook door een string loopen: één ronde per teken.

break en continue

Soms wil je een lus vroegtijdig verlaten of een ronde overslaan:

Let op de volgorde van de regels: staat de print vóór of ná de break? Dat bepaalt of de “peer” nog getoond wordt.

else bij een for-lus, en lussen in lussen

Een for-lus mag een else hebben: die wordt uitgevoerd als de lus volledig doorlopen is. Bij een break wordt het else-deel niet uitgevoerd (bij een continue wel).

Je kan ook een for-lus in een andere for-lus plaatsen: voor elk item van de buitenste lus wordt de binnenste lus helemaal doorlopen. Zo combineer je elk adjectief met elke soort fruit.

De while-lus

Soms weet je niet hoeveel keer iets moet herhaald worden, maar wel zolang wat. Dan gebruik je een while-lus: de ingesprongen code wordt herhaald zolang de voorwaarde True is. De voorwaarde bouw je op met de vergelijkingsoperatoren uit het vorige hoofdstuk.

• De variabele in de voorwaarde moet vooraf een waarde hebben.
• Ze moet tijdens de lus veranderen, anders krijg je een oneindige lus! Met Ctrl+C onderbreek je een lus in Python (in dit lesmateriaal gebruik je de Stop-knop).
• Met getal += 1 verhoog je een teller.
• break en continue werken hier op dezelfde manier als bij for.

De gebruiker bepaalt wanneer we stoppen

Een klassieker: het programma herhaalt wat de gebruiker zegt, tot die stop typt.

• De vraag zit in de variabele prompt: zo is ze makkelijk aan te passen.
• bericht = "" maakt de variabele aan vóór de voorwaarde van de while ze nodig heeft.

Dit programma heeft nog een klein foutje: als je stop typt, wordt “stop” nog net meegeprint. Dat los je in de oefeningen op!

Met een flag of met break

Is de voorwaarde ingewikkeld, dan gebruik je vaak een flag: een variabele (status = True) die de voorwaarde van de while vormt. Op verschillende plaatsen kan je ze op False zetten om de lus te beëindigen. Een alternatief is een oneindige lus while True: waaruit je met break springt. Beide versies verbeteren het foutje van daarnet.

Alle voorkomens uit een lijst verwijderen

Bij lijsten leerde je dat .remove() enkel de eerste gevonden waarde verwijdert. Met een while-lus herhaal je dat zolang de waarde nog in de lijst zit:

Van probleem naar programma

Bij een groter programma begin je niet meteen te typen. Een goede aanpak:

1. Begrijp de opdracht: wat moet er op het scherm komen, wat vraagt de gebruiker, wanneer stopt het?
2. Splits op in stukjes: eerst het geheime getal, dan één poging, dan herhalen, dan de hints, dan het einde.
3. Bouw en test stap voor stap. Typ een stukje, voer uit, controleer, ga verder.
4. Print tussenwaarden als iets niet klopt (print(geheim) tijdens het testen), en haal ze nadien weg.
5. Verbeter daarna: foutafhandeling, een mooiere opmaak, extra functies.

Voorbeeld: een raadspel

Het programma genereert een geheim getal van 0 tot en met 100. De speler krijgt 10 pogingen en na elke poging een hint: hoger of lager. Combineert een iteratie (for), selectie (if/elif) en een break als het getal geraden is. Gebruik je de else van de for-lus, dan weet je of alle pogingen op zijn.

De snelste manier om te raden

Weet jij wat de beste techniek is om een getal van 0 tot 100 in zo weinig mogelijk pogingen te raden? Halveren! Gok telkens het middelste getal van het bereik dat overblijft. Na “hoger” is de ondergrens één hoger dan je gok, na “lager” is de bovengrens één lager. Zo heb je bij 0-100 hoogstens 7 pogingen nodig. Dit heet binair zoeken en wordt overal in de informatica gebruikt.

onder = 0
boven = 100
gok = (onder + boven) // 2      # het midden

# "hoger"  -> onder = gok + 1
# "lager"  -> boven = gok - 1

Overzicht van de geziene functies en methoden

Hieronder vind je de functies in dezelfde volgorde als waarin je ze in de cursus leerde. Een functie roep je op met haakjes (len(x)), een methode met een punt achter een waarde (x.upper()).

Foutmeldingen leren lezen

Een foutmelding is geen straf maar een wegwijzer. Lees ze van onder naar boven: de laatste regel zegt welke soort fout het is en wat er mis is, de regel erboven toont in welke regel van jouw code het misging.

Zo ziet een foutmelding eruitTraceback (most recent call last):
  File "programma.py", line 2, in <module>
    print("Het getal is " + getal)
TypeError: can only concatenate str (not "int") to str

Zo zoek je een fout

1. Lees de foutmelding van onder naar boven: welke soort fout, welke regel?
2. Kijk naar die regel én de regel erboven: een vergeten haakje of dubbele punt wordt vaak pas op de volgende regel opgemerkt.
3. Print tussenwaarden met print() of print(type(x)): is het echt wat je denkt?
4. Maak het kleiner: zet regels tijdelijk in commentaar (#) tot de fout verdwijnt.
5. Zoek de foutmelding op (woord voor woord op het internet): iemand anders kreeg dezelfde fout al.
6. Neem een pauze of leg het aan iemand uit. Vaak zie je de fout dan zelf.

Hoe nu verder?

Je kent nu de bouwstenen van elk programma: variabelen, datatypes, strings, lijsten, keuzes en herhalingen. Wat je verder nog kan ontdekken:

• Eigen functies schrijven (def) om code te hergebruiken;
• Bestanden lezen en schrijven, en foutafhandeling met try/except;
• Dictionaries: gegevens bewaren als sleutel-waardeparen;
• Klassen en objecten (object-georiënteerd programmeren);
• Toepassingen: een grafische interface (tkinter), games (pygame), sensoren en robots (Raspberry Pi), data-analyse en webapplicaties.