Gestructureerd Programmeren

Informatica Programmeren – Start to Program
Gestructureerd Programmeren met Python

Linthoudt Geert
Gestructureerd Programmeren
Inhoud
1 Inleiding ........................................................................................................................................... 4
1.1 Software .................................................................................................................................. 5
1.2 Leren programmeren ............................................................................................................ 10
1.3 Wat is Gestructureerd Programmeren? ................................................................................ 12
1.4 Hoe gaan we te werk? ........................................................................................................... 13
1.4.1 Flowchart ....................................................................................................................... 14
1.4.2 Pseudocode ................................................................................................................... 15
1.5 Hoe gaat u te werk? .............................................................................................................. 16
2 Sequentie....................................................................................................................................... 17
2.1 “Hello World” ........................................................................................................................ 18
2.2 “Hello, ” naam ....................................................................................................................... 24
2.3 “Hello,” familienaam + voornaam ......................................................................................... 30
2.4 Som ........................................................................................................................................ 35
2.4.1 Functies ......................................................................................................................... 42
2.5 Conversie van Celsius naar Fahrenheit ................................................................................. 44
2.6 Bereken oppervlakte en omtrek van een rechthoek ............................................................ 49
2.7 Bereken de oppervlakte en de omtrek van een cirkel .......................................................... 54
2.8 Tentoonstelling 1 ................................................................................................................... 59
2.9 Factuur 1................................................................................................................................ 64
2.10 Punten ................................................................................................................................... 69
2.11 Verbruik ................................................................................................................................. 74
2.12 Bestelling ............................................................................................................................... 79
2.13 Stringcommando’s in Python ................................................................................................ 84
3 Selectie .......................................................................................................................................... 88
3.1 Boolean expressie.................................................................................................................. 91
3.1.1 Vergelijkingsoperatoren in Python ................................................................................ 91
3.1.2 Logische operatoren in Phyton ..................................................................................... 91
3.1.3 Syntax in Python ............................................................................................................ 92
3.2 Is een getal positief?.............................................................................................................. 93
Inleiding 1
Linthoudt Geert
3.3 Is een getal positief of negatief? ......................................................................................... 100

3.4 Is een getal positief, negatief of nul? .................................................................................. 106
3.5 Gratis verzending................................................................................................................. 113
3.6 Factuur 2.............................................................................................................................. 121
3.7 Tentoonstelling 2 ................................................................................................................. 130
3.8 Welke taxi? .......................................................................................................................... 137
3.9 Premie ................................................................................................................................. 144
3.10 Geslaagd of niet................................................................................................................... 150
3.10.1 Logische operatoren in Phyton ................................................................................... 151
3.11 Geslaagd met… .................................................................................................................... 156
4 Iteratie (herhalingen) .................................................................................................................. 164
4.1 Boolean expressie................................................................................................................ 166
4.1.1 Vergelijkingsoperatoren in Python .............................................................................. 166
4.1.2 Logische operatoren in Phyton ................................................................................... 166
4.2 Soorten herhalingen ............................................................................................................ 167
4.2.1 Begrensde herhaling in Python ................................................................................... 168
4.2.2 Voorwaardelijke herhaling in Python .......................................................................... 186
4.3 Eentje meer ......................................................................................................................... 207
4.4 Wiskundige tafel van ........................................................................................................... 213
4.5 Alle wiskundige tafels van 1 tot 10...................................................................................... 218
4.6 Tekst omkeren ..................................................................................................................... 223
4.7 Gemiddelde dobbelstenenworp ......................................................................................... 230
4.8 Dobbelstenenworpen met uitvoer nadat alle worpen gedaan zijn .................................... 235
4.9 Getallen inlezen ................................................................................................................... 241
4.10 Punten voor cursisten ......................................................................................................... 246
4.11 Tentoonstelling 3 ................................................................................................................. 253
4.12 Getallen optellen ................................................................................................................. 258
5 Extra: Complexere voorbeelden .................................................................................................. 264
5.1 21 ......................................................................................................................................... 265
5.2 Schaar steen papier 1 .......................................................................................................... 268
5.2.1 Functies ....................................................................................................................... 278
5.3 Schaar steen papier 2 .......................................................................................................... 283
5.3.1 Globale variabelen in Python ...................................................................................... 293
Inleiding 2
Linthoudt Geert
Inleiding 3
Linthoudt Geert
1 Inleiding
In deze handleiding leren we Gestructureerd Programmeren.
De nadruk ligt op het leren programmeren. De programmeertaal die ik gebruik is Python.
Maar ik herhaal, de nadruk ligt op het leren programmeren en niet op het leren programmeren in
Python. Dit is een belangrijke nuance die betekent dat ik niet inga op de typische kenmerken en
syntax van de programmeertaal Python. Ik kies Python als programmeertaal omdat het relatief
simpel is om mee aan de slag te gaan en het ook een populaire programmeertaal is, dus een
kennismaking met altijd mooi meegenomen.
Een bijkomend voordeel is dat Python nauw aansluit bij Pseudocode waar ik in deze handleiding
gebruik van maak.
U kunt Python installeren op uw eigen PC (op Moodle deel ik een video hoe u dit kunt doen). Maar
omdat de nadruk ligt op het leren programmeren, en niet op Python, maak ik het me gemakkelijk en
gebruik ik een online tool: https://www.online-python.com/
Inleiding 4
Linthoudt Geert
1.1 Software
 Voor het tekenen van de Stroomdiagram kunt u gebruik maken van de website
app.diagrams.net (het vroegere draw.io).
Inleiding 5
Linthoudt Geert
 Kies voor Stroomschema (Flow chart) en bewaar.
Inleiding 6
Linthoudt Geert
 U ziet er reeds een voorbeeldje staan, links kunt u de specifieke symbooltjes voor het
Stroomschema selecteren.
 Klik onderaan links op More Shapes….
Inleiding 7
Linthoudt Geert
 De symbolen kunt u in het diagram slepen en verbinden. Als u een symbool toevoegt kunt u
vanuit dat symbool verdere verbindingen leggen.
 U kunt ook verbindingslijnen trekken tussen twee reeds aanwezige symbolen. Zorg dat u een
groen bolletje ziet om de verbinding te verankeren.
 Tekst voegt u toe door te dubbelklikken op het symbooltje en de tekst te typen.
Inleiding 8
Linthoudt Geert
 Rechts kunt u de eigenschappen en de stijl van de symbolen, verbindingslijnen en tekst

bepalen.
Inleiding 9
Linthoudt Geert
1.2 Leren programmeren

In deze handleiding ligt de nadruk op het leren programmeren.
Leren programmeren is niet de programmeercode, de oplossing, uit het hoofd leren. Ik wil dit nog
eens extra benadrukken, voor deze handleiding en alle volgende programmeerhandleidingen die u
doorneemt, leer de programmeercode niet uit het hoofd.
Hoe leert u dan wel programmeren?
 Ken de syntax van de belangrijkste instructies van de gekozen programmeertaal.

Waar ik net stel dat u geen volledige programmeeroplossingen uit het hoofd moet leren
moet uw wel de syntax, de schrijfwijze van de belangrijkste instructies, van de gekozen
programmeertaal kennen. Weet hou u variabelen maakt, gegevens inleest, een selectie (if-
statement) schrijft, een array definieert,… Als u de syntax kent kunt u zich volledig focussen
op het programmeerprobleem zelf. Ook al lijkt dit misschien redelijk veel, al bij al is dit
hoogstens een paar A4’tjes.
 Sla niet meteen aan het programmeren. Denk eerst na over de opdracht.
Welke uitvoer wordt verwacht? Welke invoer hebt u hiervoor nodig, welke berekeningen
moeten worden uitgevoerd om uit de invoer de verwachte uitvoer te krijgen? Maak eerst
een stappenplan, een flowchart, pseudocode… zodat het programmeren zelf niet veel meer
is dan een “vertaling” van de oplossing die u reeds hebt.
 Leer structuren herkennen, hoe programmeercode opgebouwd is, en weet deze structuren
te hernemen voor uw eigen programmeercode. Kortom, leer gestructureerd programmeren.
 Leer patronen herkennen. Misschien hebt u ooit iets gelijkaardigs geprogrammeerd? Dan
kunt u deze programmeercode als basis hergebruiken en volstaan vaak een paar kleine
aanpassingen, een kleine uitbreiding. Bekijk een videotutorial die stap voor stap een
gelijkaardig probleem programmeert en uitlegt.
 Experimenteer, als u een opdracht krijgt en het is gelukt, probeer dan eens kleine varianten
op de opdracht, probeer er iets aan toe te voegen, een stapje verder te gaan.
 Maak voor uzelf een soort bibliotheek van oplossingen aan waar u kunt induiken om
oplossingen voor gelijkaardige problemen te vinden. Sommige van mijn handleidingen zullen
deze rol vervullen. Ze zullen aangeboden worden als een soort naslagwerk met de syntax,
programmeertechnieken en tal van praktische voorbeelden.
 Zoek op. Blindelings programmeercode schrijven is iets dat komt met vele jaren ervaring. In
het begin bent u omsingeld door handleidingen, PDF’s, videotutorials, vorige opdrachten,…
Een programmeertaal komt met honderden functies en tientallen bibliotheken die elk weer
tientallen functies bevatten. U kunt dit niet allemaal weten, uit het hoofd leren. U moet de
gepaste functie weten te vinden en opzoeken hoe u ze moet gebruiken (welke parameters u
moet meegeven en wat hun doel is). Heel vaak moet u daarvoor terecht in de officiële
handleiding van de gekozen programmeertaal. Ook hier is Google een goede vriend.
 En… uit fouten maken leert u. Wanneer u lang gezocht hebt op een programmeerfout, een
bug, en deze uiteindelijk opgelost hebt, dan zal u de oplossing nooit meer vergeten en,
wellicht, de fout nooit meer maken. De fout is de beste leerschool.
Inleiding 10
Linthoudt Geert
In deze handleiding probeer ik u met vele eenvoudige voorbeelden het “leren programmeren” aan te
leren.
Misschien zegt u op een gegeven ogenblik wel iets als “Ja, nog zo’n oefening, ik heb het nu wel
gehad”. Goed zo, dit betekent dat u structuren herkent, patronen herkent, dan bent u goed op weg
om te leren programmeren.
Sommige van de programmeeropdrachten zullen later in deze cursus terugkomen als opdrachten.
Hou dit document dus bij de hand, als naslagwerk, als inspiratiebron.
Inleiding 11
Linthoudt Geert
1.3 Wat is Gestructureerd Programmeren?

Van Wikipedia (een beetje ingekort):
Gestructureerd programmeren kan worden gezien als een subdiscipline van procedureel
programmeren, een van de belangrijke programmeerparadigma's voor het programmeren van
computers. De programmeur beperkt zich in dit concept tot de vier basis controlestructuren en past
het concept abstractie consequent toe. Abstractie wil hier zeggen: het vermijden van lange
programmablokken door het veelvuldig toepassen van relatief kleine subroutines.
De 3 basis controlestructuren zijn:
 Sequentie - een opeenvolging van instructies, de ene na de andere.

 Selectie - keuzestructuur, als dit dan dat anders.
 Iteratie - herhaling, herhaal zolang iets waar is of tot iets waar is.
Inleiding 12
Linthoudt Geert
1.4 Hoe gaan we te werk?

De opdracht wordt omschreven.
Bepaal:
 Uitvoer – wat moet het programma uiteindelijk tonen.

 Invoer – welke invoer hebt u nodig om de gevraagde uitvoer te krijgen.
 Bewerkingen – welke bewerkingen moeten op de invoer uitgevoerd worden om de uitvoer te
bekomen.
Vervolgens wordt het algoritme, stappenplan om via instructies de gevraagde uitvoer te krijgen,
uitgewerkt in een flowchart, Pseudocode en vertaald naar Python.
Tenslotte wordt het Python-programma geschreven.
Inleiding 13
Linthoudt Geert
1.4.1 Flowchart
Ik geef de code weer als een Flowchart.
Bijvoorbeeld:
 Een ovaal voor Starten en Stoppen van het programma/script.

 Een parallellogram voor invoer en uitvoer.
 Een rechthoek voor een proces, verwerking/bewerking.
 Een ruit start een beslissing.
 Een beslissing heeft een Ja-kant (true/waar) en een Nee-kant (false/onwaar).
Inleiding 14
Linthoudt Geert
1.4.2 Pseudocode
Pseudocode is geen programmeertaal, het is een eenvoudige manier om instructies structureel en
begrijpelijk te noteren. Het schrijven van pseudocode is echter wel vergelijkbaar met het schrijven
van programmeercode. Iedere stap van het algoritme wordt in volgorde opgeschreven en er is ook
een eenvoudige syntax.
 Instructies worden in hoofdletters geschreven.

 Variabelen in kleine letters.
 Boodschappen worden als een zin geschreven.
Pseudocode Betekenis
INPUT De gebruiker voert gegevens in en houdt deze gegevens bij in variabelen.
OUTPUT Gegevens worden weergegeven (op het scherm).
IF ... THEN... ELSE ... Een beslissing/Selectie. Als een bepaalde conditie waar is doe dan dit ander
doe dat.
WHILE ... Een lus/iteratie. Zolang een bepaalde conditie waar is doe.
FOR ... Een lus/iteratie. Doe een aantal keer.
REPEAT ... UNTIL ... Een lus/iteratie. Herhaal tot aan een bepaalde conditie voldaan is.
STORE Bewaar een waarde in een variabele (of in een record van een databank).
Een variabele is een voorbehouden locatie in het computergeheugen waar u een waarde kunt
bijhouden/stokkeren voor later hergebruik.
Inleiding 15
Linthoudt Geert
1.5 Hoe gaat u te werk?

Misschien eerst, hoe gaat u niet te werk?
Wat u niet doet is dit document laten liggen, dan op een blauwe maandagavond, zo juist voor het
einde van de cursus, dit in één keer volledig doornemen en denken dat u het kent.
Oké, hoe gaat u wel te wek.
1. Het kan geen kwaad dit document eerst eens volledig door te nemen. Maar daar mag het
niet bij blijven, nadien herneemt u het document.
2. De eerste voorbeeldopdrachten kunt u volledig doornemen, doorlezen in het document om
u vertrouwd te maken met de werkwijze.
3. Na een paar voorbeeldopdrachten gaat u echter meedenken, u leest enkel de opdracht en
probeert zelf te bepalen wat de uitvoer, invoer en de bewerkingen zijn. Ik heb bewust de
opdracht en de verschillende stappen in de uitvoer elk op een eigen pagina gezet, zodat u
niet, per toeval, reeds de oplossing ziet.
4. U vergelijkt uw oplossing met mijn oplossing. Er kunnen kleine verschillen zijn, denk erover
na, wellicht is uw oplossing even goed als de mijne.
5. Vervolgens gaat u de flowchart tekenen, dit kan een snelle schets zijn. Vergelijk uw oplossing
met die van mij. Zijn er verschillen, weet dat er meer dan één oplossing mogelijk is, misschien
is uw oplossing ook een goede oplossing. Denk er over na, twijfelt u, stel de vraag op het
forum en we bespreken dit.
6. Met de flowchart bij de hand, schrijft u de pseudocode uit op basis van uw, correcte,
flowchart.
7. Vervolgens probeert u uw pseudocode te vertalen en te programmeren in Python. Twijfelt u
aan de correcte syntax, neem dan gerust een kijkje naar mijn oplossing.
8. Doet uw programma wat het moet doen, oké, opdracht volbracht. Doet uw programma niet
wat het moet doen keer dan terug naar puntje 3 en probeer te achterhalen wat u mist of
waar het fout loopt. Vindt u de oplossing niet, deel uw foutieve code op het forum en we
bespreken dit.
9. Bijna iedere voorbeeldopdracht bevat wel iets nieuws, lees dus zeker ook mijn oplossing
eens door.
Doe dit niet allemaal in één lange sessie die tot in de nachtelijke uren loopt. Nee, maak regelmatig
een voorbeeldopdracht, 1 of 2 per dag, een half uurtje per dag. Iedere dag gedurende een paar
weken.
Inleiding 16
Linthoudt Geert
2 Sequentie
De sequentie is een opeenvolging van instructies, de ene na de andere. U leest de instructies van
boven naar beneden (of van links naar rechts zoals in Blueprint Visual Scripting van Unreal Engine).
In grote lijnen vindt u in de programmeercode steeds volgende structuur:
Invoer
opvragen
Bewerkingen
uitvoeren
Uitvoer
weergeven
Sequentie 17
Linthoudt Geert
2.1 “Hello World”

Toon de tekst “Hello World” op het scherm.
Sequentie 18
Linthoudt Geert
Uitvoer
 De tekst “Hello World”.
Invoer
 Geen invoer vereist.
Bewerkingen
 Geen bewerkingen (vermits er geen invoer is).
Opmerking
1. U stelt u steeds eerst de vraag welke uitvoer het programma verwacht. Wat moet het
programma doen?
2. Vervolgens, welke invoer hebt u nodig om de gewenste uitvoer te bekomen.
3. Tenslotte vraagt u zich af welke bewerkingen er moeten gebeuren op de invoer om de
gewenste uitvoer te bekomen.
Bovenstaande volgorde is niet altijd van toepassing. Het kan bijvoorbeeld zijn dat u een formule, een
bewerking, krijgt en dan vertrekt u vanuit deze formule.
Merk ook op dat ik in de vraagstelling een andere volgorde gebruikt dan in het programmeren zelf
waar u meestal:
1. De invoer opvraagt
2. De bewerking uitvoert
3. De uitvoer weergeeft
Sequentie 19
Linthoudt Geert
Sequentie 20
Linthoudt Geert
Pseudocode Python
OUTPUT “Hello World” print("Hello World")
Volledige code in Phyton.
print("Hello World")
Sequentie 21
Linthoudt Geert
 In https://www.online-python.com/ typt u de Python-code in, bovenaan, en drukt u op Run.

U ziet het resultaat onderaan.
Sequentie 22
Linthoudt Geert
Bovenaan hebt u een knopje waarmee u de code kunt bewaren op uw schijf.
Let op, Python-bestanden hebben de extensie .PY.
Indien u wenst kunt u uw code delen op sociale media.
Sequentie 23
Linthoudt Geert
2.2 “Hello, ” naam

Toon de tekst “Hello, ” gevolgd door uw naam.
Sequentie 24
Linthoudt Geert
Uitvoer
 De tekst “Hello, ” gevolgd door uw naam.
Invoer
 Uw naam.
Bewerkingen
 Geen bewerkingen.
Sequentie 25
Linthoudt Geert
Sequentie 26
Linthoudt Geert
Pseudocode Python
INPUT naam naam = input("Geef uw naam in: ")
OUTPUT “Hello, ” naam print("Hello, ", naam)
naam = input("Geef uw naam in: ")
print("Hello, ", naam)
Let op, een variabelenaam mag geen spaties bevatten!
Sequentie 27
Linthoudt Geert
Merk op dat ik in de uitvoer “Hello, Geert” eigenlijk een spatie te veel heb.
De print() functie in Python voegt zelf spaties toe tussen de verschillende delen. U hoeft deze zelf
niet te typen.
print("Hello, ", naam)
De spatie achter de komma binnen "Hello, " moest er dus niet staan. De spatie mag, moet, weg.
print("Hello,", naam)
Sequentie 28
Linthoudt Geert
Ziet u de fout in onderstaande code?
In Python, net als in vele, maar niet alle, programmeertalen, zijn namen hoofdlettergevoelig.
Onthoud dit, u zal de fout nog wel een paar keer maken!
Sequentie 29
Linthoudt Geert
2.3 “Hello,” familienaam + voornaam

Toon de tekst “Hello,” gevolgd door uw familienaam en uw voornaam.
Familienaam een voornaam worden afzonderlijk ingevoerd.
Sequentie 30
Linthoudt Geert
Uitvoer
 De tekst “Hello,” gevolgd door uw familienaam + voornaam.
Invoer
 familienaam
 voornaam
Bewerkingen
 naam = familienaam + “ ” + voornaam
Opmerking
 Bovenstaande bewerking voegt een spatie toe tussen de familienaam en de voornaam.
Sequentie 31
Linthoudt Geert
Sequentie 32
Linthoudt Geert
Pseudocode Python
INPUT familienaam familienaam = input("Geef uw familienaam in: ")
INPUT voornaam voornaam = input("Geef uw voornaam in: ")
STORE naam = familienaam + " " + voornaam naam = familienaam + " " + voornaam
OUTPUT “Hello,” naam print("Hello, ", naam)
#Invoer
familienaam = input("Geef uw familienaam in: ")
voornaam = input("Geef uw voornaam in: ")
#Bewerking
naam = familienaam + " " + voornaam
#Uitvoer
print("Hello,", naam)
Merk de commentaarlijntjes op, ik heb ze in het groen geplaatst. Nu de programmeercode iets

complexer wordt is dit handig, we gaan dit vanaf nu dan ook blijven doen. Commentaar dient enkel
ter verduidelijking van de programmeercode en wordt niet gecompileerd.
In Python begint commentaar met #.
Sequentie 33
Linthoudt Geert
Sequentie 34
Linthoudt Geert
2.4 Som
Tel twee getallen bij mekaar op.
Sequentie 35
Linthoudt Geert
Uitvoer
 De som van twee getallen.
Invoer
 Getal1
 Getal2
Bewerkingen
 som = getal1 + getal2
Opmerking
Hieronder ziet u de belangrijkste bewerkingsoperatoren van Python.
Operator Naam Voorbeeld

+ Optelling x+y
- Afrekking x-y
* Vermenigvuldigen x*y
/ Delen x/y
% Modulus (rest van de deling) x%y
** Exponentieel x ** y
(machtsverheffing)
// Integerdeling (enkel het x // y
integer gedeelte van de deling)
15 // 2 = 7
Sequentie 36
Linthoudt Geert
Sequentie 37
Linthoudt Geert
Pseudocode Python
INPUT getal1 getal1 = int(input("Getal 1: "))
INPUT getal2 getal2 = int(input("Getal 2: "))
STORE som = getal1 + getal2 som = getal1 + getal2
OUTPUT som print(getal1, " + ", getal2, " = ", som)
#Invoer
getal1 = int(input("Getal 1: "))
getal2 = int(input("Getal 2: "))
#Bewerking
som = getal1 + getal2
#Uitvoer
print(getal1, " + ", getal2, " = ", som)
Merk op dat de input geconverteerd wordt naar een geheel getal met de functie int().
int(input("Getal 1: "))
Om te converteren naar een kommagetal (een floating point) gebruikt u de functie float().
float(input("Getal 1: "))
Om een getal om te zetten naar een string (tekst) gebruikt u de functie str().
ToonGetallen = str(Getal1) + " + " + str(Getal2)
print(ToonGetallen, " = ", som)
Sequentie 38
Linthoudt Geert
Sequentie 39
Linthoudt Geert
Merk op dat als u geen getal ingeeft u een foutmelding krijgt.
Later, maar nog niet tijdens deze startercursus, gaan we deze fouten moeten opvangen. Voor nu
laten we deze fouten voor wat ze zijn en gaan we ervan uit dat de gebruiker de correcte waarden
invult.
Sequentie 40
Linthoudt Geert
Wat zou er gebeuren als we de int() functie niet toevoegen?
getal1 = input("Getal 1: ")
getal2 = input("Getal 2: ")
7 + 2 geeft nu de uitkomst 72.
Omdat we de conversie naar een integer getal, via int(), niet doen worden 7 en 2 niet gezien als een
getal maar als een teken en worden 7 en 2 samengevoegd tot 72 en niet opgeteld!
Sequentie 41
Linthoudt Geert
2.4.1 Functies
Als u naar de website https://www.online-python.com/ gaat dan ziet u er onderstaande code staan.
# Online Python - IDE, Editor, Compiler, Interpreter
def sum(a, b):
return (a + b)
a = int(input('Enter 1st number: '))
b = int(input('Enter 2nd number: '))
print(f'Sum of {a} and {b} is {sum(a, b)}')
Eigenlijk is dit dezelfde oefening als deze die we net besproken hebben.
Er zijn wel een paar verschillen, zo wordt een functie gebruikt.
def sum(a, b):
return (a + b)
 Het woordje def definieert een functie in Python.

 De naam van de functie is sum().
 Merk de : achteraan de functienaam op, deze bepaalt het begin van de functie.
 De functie krijgt 2 parameters mee a en b.
 Een functie geeft een uitkomt terug via return. In dit geval return (a + b).
 Let op de insprong, deze is nodig in Python.
De print wordt iets anders uitgewerkt dan wij tot nu toe gedaan hebben er wordt gewerkt met
placeholders.
print(f'Sum of {a} and {b} is {sum(a, b)}')
Merk het aanroepen van de functie op
sum(a, b)
De a gaat in parameter a en de b gaat in parameter b. Toevallig komen de namen hier overeen maar
dit is geen vereiste.
Het werken met functies is een belangrijke workflow in programmeren en is vooral heel nuttig
wanneer de functie complexere programmeercode bevat die herhaaldelijk hergebruikt moet worden.
Sequentie 42
Linthoudt Geert
Het belangrijkste voordeel is dat wanneer er aanpassingen moeten gebeuren aan de

programmeercode van de functie die aanpassingen enkel binnen de functie zelf gebeuren en meteen
doorgevoerd worden overal waar de functie aangeroepen wordt.
Hoewel ik het belang van functies niet genoeg kan onderlijnen, en we er later zeker gebruik gaan van
maken, ga ik ze verder in deze handleiding, op een enkele uitzondering na, niet gebruiken.
Voor de eerder eenvoudige berekeningen die we hier maken zou het gebruik van functies teveel van
het goede zijn en ons eerder afleiden van het doel van deze handleiding, namelijk gestructureerd
programmeren.
Sequentie 43
Linthoudt Geert
2.5 Conversie van Celsius naar Fahrenheit

De gebruiker geeft het aantal graden Celsius in. De computer moet de omrekening maken naar
graden Fahrenheit.
Sequentie 44
Linthoudt Geert
Uitvoer
 Graden fahrenheit.
Invoer
 Graden celsius
Bewerkingen
 fahrenheit = (9/5) * celsius + 32
Sequentie 45
Linthoudt Geert
Sequentie 46
Linthoudt Geert
Pseudocode Python
INPUT celsius celsius = int(input("Geef graden celsius in: "))
STORE fahrenheit = (9/5) * celsius + 32 fahrenheit = (9/5) * celsius + 32
OUTPUT fahrenheit print(celsius, "graden celsius =", fahrenheit,
"graden fahrenheit.")
#Invoer
celsius = int(input("Geef graden celsius in: "))
#Bewerking
fahrenheit = (9/5) * celsius + 32
#Uitvoer
print(celsius, "graden celsius =", fahrenheit, "graden fahrenheit.")
Sequentie 47
Linthoudt Geert
Sequentie 48
Linthoudt Geert
2.6 Bereken oppervlakte en omtrek van een rechthoek

Bereken de oppervlakte en omtrek van een rechthoek.
Sequentie 49
Linthoudt Geert
Uitvoer
 Oppervlakte van een rechthoek

 Omtrek van een rechthoek
Invoer
 Lengte van de rechthoek in cm

 Breedte van de rechthoek in cm
Bewerkingen
 oppervlakte = lengte * breedte

 omtrek = 2 * (lengte + breedte)
Sequentie 50
Linthoudt Geert
Sequentie 51
Linthoudt Geert
Pseudocode Python
INPUT lengte lengte = float(input("Geef de lengte van de
rechthoek in (cm): "))
INPUT breedte breedte = float(input("Geef de breedte van de
rechthoek in (cm): "))
STORE oppervlakte = lengte * breedte oppervlakte = lengte * breedte
STORE omtrek = 2 * (lengte + breedte) omtrek = 2 * (lengte + breedte)
OUTPUT oppervlakte print("Oppervlakte =", oppervlakte, "cm².")
OUTPUT omtrek print("Omtrek =", omtrek, "cm.")
#Invoer
lengte = float(input("Geef de lengte van de rechthoek in (cm): "))
breedte = float(input("Geef de breedte van de rechthoek in (cm): "))
#Bewerking
oppervlakte = lengte * breedte
omtrek = 2 * (lengte + breedte)
#Uitvoer
print("Oppervlakte =", oppervlakte, "cm².")
print("Omtrek =", omtrek, "cm.")
Sequentie 52
Linthoudt Geert
Sequentie 53
Linthoudt Geert
2.7 Bereken de oppervlakte en de omtrek van een cirkel

Bereken de oppervlakte en omtrek van een cirkel.
Sequentie 54
Linthoudt Geert
Uitvoer
 Oppervlakte van een cirkel

 Omtrek van een cirkel
Invoer
 Straal van de cirkel
Bewerkingen
 oppervlakte = straal * straal * π

 omtrek = 2 * straal * π
Opmerking
We hebben de waarde van π (pi) nodig. We kunnen deze zelf ingeven namelijk 3.1415927 of we
kunnen deze gaan halen uit de math-bibliotheek van Python.
Een bibliotheek is een verzameling van functies, de math-bibliotheek is een verzameling van
mathematische functies.
Om een bibliotheek te kunnen gebruiken moet deze eerst geïmporteerd worden.
Sequentie 55
Linthoudt Geert
Sequentie 56
Linthoudt Geert
Pseudocode Python
IMPORT Math import math
INPUT straal straal = float(input("Geef de straal van de cirkel
in: "))
STORE oppervlakte = straal * straal * π oppervlakte = round(straal * straal * math.pi, 2)
STORE omtrek = 2 * straal * π omtrek = round(2 * straal * math.pi, 2)
OUTPUT oppervlakte print("Oppervlakte =", oppervlakte)
OUTPUT omtrek print("Omtrek =", omtrek)
#Import
import math
#Invoer
straal = float(input("Geef de straal van de cirkel in: "))
#Bewerking
oppervlakte = round(straal * straal * math.pi, 2)
omtrek = round(2 * straal * math.pi, 2)
#Uitvoer
print("Oppervlakte =", oppervlakte)
print("Omtrek =", omtrek)
Merk op dat de functie round() wordt gebruikt om af te ronden, hier op 2 cijfer na de komma. Pi
wordt uit de bibliotheek math gehaald vandaar math.pi.
oppervlakte = round(straal * straal * math.pi, 2)
omtrek = round(2 * straal * math.pi, 2)
Sequentie 57
Linthoudt Geert
Sequentie 58
Linthoudt Geert
2.8 Tentoonstelling 1
U gaat met uw gezin, of met vrienden, naar een tentoonstelling.
 Voor kinderen onder de 12 jaar is de inkom gratis.

 Voor jongeren tussen 12 en 18 jaar is de inkom 20 €.
 Voor volwassenen is de inkom 30 €
Vraag naar het aantal kinderen, het aantal jongeren en het aantal volwassenen.
Bereken de te betalen inkomprijs.
Sequentie 59
Linthoudt Geert
Uitvoer
 Te betalen inkom
Invoer
 Aantal kinderen
 Aantal jongeren
 Aantal volwassenen
Bewerkingen
 PrijsKinderen = 0
 PrijsJongeren = Aantal jongeren * 20
 PrijsVolwassenen = Aantal volwassenen * 30
 Totaal = PrijsJongeren + PrijsVolwassenen
Opmerking
Omdat kinderen niets betalen is het niet echt nodig naar het aantal kinderen te vragen, ik heb het in
dit voorbeeld echter wel gedaan, doet u dit niet dan is dit ook oké.
Sequentie 60
Linthoudt Geert
Sequentie 61
Linthoudt Geert
Pseudocode Python
INPUT AantalKinderen AantalKinderen = int(input("Aantal kinderen
jonger dan 12 jaar: "))
INPUT AantalJongeren AantalJongeren = int(input("Aantal jongeren
tussen 12 en 18 jaar: "))
INPUT AantalVolwassenen AantalVolwassenen = int(input("Aantal
volwassenen (ouder dan 18 jaar): "))
STORE PrijsJongeren = Aantal jongeren * 20 PrijsJongeren = AantalJongeren * 20
STORE PrijsVolwassenen = Aantal volwassenen PrijsVolwassenen = AantalVolwassenen * 30
* 30
STORE Totaal = PrijsJongeren + Totaal = PrijsJongeren + PrijsVolwassenen
PrijsVolwassenen
OUTPUT Totaal print("Inkomprijs =", Totaal)
#Invoer
AantalKinderen = int(input("Aantal kinderen jonger dan 12 jaar: "))
AantalJongeren = int(input("Aantal jongeren tussen 12 en 18 jaar: "))
AantalVolwassenen = int(input("Aantal volwassenen (ouder dan 18 jaar):
"))
#Bewerking
PrijsJongeren = AantalJongeren * 20
PrijsVolwassenen = AantalVolwassenen * 30
Totaal = PrijsJongeren + PrijsVolwassenen
#Uitvoer
print("Inkomprijs =", Totaal)
Sequentie 62
Linthoudt Geert
Sequentie 63
Linthoudt Geert
2.9 Factuur 1
Maak een eenvoudige factuur aan die de prijs exclusief BTW van de factuur en het BTW-percentage
opvraagt en vervolgens de BTW en de prijs inclusief BTW berekent.
Sequentie 64
Linthoudt Geert
Uitvoer
 BTW
 Prijs inclusief BTW
Invoer
 Prijs exclusief BTW

 BTW-percentage
Bewerkingen
 BTW = Prijs exclusief BTW / 100 * BTW-percentage

 Prijs inclusief BTW = Prijs exclusief BTW + BTW
Sequentie 65
Linthoudt Geert
Sequentie 66
Linthoudt Geert
Pseudocode Python
INPUT Prijs exclusief BTW PrijsExclusiefBTW = float(input("Geef de prijs
zonder BTW in: "))
INPUT BTW-Percentage BTW_Percentage = float(input("Geef het BTW-
percentage in: "))
STORE BTW = Prijs exclusief BTW / 100 * BTW- BTW = PrijsExclusiefBTW / 100 *
percentage BTW_Percentage
STORE Prijs inclusief BTW = Prijs exclusief BTW PrijsInclusiefBTW = PrijsExclusiefBTW + BTW
+ BTW
OUTPUT BTW print("BTW =", round(BTW, 2), "€.")
OUTPUT Prijs inclusief BTW print("Prijs inclusief BTW =",
round(PrijsInclusiefBTW, 2), "€.")
#Invoer
PrijsExclusiefBTW = float(input("Geef de prijs zonder BTW in: "))
BTW_Percentage = float(input("Geef het BTW-percentage in: "))
#Bewerking
BTW = PrijsExclusiefBTW / 100 * BTW_Percentage
PrijsInclusiefBTW = PrijsExclusiefBTW + BTW
#Uitvoer
print("BTW =", round(BTW, 2), "€.")
print("Prijs inclusief BTW =", round(PrijsInclusiefBTW, 2), "€.")
Sequentie 67
Linthoudt Geert
Sequentie 68
Linthoudt Geert
2.10 Punten
Schrijf een programma dat de score van drie toetsen op 20 inleest.
Bereken vervolgens de totaalscore, het gemiddelde en het percentage.
Sequentie 69
Linthoudt Geert
Uitvoer
 Totaalscore
 Gemiddeldescore
 Percentage
Invoer
 punt1
 punt2
 punt3
Bewerkingen
 totaalscore = punt1 + punt2 + punt3

 gemiddeldescore = totaalscore / 3
 percentage = Totaalscore / 60 * 100
Opmerking
Een toets staat op 20 punten en er zijn 3 toetsen, 3 x 20 = 60. Vandaar die 60.
Sequentie 70
Linthoudt Geert
Sequentie 71
Linthoudt Geert
Pseudocode Python
INPUT punt1 punt1 = float(input("Geef punt1 in op 20: "))
STORE totaalscore= punt1 + punt2 + punt3 totaalscore = punt1 + punt2 + punt3
STORE gemiddeldescore = totaalscore / 3 gemiddeldescore = totaalscore / 3
STORE percentage = Totaalscore / 60 * 100 Percentage = totaalscore / 60 * 100
OUTPUT totaalscore print("Totaalscore =", round(totaalscore, 2))
OUTPUT gemiddeldescore print("Gemiddelde score =",
round(gemiddeldescore, 2))
OUTPUT percentage print("Percentage =", round(Percentage, 2),
"%")
#Invoer
punt1 = float(input("Geef punt1 in op 20: "))
#Bewerking
totaalscore = punt1 + punt2 + punt3
gemiddeldescore = totaalscore / 3
Percentage = totaalscore / 60 * 100
#Uitvoer
print("Totaalscore =", round(totaalscore, 2))
print("Gemiddelde score =", round(gemiddeldescore, 2))
print("Percentage =", round(Percentage, 2), "%")
Sequentie 72
Linthoudt Geert
Sequentie 73
Linthoudt Geert
2.11 Verbruik
Stel, uw wagen verbruikt 4.3 liter benzine per 100 km. Dit is een vast gegeven aangezien u minstens
10 jaar met de wagen wilt rijden.
U wilt berekenen hoeveel een ritje met de wagen kost.
Sequentie 74
Linthoudt Geert
Uitvoer
 Verbruik
Invoer
 Prijs voor een liter benzine

 Aantal kilometers
Bewerkingen
Dit is een klassieke regel van 3.
4.3 liter -> 100 km
4.3 / 100 liter -> 1 km
Nu we weten hoeveel het verbruik is per liter kunt u gemakkelijk de prijs berekenen op basis van het
aantal gereden kilometers.
De formule is: 4.3 / 100 * aantalkilometers * prijsperkilometer
Sequentie 75
Linthoudt Geert
Sequentie 76
Linthoudt Geert
Pseudocode Python
INPUT prijs per kilometer prijsperkilometer = float(input("Geef de
benzineprijs van de tankbeurt in: "))
INPUT aantal kilometers aantalkilometers = float(input("Geef het aantal
gereden kilometers in: "))
STORE verbruik = 4.3 / 100 * aantalkilometers * verbruik = 4.3 / 100 * aantalkilometers *
prijsperkilometer prijsperkilometer
OUTPUT verbruik print("Het verbruik is", round(verbruik, 2), "€.")
#Invoer
prijsperkilometer = float(input("Geef de benzineprijs van de tankbeurt
in: "))
aantalkilometers = float(input("Geef het aantal gereden kilometers in:
"))
#Bewerking
verbruik = 4.3 / 100 * aantalkilometers * prijsperkilometer
#Uitvoer
print("Het verbruik is", round(verbruik, 2), "€.")
Sequentie 77
Linthoudt Geert
Sequentie 78
Linthoudt Geert
2.12 Bestelling
Om de plaatselijke vereniging te helpen bij hun jaarlijkse festiviteit ontwerpen we een
programmaatje dat de bestellingen berekent. Om gemakkelijk te werken zijn er maar een beperkt
aantal bestellingen mogelijk die allen een vaste prijs hebben:
 Frisdrank = 2 €
 Chips = 1.5 €
 Hamburgers = 3 €
Sequentie 79
Linthoudt Geert
Uitvoer
 Totaal bestelde frisdranken

 Totaal bestelde chips
 Totaal bestelde hamburgers
 Totaal van de bestelling
Invoer
 Aantal bestelde frisdranken

 Aantal bestelde chips
 Aantal bestelde hamburgers
Bewerkingen
 totaalfrisdrank = aantal bestelde frisdranken * 2

 totaalchips = aantal bestelde chips * 1.5
 totaalhamburgers = aantal bestelde hamburgers * 3
 totaalbestelling = totaalfrisdrank + totaalchips + totaalhamburgers
Sequentie 80
Linthoudt Geert
Ik heb ervoor gekozen de meerdere INPUTs en OUTPUTs samen te nemen, dit om het overzicht te
behouden. Ik had deze ook mogen uitsplitsen zoals ik gedaan heb voor de berekeningen.
Sequentie 81
Linthoudt Geert
Pseudocode Python
INPUT aantalfrisdrank aantalfrisdrank = int(input("Geef het aantal
bestelde frisdranken in: "))
INPUT aantalchips aantalchips = int(input("Geef het aantal bestelde
chips in: "))
INPUT aantalhamburgers int(input("Geef het aantal bestelde hamburgers
in: "))
STORE totaalfrisdrank = aantalfrisdrank * 2 totaalfrisdrank = aantalfrisdrank * 2
STORE totaalchips = aantalchips * 1.5 totaalchips = aantalchips * 1.5
STORE totaalhamburgers = aantalhamburgers * totaalhamburgers = aantalhamburgers * 3
3
STORE totaalbestelling = totaalfrisdrank + totaalbestelling = totaalfrisdrank + totaalchips +
totaalchips + totaalhamburgers totaalhamburgers
OUTPUT totaalfrisdrank print("Totaal bestelde frisdranken =",
totaalfrisdrank)
OUTPUT totaalchips print("Totaal bestelde chips =", totaalchips)
OUTPUT totaalhamburgers print("Totaal bestelde hamburgers =",
totaalhamburgers)
OUTPUT totaalbestelling print("Totaal bestelling =", totaalbestelling)
#Invoer
aantalfrisdrank = int(input("Geef het aantal bestelde frisdranken in:
"))
aantalchips = int(input("Geef het aantal bestelde chips in: "))
aantalhamburgers = int(input("Geef het aantal bestelde hamburgers in:
"))
#Bewerking
totaalfrisdrank = aantalfrisdrank * 2
totaalchips = aantalchips * 1.5
totaalhamburgers = aantalhamburgers * 3
totaalbestelling = totaalfrisdrank + totaalchips + totaalhamburgers
#Uitvoer
print("Totaal bestelde frisdranken =", totaalfrisdrank)
print("Totaal bestelde chips =", totaalchips)
print("Totaal bestelde hamburgers =", totaalhamburgers)
print("Totaal bestelling =", totaalbestelling)
Sequentie 82
Linthoudt Geert
Sequentie 83
Linthoudt Geert
2.13 Stringcommando’s in Python

Dit is geen “opdracht” maar een aantal voorbeelden voor het werken met strings (een tekenreeks) in
Python.
Bestudeer onderstaande code, ik heb de belangrijkste code gemarkeerd:
Tekst = "Zeven Zaventemse zotten zullen zeven zomerse zondagen zwemmen
zonder zwembroek. Ze zijn zot ze zullen zinken."
print(Tekst)
print("Lengte:", len(Tekst))
print("Aantal spaties:", Tekst.count(" "))
print("Positie van het eerste punt:", Tekst.index("."))
print("In hoofdletters:", Tekst.upper())
print("In kleine letters:", Tekst.lower())
print("Vervang z door p:", Tekst.replace("z","p"))
Tekst = Tekst.upper()
print("Vervang z door p in hoofdletters:", Tekst.replace("Z","P"))
Sequentie 84
Linthoudt Geert
Sequentie 85
Linthoudt Geert
Een string is een tekenreeks, een lijst van tekens, of in het jargon van de programmeurs een array
(hoewel Python hier een uitzondering op is en enkel spreekt van een lijst en niet van een array).
U kunt dan ook een string behandelen als een geïndexeerde lijst van tekens die begint bij 0, het
eerste teken van de string heeft dus de index 0.
Een paar voorbeelden:
Tekst = "CVO Groeipunt"
print("Eerste teken:", Tekst[0])
print("Laatste teken:", Tekst[-1])
print("Derde teken:", Tekst[2])
print("Eerste drie tekens:", Tekst[:3])
print("Alle tekens vanaf het vierde teken:", Tekst[4:])
print("Laatste 4 tekens:", Tekst[-4:])
print("Teken 4 tot 9:", Tekst[4:9])
print("Tekst omgekeerd:", Tekst[::-1])
Sequentie 86
Linthoudt Geert
Sequentie 87
Linthoudt Geert
3 Selectie
In het dagelijks leven doen we het constant, beslissingen nemen. Als een bepaalde conditie vervult
is dan… anders…. Als het regent dan nemen we de auto anders gaan we per fiets.
In een computerprogramma is het niet anders. Ook hier zullen heel vaak beslissingen genomen
dienen te worden. De beslissingen worden genomen naargelang de uitkomst van
een vergelijking (een conditie) waar is of onwaar is. Is deze vergelijking waar, dan gaat het
programma de Waar-kant uit, anders, de vergelijking is onwaar, dan gaat het de Onwaar-kant uit.
Beslissingen worden genomen door middel van programmeercode gebruikmakend van Conditional
Statements.
Selectie 88
Linthoudt Geert
Selectie 89
Linthoudt Geert
Selectie 90
Linthoudt Geert
3.1 Boolean expressie

Een Boolean expressie is een expressie (een stelling) die enkel de uitkomst waar (true)
of onwaar (false) kan hebben.
De beslissing bestaat uit een conditie/vergelijking en is ene booleaanse expressie. De uitkomst van
de vergelijking is dus ofwel Waar (true) ofwel Onwaar (false).
Een conditie kan ook uit meerdere vergelijkingen bestaan. Meerdere vergelijkingen worden aan
mekaar verbonden door logische operatoren.
3.1.1 Vergelijkingsoperatoren in Python

Operator Omschrijving Voorbeeld
== Gelijk x == y
!= Niet gelijk x != y
> Groter dan x>y
< Kleiner dan x<y
>= Groter dan of gelijk aan x >= y
<= Kleiner dan of gelijk aan x <= y
3.1.2 Logische operatoren in Phyton

and Returns True als alle x < 5 and x < 10
statements True zijn
or Returns True als één van de x < 5 or x < 4
statements True is
not Keert het resultaat om not(x < 5 and x < 10)
Vergelijking 1 Vergelijking 2 1 AND 2 1 OR 2 NOT 1

true true true true false
true false false true false
false true false true true
false false false false true
Selectie 91
Linthoudt Geert
3.1.3 Syntax in Python

if conditie1:
#acties indien conditie1 waar is
elif conditie2:
#acties indien conditie1 onwaar is en conditie2 waar is
else:
#acties indien conditie1 onwaar is en conditie2 ook onwaar is
 Merk de : op!
 De insprong van de acties is nodig (en niet optioneel) in Python.
Selectie 92
Linthoudt Geert
3.2 Is een getal positief?

Geef een getal in.
Als het getal groter dan of gelijk is aan 0 dan wordt de tekst “Getal is positief” getoond.
Selectie 93
Linthoudt Geert
Uitvoer
 “Positief”
Invoer
 Getal
Bewerkingen
 If Getal >= 0 then “Positief”
Selectie 94
Linthoudt Geert
Selectie 95
Linthoudt Geert
Pseudocode Python
INPUT getal int(input("Geef een getal in:"))
IF getal >= 0 THEN if getal >= 0:
OUTPUT “Positief” print(getal, "is positief.")
#Invoer
getal = int(input("Geef een getal in:"))
#Bewerking
if getal >= 0:
#Uitvoer
print(getal, "is positief.")
Let op de : op het einde van if getal >= 0:.
Selectie 96
Linthoudt Geert
Selectie 97
Linthoudt Geert
Geeft u een negatief getal in dan krijgt u geen uitvoer.
Selectie 98
Linthoudt Geert
Let op, de insprong is essentieel voor Python, laat u deze weg dan krijgt u een foutmelding
“IdentationError: expected an indented Block”.
Selectie 99
Linthoudt Geert
3.3 Is een getal positief of negatief?

Geef een getal in.
Als het getal groter dan of gelijk is aan 0 dan wordt de tekst “Getal is positief” getoond anders
verschijnt de tekst “Getal is negatief”.
Selectie 100
Linthoudt Geert
Uitvoer
 “Positief”
 “Negatief”
Invoer
 Getal
Bewerkingen
 If Getal >= 0 then “Positief” else “Negatief”
Opmerking
Deze opdracht is een uitbreiding van de vorige opdracht, u kunt dus de vorige oplossing als basis
nemen, patroonherkenning.
Selectie 101
Linthoudt Geert
Selectie 102
Linthoudt Geert
Pseudocode Python
IF getal >= 0 THEN if getal >= 0:
ELSE else:
OUTPUT “Negatief” print(getal, "is negatief.")
#Invoer
#Bewerking
if getal >= 0:
#Uitvoer
else:
#Uitvoer
print(getal, "is negatief.")
Selectie 103
Linthoudt Geert
Selectie 104
Linthoudt Geert
Selectie 105
Linthoudt Geert
3.4 Is een getal positief, negatief of nul?

Geef een getal in.
Als het getal groter dan is dan 0 dan wordt de tekst “Getal is positief” getoond anders als het getal
kleiner is dan 0 is dan verschijnt de tekst “Getal is negatief” anders, het getal is gelijk aan nul,
verschijnt “Getal is nul”.
Selectie 106
Linthoudt Geert
Uitvoer
 “Positief”
 “Negatief”
 “Nul”
Invoer
 Getal
Bewerkingen
 If Getal > 0 then “Positief” else if getal < 0 then “Negatief” else “Nul”
Opmerking
Deze opdracht is een uitbreiding van de vorige opdracht, u kunt dus de vorige oplossing als basis
nemen, patroonherkenning.
Selectie 107
Linthoudt Geert
Selectie 108
Linthoudt Geert
Pseudocode Python
IF getal > 0 THEN if getal >= 0:
ELSE IF getal < 0 THEN elif getal < 0:
OUTPUT “Negatief” print(getal, "is negatief.")
ELSE else:
OUTPUT “Nul” print(getal, "is nul.")
#Invoer
#Bewerking
if getal > 0:
#Uitvoer
elif getal < 0:
#Uitvoer
print(getal, "is negatief.")
else:
#Uitvoer
print(getal, "is nul.")
Selectie 109
Linthoudt Geert
Selectie 110
Linthoudt Geert
Selectie 111
Linthoudt Geert
Selectie 112
Linthoudt Geert
3.5 Gratis verzending

Geef de aankoopprijs in. Als de aankoopprijs groter dan of gelijk is aan 50 euro dan is de verzending
gratis, anders wordt er 5 euro verzendingskosten aangerekend.
Selectie 113
Linthoudt Geert
Uitvoer
 Totaalprijs
Invoer
 Aankoopprijs
Bewerkingen
 If Aankoopprijs >= 50 then Aankoopprijs else Aankoopprijs + 5
Opmerking
Deze opdracht heeft net als de opdracht “Is een getal positief of negatief?” twee opties, de structuur
zal dus gelijkaardig zijn.
Selectie 114
Linthoudt Geert
Opmerking, er zijn andere structuren mogelijk die ook een correcte oplossing bieden.
Selectie 115
Linthoudt Geert
Zo zou u de Output binnen de If-structuur kunnen opnemen en geen variabele totaalprijs gebruiken.
Dit zou eveneens een goede oplossing zijn.
Selectie 116
Linthoudt Geert
Nog een optie kan de onderstaande zijn. Hier wordt gecontroleerd of de aankoopprijs kleiner is dan
50 en indien dit het geval is dan wordt de aankoopprijs verhoogt met 5 euro. Tenslotte wordt de
aankoopprijs weergegeven.
U ziet, er zijn meerder oplossingen mogelijk.
Ik ga de laatste verder uitwerken.
Selectie 117
Linthoudt Geert
Pseudocode Python
INPUT aankoopprijs aankoopprijs = int(input("Geef de aankoopprijs
in:"))
IF aankoopprijs < 50 THEN if aankoopprijs < 50:
STORE aankoopprijs = aankoopprijs + 5 aankoopprijs = aankoopprijs + 5
OUTPUT aankoopprijs print("De totale prijs is", aankoopprijs, "€.")
#Invoer
aankoopprijs = int(input("Geef de aankoopprijs in:"))
#Bewerking
if aankoopprijs < 50:
#Bewerking
aankoopprijs = aankoopprijs + 5
#Uitvoer
print("De totale prijs is", aankoopprijs, "€.")
Selectie 118
Linthoudt Geert
Selectie 119
Linthoudt Geert
Selectie 120
Linthoudt Geert
3.6 Factuur 2
Maak een eenvoudige factuur aan die de prijs exclusief BTW van de factuur en het BTW-percentage
opvraagt en vervolgens de BTW en de prijs inclusief BTW berekent. Bij contante betaling wordt 10%
korting gegeven.
Wacht even, hebben we niet een gelijkaardige oefening gemaakt? Patroonherkenning!
Selectie 121
Linthoudt Geert
Dit was de vorige oefening Factuur:
Uitvoer
 BTW
Invoer

 BTW-percentage
Bewerkingen

Selectie 122
Linthoudt Geert
Selectie 123
Linthoudt Geert
Pseudocode Python
zonder BTW in: "))
percentage in: "))
+ BTW
#Invoer
#Bewerking
#Uitvoer
Selectie 124
Linthoudt Geert
We kunnen van deze oplossing starten en “gewoon” uitbreiden met het nieuwe gegeven: “10%
korting bij contante betaling.
Ik geef de toegevoegde tekst en code in kleur aan.
Uitvoer
 Prijs na korting
 BTW
Invoer

 BTW-percentage
 Contante betaling?
Bewerkingen
 If contantebetaling = true then Prijs exclusief BTW * 0.9

Selectie 125
Linthoudt Geert
Selectie 126
Linthoudt Geert
Pseudocode Python
zonder BTW in: "))
percentage in: "))
INPUT ContanteBetaling ContanteBetaling = input("Contante betaling?
(j/n): ")
IF contantebetaling = true THEN if ContanteBetaling.lower() == "j":
STORE Prijs exclusief BTW * 0.9 PrijsExclusiefBTW =
PrijsExclusiefBTW * 0.9
+ BTW
OUTPUT Prijs na korting print("Prijs na eventuele korting =",
round(PrijsExclusiefBTW, 2), "€.")
#Invoer
ContanteBetaling = input("Contante betaling? (j/n): ")
#Bewerking
if ContanteBetaling.lower() == "j":
PrijsExclusiefBTW = PrijsExclusiefBTW * 0.9
#Uitvoer
print("Prijs na eventuele korting =", round(PrijsExclusiefBTW, 2),
"€.")
Selectie 127
Linthoudt Geert
Met de functie lower() wordt tekst omgezet naar kleine letters: ContanteBetaling.lower()== "j"
Selectie 128
Linthoudt Geert
Selectie 129
Linthoudt Geert

Vraag naar de leeftijd.
Bereken de te betalen inkomprijs per persoon.
Selectie 130
Linthoudt Geert
Uitvoer
 Te betalen inkom per persoon
Invoer
 leeftijd
Bewerkingen
 If leeftijd >= 18 then “30 €” else if leeftijd < 12 then “Gratis” else “20 €”
Opmerking
Dit is een gelijkaardige opdracht als de opdracht Tentoonstelling 1 uit het vorige hoofdstuk maar
omdat er nu niet naar het aantal kinderen, aantal jongeren en aantal volwassenen gevraagd wordt,
maar wel naar de leeftijd, krijgen we een andere uitwerking.
Selectie 131
Linthoudt Geert
Selectie 132
Linthoudt Geert
Pseudocode Python
INPUT leeftijd leeftijd = int(input("Geef je leeftijd in:"))
IF leeftijd >= 18 THEN if leeftijd >= 18:
OUTPUT “Inkom is 30 €.” print("Inkom is 30 €.")
ELSE IF leeftijd < 12 THEN elif leeftijd < 12:
OUTPUT “Inkom is gratis.” print("Inkom is gratis.")
ELSE else:
OUTPUT “getal is nul” print("Inkom is 20 €.")
#Invoer
leeftijd = int(input("Geef je leeftijd in:"))
#Bewerking
if leeftijd >= 18:
#Uitvoer
print("Inkom is 30 €.")
elif leeftijd < 12:
#Uitvoer
print("Inkom is gratis.")
else:
#Uitvoer
print("Inkom is 20 €.")
Selectie 133
Linthoudt Geert
Selectie 134
Linthoudt Geert
Selectie 135
Linthoudt Geert
Selectie 136
Linthoudt Geert
3.8 Welke taxi?

Er zijn twee taxibedrijven:
Bij Taxi Noord wordt de prijs van een taxirit als volgt berekend: 20 € startkosten op te tellen bij 2 €
per kilometer.
Bij Taxi Noord wordt de prijs van een taxirit als volgt berekend: 50 € startkosten op te tellen bij 1.5 €
per kilometer.
Geef het aantal te rijden kilometers in en laat de computer u vertellen welk taxibedrijf het
goedkoopst is.
Selectie 137
Linthoudt Geert
Uitvoer
 Goedkoopste taxibedrijf
Invoer
 Aantal kilometers
Bewerkingen
 TaxiNoord = 20 + AantalKilometers * 2
 TaxiZuid = 50 + AantalKilometers * 1.5
 If TaxiNoord < TaxiZuid then “TaxiNoord” else “TaxiZuid”
Selectie 138
Linthoudt Geert
Selectie 139
Linthoudt Geert
Pseudocode Python
INPUT AantalKilometers AantalKilometers = int(input("Geef het aantal
kilometers in:"))
STORE TaxiNoord = 20 + AantalKilometers * 2 TaxiNoord = 20 + (AantalKilometers * 2)
STORE TaxiZuid = 50 + AantalKilometers * 1.5 TaxiZuid = 50 + (AantalKilometers * 1.5)
IF TaxiNoord < TaxiZuid THEN if TaxiNoord < TaxiZuid:
OUTPUT “TaxiNoord” print("TaxiNoord is het goedkoopst met
een prijs van", TaxiNoord, "€.")
ELSE else:
OUTPUT “TaxiZuid” print("TaxiZuid is het goedkoopst
met een prijs van", TaxiZuid, "€.")
#Invoer
AantalKilometers = int(input("Geef het aantal kilometers in:"))
#Bewerking
TaxiNoord = 20 + (AantalKilometers * 2)
TaxiZuid = 50 + (AantalKilometers * 1.5)
if TaxiNoord < TaxiZuid:
#Uitvoer
print("TaxiNoord is het goedkoopst met een prijs van", TaxiNoord,
"€.")
else:
#Uitvoer
print("TaxiZuid is het goedkoopst met een prijs van", TaxiZuid,
"€.")
Selectie 140
Linthoudt Geert
Selectie 141
Linthoudt Geert
Selectie 142
Linthoudt Geert
Selectie 143
Linthoudt Geert
3.9 Premie
Bij de heraanleg van de straat moet het regenwater gescheiden worden van het afvalwater.
De stad heeft een tegemoetkoming van 75% met een maximum van 1750 €.
Geef de kostprijs van de werken in.
Bereken de premie en de eigenkosten.
Selectie 144
Linthoudt Geert
Uitvoer
 Premie
 Eigenkost
Invoer
 Kost
Bewerkingen
 Premie = Kost * 0.75

 If Premie > 1750 then Premie = 1750
 Eigenkost = Kost - Premie
Selectie 145
Linthoudt Geert
Selectie 146
Linthoudt Geert
Pseudocode Python
INPUT Kost Kost = float(input("Geef de kostprijs van de
werken in:"))
STORE Premie = Kost * 0.75 Premie = Kost * 0.75
IF Premie > 1750 THEN if Premie > 1750:
Premie = 1750 Premie = 1750
STORE Eigenkost = Kost - Premie Eigenkost = Kost - Premie
OUTPUT Eigenkost print("De eigenkost bedraagt:", Eigenkost, "€.")
OUTPUT Premie print("De premie bedraagt:", Premie, "€.")
#Invoer
Kost = float(input("Geef de kostprijs van de werken in:"))
#Bewerking
Premie = Kost * 0.75
if Premie > 1750:
Premie = 1750
Eigenkost = Kost - Premie
#Uitvoer
print("De eigenkost bedraagt:", Eigenkost, "€.")
print("De premie bedraagt:", Premie, "€.")
Selectie 147
Linthoudt Geert
Selectie 148
Linthoudt Geert
Selectie 149
Linthoudt Geert
3.10 Geslaagd of niet

Om geslaagd te zijn moet aan 3 condities voldaan zijn:
 De cursist moet minimaal 50 % halen,

 de cursist mag niet meer dan 1 tekort hebben,
 de cursist mag niet meer dan 2 keer onwettig afwezig zijn.
Selectie 150
Linthoudt Geert
Uitvoer
 Geslaagd of niet
Invoer
 Percentage
 Aantal tekorten
 Aantal onwettige afwezigheden
Bewerkingen
 If Percentage >= 50 and AantalTekorten <= 1 and AantalOnwettigeAfwezigheden <= 2 then

“Geslaagd” else “Niet geslaagd”
Opmerking
U kunt dit ook juist omgekeerd benaderen namelijk
 If Percentage < 50 or AantalTekorten > 1 or AantalOnwettigeAfwezigheden > 2 then “Niet

geslaagd” else “Geslaagd”
Aan u de keuze.
De moeilijkheid in deze oefening ligt in de meerdere condities die u moet combineren. Ik herneem
nog eens de tabellen die u kunnen helpen.

statements True is

Selectie 151
Linthoudt Geert
Selectie 152
Linthoudt Geert
Pseudocode Python
INPUT Percentage Percentage = float(input("Geef het percentage
in:"))
INPUT Aantal tekorten AantalTekorten = int(input("Geef het aantal
tekorten in:"))
INPUT Aantal onwettige afwezigheden AantalOnwettigAfwezig = int(input("Geef het
aantal onwettige afwezigheden in:"))
IF Percentage >= 50 and AantalTekorten <= 1 if Percentage >= 50 and AantalTekorten <= 1 and
and AantalOnwettigeAfwezigheden <= 2 THEN AantalOnwettigAfwezig <= 2 :
OUTPUT “Geslaagd.” print("Geslaagd.")
ELSE else:
OUTPUT “Niet geslaagd!” print("Niet geslaagd!")
#Invoer
Percentage = float(input("Geef het percentage in:"))
AantalTekorten = int(input("Geef het aantal tekorten in:"))
AantalOnwettigAfwezig = int(input("Geef het aantal onwettige
afwezigheden in:"))
#Bewerking
if Percentage >= 50 and AantalTekorten <= 1 and AantalOnwettigAfwezig
<= 2 :
#Uitvoer
print("Geslaagd.")
else:
#Uitvoer
print("Niet geslaagd!")
Selectie 153
Linthoudt Geert
Selectie 154
Linthoudt Geert
Selectie 155
Linthoudt Geert
3.11 Geslaagd met…

Om geslaagd te zijn moet aan 3 condities voldaan zijn:
 De cursist moet minimaal 50 % halen,

 de cursist mag niet meer dan 1 tekort hebben,
 de cursist mag niet meer dan 2 keer onwettig afwezig zijn.
Bijkomend:
 Indien de cursist geslaagd is met een % tussen de 50% (inbegrepen) en de 70% dan is hij
“Geslaagd met voldoening”.
 Indien de cursist geslaagd is met een % tussen de 70% (inbegrepen) en de 90% dan is hij
“Geslaagd met onderscheiding”.
 Indien hij geslaagd is met een % van 90% of meer dan is hij “Geslaagd met grote
onderscheiding”.
Selectie 156
Linthoudt Geert
Uitvoer
 Geslaagd of niet
 “Geslaagd met voldoening” of “Geslaagd met onderscheiding” of “Geslaagd met grote
onderscheiding”
Invoer
 Percentage
 Aantal tekorten
 Aantal onwettige afwezigheden
Bewerkingen
 If Percentage >= 50 and AantalTekorten <= 1 and AantalOnwettigeAfwezigheden <= 2 then

“Geslaagd” else “Niet geslaagd”
 If Percentage >= 90 then “Geslaagd met grote onderscheiding” else If Percentage >=70 then
“Geslaagd met onderscheiding” else “Geslaagd met voldoening”
Opmerking
Dit is een uitbreiding op de vorige opdracht die u als basis kunt gebruiken.
De uitbreiding is dat indien de cursist geslaagd is er niet enkel moet komen “Geslaagd” maar ook, op
basis van het percentage, de wijze waarop.
Er zijn opnieuw verschillende benaderingen mogelijk maar ik denk dat van hoog naar laag vaak het
gemakkelijkste is.
If Percentage >= 90 then “Geslaagd met grote onderscheiding” else If Percentage >=70 then
“Geslaagd met onderscheiding” else “Geslaagd met voldoening”
Selectie 157
Linthoudt Geert
Selectie 158
Linthoudt Geert
Pseudocode Python
INPUT Percentage Percentage = float(input("Geef het percentage
in:"))
INPUT Aantal tekorten AantalTekorten = int(input("Geef het aantal
tekorten in:"))
INPUT Aantal onwettige afwezigheden AantalOnwettigAfwezig = int(input("Geef het
aantal onwettige afwezigheden in:"))
IF Percentage >= 50 and AantalTekorten <= 1 if Percentage >= 50 and AantalTekorten <= 1 and
and AantalOnwettigeAfwezigheden <= 2 THEN AantalOnwettigAfwezig <= 2 :
IF Percentage >= 90 THEN if Percentage >= 90:
OUTPUT “Geslaagd met grote print("Geslaagd met grote
onderscheiding.” onderscheiding.")
ELSE IF Percentage >= 70 THEN elif Percentage >= 70:
OUTPUT “Geslaagd met print("Geslaagd met
onderscheiding.” onderscheiding.")
ELSE else:
OUTPUT “Geslaagd met print("Geslaagd met
voldoening.” voldoening.")
ELSE else:
OUTPUT “Niet geslaagd!” print("Niet geslaagd!")
Selectie 159
Linthoudt Geert
#Invoer
Percentage = float(input("Geef het percentage in:"))
AantalTekorten = int(input("Geef het aantal tekorten in:"))
AantalOnwettigAfwezig = int(input("Geef het aantal onwettige
afwezigheden in:"))
#Bewerking
if Percentage >= 50 and AantalTekorten <= 1 and AantalOnwettigAfwezig
<= 2 :
if Percentage >= 90:
#Uitvoer
print("Geslaagd met grote onderscheiding.")
elif Percentage >= 70:
#Uitvoer
print("Geslaagd met onderscheiding.")
else:
#Uitvoer
print("Geslaagd met voldoening.")
else:
#Uitvoer
print("Niet geslaagd!")
Selectie 160
Linthoudt Geert
Selectie 161
Linthoudt Geert
Selectie 162
Linthoudt Geert
Selectie 163
Linthoudt Geert
4 Iteratie (herhalingen)
Een Selectie gaat op basis van een conditie die al dan niet waar is een keuze maken en een bepaalde
richting uit gaan.
Iteratie (herhaling) 164

Linthoudt Geert
Een Iteratie, een herhaling, herhaalt iets zolang de conditie waar is.
Gebruik een zeshoek als symbool voor de herhaling.

Linthoudt Geert
4.1 Boolean expressie

Net als bij de Selectie worden Booleaanse expressies gebruikt. Ik herhaal nog eens.
Een Boolean expressie is een expressie (een stelling) die enkel de uitkomst waar (true)
of onwaar (false) kan hebben.
De beslissing bestaat uit een conditie/vergelijking en is ene booleaanse expressie. De uitkomst van
de vergelijking is dus ofwel Waar (true) ofwel Onwaar (false).
Een conditie kan ook uit meerdere vergelijkingen bestaan. Meerdere vergelijkingen worden aan
mekaar verbonden door logische operatoren.
4.1.1 Vergelijkingsoperatoren in Python

== Gelijk x == y
!= Niet gelijk x != y
> Groter dan x>y
< Kleiner dan x<y
>= Groter dan of gelijk aan x >= y
<= Kleiner dan of gelijk aan x <= y

statements True is


Linthoudt Geert
4.2 Soorten herhalingen

Er zijn twee soorten Iteraties/herhalingen:
De begrensde herhaling – het aantal keer dat de herhaling plaats vindt, de lus moet doorlopen
worden, ligt vast.
De voorwaardelijke herhaling – de herhaling blijft duren zolang een voorwaarde geldt (waar is).

Linthoudt Geert
4.2.1 Begrensde herhaling in Python

for variabele in range(teller):
#acties binnen de lus
else:
#acties indien de lus beëindigd is
Voorbeeld:
for x in range(6):
print(x)
else:
print("Einde herhaling!")

Linthoudt Geert
 Merk op dat Python, net zoals de meeste programmeertalen, begint te tellen bij 0.
 Merk dat de herhaling niet stopt bij 6, zoals misschien verwacht, maar bij 5. De 6 staat dus
voor het aantal keer dat de lus moet doorlopen worden, beginnende bij 0.

Linthoudt Geert
De else: is optioneel en hoeft u niet te gebruiken (de meeste programmeertalen kennen dit trouwens
niet). U moet in Python dan wel opnieuw de insprong verwijderen om aan te geven dat de lus
beëindigd is.
for x in range(6):
print(x)

Linthoudt Geert

Linthoudt Geert
U kunt 2 parameters gebruiken in de Range. De eerste parameter is dan de startwaarde, de tweede

parameter is de eindwaarde (niet inbegrepen).
for x in range(1, 6):
print(x)

Linthoudt Geert

Linthoudt Geert
U kunt zelfs een derde parameter meegeven, deze derde parameter bepaalt het interval, het aantal
dat bij de teller iedere lus moet worden bijgeteld. Standaard is het interval 1.
for x in range(1, 6, 2):
print(x)

Linthoudt Geert

Linthoudt Geert
U kunt in plaats van een range een lijst (een array) doorlopen.
fruit = ["Appel", "Banaan", "Peer", "Kiwi"]
for x in fruit:
print(x)

Linthoudt Geert

Linthoudt Geert
U kunt de letters van een string doorlopen.
for x in "Geert Linthoudt":
print(x)

Linthoudt Geert

Linthoudt Geert
Onderstaande code zal “Peer” niet tonen door gebruik te maken van continue.
for x in fruit:
if x == "Peer":
continue
print(x)
Let op de insprongen, deze zijn van belang.
Merk op dat u, uiteraard, een Selectie en een Iteratie kunt combineren in dezelfde code.

Linthoudt Geert
Let op, het commando Continu zorgt voor de onderbreking van de structuur, voor de Flow Chart is
dit gewoon een statement/commando als een ander.

Linthoudt Geert

Linthoudt Geert
Onderstaande code zal “Peer” en “Kiwi” niet tonen door gebruik te maken van break.
for x in fruit:
if x == "Peer":
break
print(x)

Linthoudt Geert

Linthoudt Geert

Linthoudt Geert
4.2.2 Voorwaardelijke herhaling in Python

while conditie:
#acties zolang conditie waar is.
#Minimaal één van de acties moet de conditie wijzigen
else:
#acties indien de lus beëindigd is
Voorbeeld:
teller = 0
while teller < 6:
print(teller)
teller += 1
else:
Merk op dat de teller van waarde moet veranderen binnen de lus zodat ook de conditie onwaar kan
worden. Doet u dit niet dan komt uw programma in een “oneindige lus”.

Linthoudt Geert

Linthoudt Geert

Linthoudt Geert
U kunt ook hier de else: weglaten, zorg dat de lus beëindigd wordt door niet langer in te springen.
teller = 0
while teller < 6:
print(teller)
teller += 1

Linthoudt Geert

Linthoudt Geert
Om de getallen van 1 tot 6 te krijgen moet u de beginwaarde van de teller wijzigen naar 1 en de lus
doorlopen zolang de teller <= 6.
teller = 1
while teller <= 6:
print(teller)
teller += 1

Linthoudt Geert

Linthoudt Geert

Linthoudt Geert
U kunt de lus voortijdig beëindigen door een break te gebruiken.
teller = 1
while teller <= 6:
print(teller)
if teller == 3:
break
teller += 1
Er wordt geteld tot 3 en bij 3 wordt de herhaling beëindigt.

Linthoudt Geert

Linthoudt Geert

Linthoudt Geert
Let op, als u dezelfde structuur overneemt met een continue gaat u een oneindige lus krijgen
omdat de teller += 1, die de conditie wijzigt, altijd zal worden overgeslagen vanaf dat de teller de
waarde 3 bereikt.
Met een continue hebt u onderstaande structuur nodig.
teller = 0
while teller < 6:
teller += 1
if teller == 3:
continue
print(teller)
Merk op dat, omdat de teller nu eerst verhoogd wordt voordat hij wordt getoond (print()) dat de
teller weer moet starten bij 0 en de conditie teller < 6 moet zijn om de getallen van 1 tot 6 te
krijgen met uitzondering van 3.

Linthoudt Geert

Linthoudt Geert

Linthoudt Geert
De voorwaardelijke herhaling is heel handig om te controleren op invoer.
Bijvoorbeeld, u vraagt de gebruiker om een getal in te lezen tussen 0 en 10. Zolang hij dit niet doet
blijft het programma de vraag herhalen.
#Invoer
getal = int(input("Geef een getal in tussen 0 en 10: "))
while getal < 0 or getal > 10:
getal = int(input("Geef een getal in tussen 0 en 10: "))
#Uitvoer
print("Het getal is", getal)

Linthoudt Geert

Linthoudt Geert
Voor de opdrachten die volgen mag u, tenzij anders gevraagd, de invoercontrole achterwege laten
zodat we ons kunnen focussen op de structuur van het eigenlijke programmeerprobleem.

Linthoudt Geert
Let op, geeft u geen getal in maar tekst dan krijgt u nog steeds een fout.

Linthoudt Geert
De oplossing valt een beetje buiten de doelstellingen van deze handleiding die de nadruk legt op
programmeerstructuren en minder op typische Python-code maar hier is een oplossing.
def validate(getal, laagste, hoogste):
try:
val = int(getal)
if val < laagste or val > hoogste:
valid = False
else:
valid = True
except Exception:
valid = False
return valid
#Invoer
getal = input("Geef een getal in tussen 0 en 10: ")
while validate(getal, 0, 10) == False:
#Uitvoer
print("Het getal is", getal)
Ik heb een functie geschreven die het getal, de laagste waarde en de hoogste waarde als parameters
ontvangt.
def validate(getal, laagste, hoogste):
De functie geeft de waarde van een Boolean variabele terug.
return valid

Linthoudt Geert
Met
try:
# Probeer deze code
except Exception:
# loopt er iets fout voer dan deze code uit
vangt u fouten op zonder dat er een foutmelding verschijnt (tenzij een foutmelding die u zelf schrijft).
Hebt u een tekst ingetypt en geen getal dan zal de conversie
val = int(getal)
een fout genereren. De code springt dan naar except Exception: en de variabele valid, die
teruggegeven wordt door de functie, krijgt de waarde False.
except Exception:
valid = False
Hebt u wel een getal getypt dan wordt de “normale” controle uitgevoerd en naargelang het resultaat
van de conditie wordt aan de variabele valid de waarde True of False gegeven.
if val < laagste or val > hoogste:
valid = False
else:
valid = True
De functie heeft de waarde van de variabele valid terug.
return valid
De invoer gebeurt zonder de conversie naar int() zoals in het vorige voorbeeld.
#Invoer

Linthoudt Geert
De while lus roept de functie validate(getal, 0, 10) aan met de nodige parameters en wordt
herhaalt zolang de waarde die wordt teruggegeven door de functie False is.
while validate(getal, 0, 10) == False:
Zoals gezegd, deze code is iets teveel van het goede voor de doelstellingen van deze cursus maar ik
wou ze toch even meegeven.

Linthoudt Geert
4.3 Eentje meer

Begin bij 0 en tel telkens ééntje op.
Herhaal dit zolang u niet op een toets, bv. de toets “x” drukt.

Linthoudt Geert
Uitvoer
 teller
Invoer
 willekeurige toets
Bewerkingen
 teller = teller + 1

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
STORE Teller = 0 Teller = 0
OUTPUT Teller print(Teller)
INPUT “Nog een getal” NogEenGetal = input('Wenst u nog een getal
(druk op een toets om door te gaan, druk op x
om te stoppen)?')
WHILE “Nog een getal” != “X” while(NogEenGetal.upper() != "X"):
Teller = Teller + 1 Teller = Teller + 1
OUTPUT Teller print(Teller)
INPUT “Nog een getal” NogEenGetal = input('Wenst u nog een
getal (druk op een toets om door te gaan, druk
op x om te stoppen)?')
OUTPUT “Einde herhaling” print("Einde herhaling")
Teller = 0
# Uitvoer Teller
print(Teller)
#Invoer
NogEenGetal = input('Wenst u nog een getal (druk op een toets om door
te gaan, druk op x om te stoppen)?')
#Herhaal zolang er niet op “x” gedrukt wordt
while(NogEenGetal.upper() != "X"):
#Bewerking
Teller = Teller + 1
#Uitvoer
print(Teller)
#Invoer
NogEenGetal = input('Wenst u nog een getal (druk op een toets om
door te gaan, druk op x om te stoppen)?')
#Uitvoer na de lus
print("Einde herhaling")

Linthoudt Geert
Merk op dat door de functie upper() te gebruiken u zowel een kleine “x” als een grote “X” kunt
ingeven. U moet natuurlijk testen op de grote “X”.

Linthoudt Geert

Linthoudt Geert
4.4 Wiskundige tafel van

Vraag welke wiskundige tafel de gebruiker wenst (tussen 1 en 10).
Geef de gevraagde wiskundige tafel, dit is de vermenigvuldiging van de gevraagde tafel met alle
getallen van 1 tot en met 10, weer op het scherm.

Linthoudt Geert
Uitvoer
 Gevraagde wiskundige tafel
Invoer
 tafel
Bewerkingen
 Binnen een lus: x * tafel

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
INPUT tafel tafel = int(input("Welke tafel (1 tot 10): "))
FOR x van 1 tot 11 for x in range(1, 11):
OUTPUT x * tafel print(x, "x", tafel, "=", x * tafel )
#Invoer
tafel = int(input("Welke tafel (1 tot 10): "))
#Bewerking + uitvoer
print(x, "x", tafel, "=", x * tafel )
Met invoercontrole wordt de code:
#Invoer
#Invoercontrole
while tafel < 0 or tafel > 10:
print(x, "x", tafel, "=", x * tafel )

Linthoudt Geert

Linthoudt Geert
4.5 Alle wiskundige tafels van 1 tot 10

Vraag niet om de tafel maar doorloop alle wiskundige tafels van 1 tot 10 direct.

Linthoudt Geert
Uitvoer
 Alle wiskundige tafels van 1 tot 10
Invoer
 Geen invoer
Bewerkingen
 Binnen een dubbele lus: Teller * tafel

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
FOR teller van 1 tot 11 for teller in range(1, 11):
FOR x van 1 tot 11 for x in range(1, 11):
OUTPUT teller * tafel print(teller, "x", x, "=", teller * x )
for teller in range(1, 11):
print(teller, "x", x, "=", teller * x )
Dit is een eenvoudig voorbeeld van een dubbele lus, een lus in een lus.

Linthoudt Geert

Linthoudt Geert
4.6 Tekst omkeren

Vraag om een tekst.
Toon de tekst omgekeerd.

Linthoudt Geert
Uitvoer
 Omgekeerde tekst
Invoer
 Tekst
Bewerkingen
 Lengte = len(Tekst)
 Binnen een lus: Omgekeerd = Omgekeerd + Tekst[Lengte – (x + 1)]
U moet bij x 1 optellen omdat een lus standaard begint te letten bij 0.

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
INPUT Tekst Tekst = input("Geef een tekst in: ")
STORE Omgekeerd = “” Omgekeerd = ""
STORE Lengte Lengte = len(Tekst)
FOR x = 0 tot Lengte for x in range(0, Lengte):
STORE Omgekeerd = Omgekeerd + Omgekeerd = Omgekeerd + Tekst[Lengte - (x+1)]
Tekst[Lengte - (x+1)]
OUTPUT Omgekeerd print(Omgekeerd)
#Invoer
Tekst = input("Geef een tekst in: ")
Omgekeerd = ""
#Bewerkingen
Lengte = len(Tekst)
for x in range(0, Lengte):
Omgekeerd = Omgekeerd + Tekst[Lengte - (x+1)]
#Uitvoer
print(Omgekeerd)

Linthoudt Geert

Linthoudt Geert
Wie tot nu toe de handleiding goed gevolgd heeft weet dat met veel minder code kan.
#Invoer
Tekst = input("Geef een tekst in: ")
#Bewerkingen
Omgekeerd = Tekst[::-1]
#Uitvoer
print(Omgekeerd)

Linthoudt Geert

Linthoudt Geert
4.7 Gemiddelde dobbelstenenworp

Schrijf een programmaatje dat het gooien van dobbelstenen simuleert.
Het programma moet 20 keer met 2 dobbelstenen gooien. De worpen moeten getoond worden.
Vervolgens moet de gemiddelde aantal geworden ogen getoond worden.

Linthoudt Geert
Uitvoer
 Worpen met 2 dobbelstenen

 Gemiddeld aantal ogen
Invoer
 Geen invoer
Bewerkingen
 Gemiddelde = Som / 20
Opmerking
Om in Python een willekeurig getal tussen 1 en 6 te genereren moet u eenmalig de bibliotheek

random importeren.
import random
Een willekeurig geheel getal tussen 1 en 6 kan als volgt worden gegenereerd.
Dobbel1 = random.randint(1,6)

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
IMPORT random import random
STORE Som = 0 Som = 0
FOR x = 1 tot 21 for x in range(1,21):
STORE Dobbel1 = willekeurig getal Dobbel1 = random.randint(1,6)
tussen 1 en 6 inbegrepen
tussen 1 en 6
STORE Worp = Dobbel1 + Dobbel2 Worp = Dobbel1 + Dobbel2
STORE Som = Som + worp Som = Som + Worp
OUTPUT Worp print("Worp", x , "=", Worp)
STORE Gemiddelde = Som / 20 Gemiddelde = Som / 20
OUTPUT Gemiddelde print("Het gemiddelde aantal geworpen ogen
is", Gemiddelde)
import random
Som = 0
for x in range(1,21):
#Bewerkingen
Worp = Dobbel1 + Dobbel2
Som = Som + Worp
#Uitvoer
print("Worp", x , "=", Worp)
#Bewerking
Gemiddelde = Som / 20
#Uitvoer
print("Het gemiddelde aantal geworpen ogen is", Gemiddelde)
Merk het belang op van de insprongen in Python.

Linthoudt Geert

Linthoudt Geert
4.8 Dobbelstenenworpen met uitvoer nadat alle worpen gedaan zijn

Vraag aan de gebruiker hoeveel dobbelsteenworpen hij/zij wenst.
Toon het gemiddelde aantal geworpen ogen.
Toon nadien alle worpen ter controle.

Linthoudt Geert
Uitvoer
 Gemiddeld aantal ogen

 De dobbelsteenworpen
Invoer
 Aantal dobbelsteenworpen
Bewerkingen
 Gemiddelde = Som / aantal
Opmerking
Omdat de worpen pas getoond mogen worden nadat het gemiddelde getoond is moeten deze
worden bijgehouden in een lijst.
In Python kunt u een lege lijst aanmaken door een naam te kiezen en deze gelijk te stellen aan een
lege lijst [].
Ogen = []
Items toevoegen aan de lijst doet u met de functie append().
Ogen.append(Worp)
Om alle items te tonen doorloopt u ze in een lus.
for x in range(0,Aantal):
print(Ogen[x])

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
STORE Som = 0 Som = 0
STORE Ogen Ogen = []
INPUT Aantal Aantal = int(input("Hoeveel worpen wilt u
gooien?"))
FOR x = 1 tot Aantal + 1 for x in range(1,Aantal + 1):
tussen 1 en 6 inbegrepen
tussen 1 en 6
STORE Worp = Dobbel1 + Dobbel2 Worp = Dobbel1 + Dobbel2
STORE Worp in Ogen Ogen.append(Worp)
STORE Som = Som + worp Som = Som + Worp
STORE Gemiddelde = Som / 20 Gemiddelde = Som / 20
OUTPUT Gemiddelde print("Het gemiddelde aantal geworpen ogen
is", Gemiddelde)
FOR x = 0 tot Aantal for x in range(0,Aantal):
OUTPUT Ogen[x] print("Worp", x + 1 , "=", Ogen[x])

Linthoudt Geert
import random
Som = 0
Ogen = []
#Invoer
Aantal = int(input("Hoeveel worpen wilt u gooien?"))
#Bewerkingen
for x in range(1, Aantal + 1):
Worp = Dobbel1 + Dobbel2
Ogen.append(Worp)
Som = Som + Worp
Gemiddelde = Som / Aantal
#Uitvoer
print("Het gemiddelde aantal geworpen ogen is", Gemiddelde)
for x in range(0, Aantal):
print("Worp", x + 1 , "=", Ogen[x])
Omdat deze code gebaseerd is op voorgaande opdracht heb ik de toevoegingen/wijzigingen

gemarkeerd.

Linthoudt Geert

Linthoudt Geert
4.9 Getallen inlezen

Lees positieve getallen is en beëindig het inlezen door een negatief getal in te geven.
Toon nadien nog eens alle ingelezen getallen.

Linthoudt Geert
Uitvoer
 Alle ingelezen getallen
Invoer
 Lees positieve getallen in zolang u geen negatief getal inleest
Opmerking
Omdat u alle ingelezen getallen nadien nog eens moet tonen moet u deze bijhouden in een lijst.

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
STORE Getallen Getallen = []
INPUT Getal Getal = int(input("Geef een getal
in."))
WHILE Getal >= 0 while(Getal >= 0):
STORE Getal in Getallen Getallen.append(Getal)
INPUT Getal Getal = int(input("Geef een getal
in."))
FOR Getal in Getallen for x in range(0, len(Getallen)):
OUTPUT Getal print(Getallen[x])
Getallen = []
#Invoer
Getal = int(input("Geef een getal in."))
while(Getal >= 0):
Getallen.append(Getal)
Getal = int(input("Geef een getal in."))
#Uitvoer
for x in range(0, len(Getallen)):
print(Getallen[x])
Merk op dat u de lengte van een lijst Getallen kunt opvragen met de functie len().
len(Getallen)

Linthoudt Geert

Linthoudt Geert
4.10 Punten voor cursisten

U hebt een klein klasje met drie cursisten: Lode, Emmelie en Elise.
De cursisten volgen 2 vakken: Nederlands en Frans.
1. Lees de punten Nederlands in voor de drie cursisten.

2. Lees de punten Frans in voor de drie cursisten.
3. Toon het behaalde percentage per cursist.
De uitvoer ziet er bijvoorbeeld als volgt uit:

Linthoudt Geert
Uitvoer
 Percentage per cursist
Invoer
 Punten Nederlands voor alle cursisten

 Punten Frans voor alle cursisten
Bewerkingen
 Percentage = (Nederlands[x] + Frans[x]) / 2 * 10
Opmerkingen
Hou een lijst bij voor de cursisten, een lijst voor Nederlands en een lijst voor Frans.
De lijst cursisten wordt meteen opgevuld met de namen, de andere lijsten zijn leeg.
Cursisten = ["Lode", "Emmelie", "Elise"]
Nederlands = []
Frans = []

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
STORE Cursisten Cursisten = ["Lode", "Emmelie", "Elise"]
STORE Nederlands = [] Nederlands = []
STORE Frans = [] Frans = []
FOR Iedere cursist for x in range(0,3):
INPUT Punten Nederlands Punten = int(input(Inputtekst))
STORE Punten Nederlands.append(Punten)
INPUT Punten Frans Punten = int(input(Inputtekst))
STORE Punten Frans.append(Punten)
BEREKEN Percentage Percentage = (Nederlands[x] + Frans[x]) /
2 * 10
OUTPUT Percentage print("Het percentage voor",
Cursisten[x], "is", Percentage, "%")
De Inputtekst kan er als volgt uitzien:
Inputtekst = "Geef de punten (0 tot 10) voor Nederlands voor " + Cursisten[x] +
"."

Linthoudt Geert
Nederlands = []
Frans = []
#Input
Inputtekst = "Geef de punten (0 tot 10) voor Nederlands voor " +
Cursisten[x] + "."
Punten = int(input(Inputtekst))
Nederlands.append(Punten)
Inputtekst = "Geef de punten (0 tot 10) voor Frans voor " +
Cursisten[x] + "."
Frans.append(Punten)
#Uitvoer
Percentage = (Nederlands[x] + Frans[x]) / 2 * 10
print("Het percentage voor", Cursisten[x], "is", Percentage, "%")

Linthoudt Geert
Met invoercontrole.
Nederlands = []
Frans = []
#Input
Inputtekst = "Geef de punten (0 tot 10) voor Nederlands voor " +
Cursisten[x] + "."
while Punten < 0 or Punten > 10:
Nederlands.append(Punten)
Inputtekst = "Geef de punten (0 tot 10) voor Frans voor " +
Cursisten[x] + "."
while Punten < 0 or Punten > 10:
Frans.append(Punten)
#Uitvoer
Percentage = (Nederlands[x] + Frans[x]) / 2 * 10
print("Het percentage voor", Cursisten[x], "is", Percentage, "%")

Linthoudt Geert

Linthoudt Geert

Vraag naar de leeftijd.
Bereken de te betalen inkomprijs per gezin/groep.

Linthoudt Geert
Uitvoer
 Te betalen inkom per gezin
Invoer
 leeftijd
Bewerkingen
 If leeftijd >= 18 then “30 €” else if leeftijd < 12 then “Gratis” else “20 €”
Opmerking
Dit is een gelijkaardige opdracht als de opdracht Tentoonstelling 2 uit het vorige hoofdstuk maar in
plaats van de inkom per persoon te tonen moet nu de inkom voor het volledige gezin/groep getoond
worden.
Het afsluiten van de invoer per gezin/groep kan bv. door -1 in te typen.

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
INPUT leeftijd leeftijd = int(input("Geef de leeftijd in (afsluiten
met -1):"))
STORE Inkom = 0 inkom = 0
WHILE Leeftijd != -1 while leeftijd != -1:
IF leeftijd >= 18 THEN if leeftijd >= 18:
STORE Inkom + 30 inkom += 30
ELSE IF leeftijd < 12 THEN elif leeftijd < 12:
ELSE else:
INPUT leeftijd leeftijd = int(input("Geef de
leeftijd in (afsluiten met - 1):"))
Output Inkom print("De inkom voor het gezin, de groep, is:",
inkom)
#Invoer
leeftijd = int(input("Geef de leeftijd in (afsluiten met -1):"))
inkom = 0
while leeftijd != -1:
#Bewerking
if leeftijd >= 18:
inkom += 30
elif leeftijd < 12:
inkom += 0
else:
inkom += 20
#Invoer
leeftijd = int(input("Geef de leeftijd in (afsluiten met -1):"))
#Uitvoer
print("De inkom voor het gezin, de groep, is:", inkom)
Opmerking
inkom += 0
is dit niet overbodig? In theorie wel, in de praktijk houdt dit de structuur, die we reeds hadden,
overeind, ook al is het een beetje onlogisch.

Linthoudt Geert

Linthoudt Geert
4.12 Getallen optellen

De eerste twee getallen worden meteen gegenereerd en de som wordt getoond.
De computer vraagt om een volgend getal en, indien u een nieuw getal wenst, telt het getal op bij de
vorige getallen. Herhaal dit zolang u niet stopt met getallen te vragen.

Linthoudt Geert
Uitvoer
 Getallen
 Som
Invoer
 Nog een getal of niet
Bewerkingen
 Willekeurige getallen genereren

 De getallen optellen
Opmerking
Omdat we altijd alle getallen moeten optellen en tonen, en omdat we niet weten hoeveel getallen er
moeten bijgehouden en getoond worden, moeten de getallen in een lijst (array) worden
bijgehouden.
De uitvoer ziet er ongeveer als volgt uit.

Linthoudt Geert

Linthoudt Geert
Pseudocode Python
Import random import random
STORE Getallen = [] Getallen = []
STORE ToonGetallen = “” ToonGetallen = ""
STORE Willekeurig getal 1 Getallen.append(random.randint(1, 10))
STORE Willekeurig getal 2 Getallen.append(random.randint(1, 10))
STORE Som van de getallen som = Getallen[0] + Getallen[1]
OUTPUT Getallen en som ToonGetallen = str(Getallen[0]) + " + " +
str(Getallen[1])
print(ToonGetallen,"=",som)
INPUT “Verder of niet?” NogEenGetal = input('Wenst u nog een getal
(druk op een toets om door te gaan, druk op x
om te stoppen)?')
WHILE Verder while(NogEenGetal.upper() != "X"):
STORE Willekeurig getal Getallen.append(random.randint(1, 10))
STORE Som = 0 som = 0
STORE ToonGetallen = “” ToonGetallen = "
FOR ieder Getal for Getal in Getallen:
STORE Som som += Getal
STORE ToonGetallen ToonGetallen += str(Getal) + " + "
OUTPUT Getallen en som ToonGetallen = ToonGetallen[:-2]
print(ToonGetallen, "=", som)
INPUT Getallen en som NogEenGetal = input('Wenst u nog een
getal (druk op een toets om door te gaan, druk
op x om te stoppen)?')
import random
Getallen = []
ToonGetallen = ""
#Bewerkingen - Voeg willekeurige getallen toe aan de lijst

Getallen.append(random.randint(1, 10))
#Bereken de som
som = Getallen[0] + Getallen[1]
#Uitvoer
ToonGetallen = str(Getallen[0]) + " + " + str(Getallen[1])
#Invoer
NogEenGetal = input('Wenst u nog een getal (druk op een toets om door
te gaan, druk op x om te stoppen)?')

Linthoudt Geert
#Herhaal zolang er niet op “x” gedrukt wordt

#Voeg een getal toe aan de lijst
#Maak de som en de uitvoertekst leeg

som = 0
ToonGetallen = ""
#Doorloop de lijst met getallen en tel ze op

for Getal in Getallen:
som += Getal
ToonGetallen += str(Getal) + " + "
#Haal het laatste +-teken en de laatste spatie weg

ToonGetallen = ToonGetallen[:-2]
#Uitvoer
#Invoer
NogEenGetal = input('Wenst u nog een getal (druk op een toets om
door te gaan, druk op x om te stoppen)?')
Omdat we telkens een +-teken en een spatie toevoegen met
Hebt u een +-teken, en een spatie teveel staan. U verwijdert de laatste twee tekens van een string
met:
Opmerking, om een array leeg te maken gebruikt u de functie clear().
Getallen.clear()

Linthoudt Geert

Linthoudt Geert
5 Extra: Complexere voorbeelden

Deze voorbeelden zijn misschien niet echt voor “beginnende programmeurs”, u mag ze dus
eventueel overslaan en de handleiding hier beëindigen.
Maar voor wie nu reeds een stapje verder wilt zetten kan onderstaande complexere voorbeelden
eens bestuderen.
Opdracht 264
Linthoudt Geert
5.1 21
Schrijf een programma dat:
de speler twee willekeurige getallen tussen de 1 en 10 (inbegrepen) geeft en deze twee getallen en
de som van deze twee getallen toont.
Het programma vraagt nu of de speler nog een willekeurig getal wenst. Die vraag wordt herhaald
zolang de speler een bijkomend getal vraagt of tot de som van de getallen groter is dan 21.
 Is de som van de getallen groter dan 21 dan verliest de speler 10 €.

 Stopt de speler bij een som van 19 dan ontvangt hij 2 €.
 Stopt de speler bij de som van 20 dan ontvangt hij 5 €.
 Stopt de speler bij de som van 21 dan ontvangt hij 20 €.
De speler moet zolang kunnen spelen tot hij besluit te stoppen met spelen.
Opmerking
Behandel dit als een opdracht, iets dat u volledig zelf moet uitwerken.
Op de volgende pagina vindt u een oplossing in Python, maar ga pas kijken nadat u zelf geprobeerd
hebt.
Weet dat uw oplossing altijd wat kan verschillen van mijn oplossing, zolang ze maar werkt.
Opdracht 265
Linthoudt Geert
import random
#Geef beginwaarden
Stoppen = "N"
Winst = 0
#Maak een lege array
Getallen = []
#Zolang u niet wilt stoppen

while Stoppen.upper() != "J":
#Arrays leeg maken
Getallen.clear()
ToonGetallen = ""
#Bewerkingen - Voeg willekeurige getallen toe aan de lijst

#Bepaal de uitvoertekst
ToonGetallen = str(Getallen[0]) + " + " + str(Getallen[1])
#Bereken de som
som = Getallen[0] + Getallen[1]
#Uitvoer - Toon de getallen en de som

#Invoer - Vraag of de speler een nieuw getal wenst

NogEenGetal = input('Wenst u nog een getal (j/n)?')
#Herhaal zolang er op "j" gedrukt wordt en de speler dus een nieuw

getal wenst
while(NogEenGetal.upper() == "J"):
#Voeg een getal toe aan de lijst
#Maak de som en de uitvoertekst leeg

som = 0
ToonGetallen = ""
#Doorloop de lijst met getallen en tel ze op

for Getal in Getallen:
som += Getal
#Haal het laatste +-teken en de laatste spatie weg

#Uitvoer - Toon de getallen en de som

#Controleer of de 21 bereikt is
if som > 21:
#Bereken winst
Winst = Winst - 10
#Uitvoer
print("U verliest 10 €. Uw huidige winst is", Winst, "€.")
Opdracht 266
Linthoudt Geert
#U kunt geen getal meer vragen

NogEenGetal = "N"
#Invoer - Vraag om te stoppen met spelen

Stoppen = input('Wil u stoppen met spelen (j/n)?')
elif som == 21:
#Bereken winst
Winst = Winst + 20
#Uitvoer
print("U wint 20 €. Uw huidige winst is", Winst, "€.")
#U kunt geen getal meer vragen

NogEenGetal = "N"

else:
#Invoer - Vraag of de speler een nieuw getal wenst
NogEenGetal = input('Wenst u nog een getal (j/n)?')
#U wilt geen getal meer, afwerken en vragen of u wilt stoppen

if som == 20:
#Bereken de winst
Winst = Winst + 5
#Uitvoer

elif som == 19:
#Bereken de winst
Winst = Winst + 2
#Uitvoer

elif som < 19:
#Uitvoer
print("Geen winst en geen verlies. Uw huidige winst is", Winst,
"€.")

#Uitvoer
print("Uw totale winst/verlies is", Winst,"€.")
Opdracht 267
Linthoudt Geert
5.2 Schaar steen papier 1

U kent het spelletje “Schaar steen papier”?
 “Schaar” verslaat “Papier”.

 “Steen” verslaat “Schaar”.
 “Papier” verslaat “Steen”.
Hoe gaat u te werk?
1. U, de speler, moet een keuze kunnen maken tussen “schaar”, “steen” of “papier”.
2. De computer maakt zijn keuze.
3. Het programma vergelijkt beide keuzes en geeft aan wie er gewonnen is.
We gaan op deze oefening later nog terugkomen en verder uitbreiden, om te starten doen we enkel
het bovenstaande met volgende tips:
Om de invoer gemakkelijker te maken kiest u voor de Engelse benaming: “Paper”, “Rock” of

“Scissors”. U typt een “P” in voor “Paper”, een “R” voor “Rock” of een “S” voor “Scissors”. Begrijpt u
waarom “schaar”, “steen” of “papier” een probleem(pje) is voor de invoer?
In deze versie 1 doet u geen invoercontrole, dit is voor versie 2.
Denk zelf na over de programmeerstructuur, er kan enige variatie zitten in de volgorde van de
condities, de vergelijkingen, maar de structuur moet in grote lijnen gelijk zijn.
De Python-code bevat een paar nieuwigheden die u, uiteraard, nog niet kent.
Opdracht 268
Linthoudt Geert
Uitvoer
 Keuzes
 Winnaar
Invoer
 Keuze van de speler (“p”, “r” of “s”)
Bewerkingen
 Computer kiest een random waarde tussen “p”, “r” of “s”.

 Als de keuze van de speler gelijk is aan de keuze van de computer dan “Gelijk”
 Anders Als de keuze van de speler “R” is dan
o Als de keuze van de computer is “S” dan “Speler wint”
o anders “Computer wint”.
 Anders Als de keuze van de speler “P” is dan
o Als de keuze van de computer is “R” dan “Speler wint”
 Anders Als de keuze van de speler “S” is dan
o ALS de keuze van de computer is “P” dan “Speler wint”
Vrij vertaald, controleer eerst of de beide keuzes gelijk zijn. Is dit het geval dan is er “Geen winanar”.
Zijn de keuzes niet gelijk, controleer dan de 3 mogelijke keuzes vanuit het standpunt van de speler
(of de computer, dit maakt niet uit). Voor iedere keuze van de speler, vergelijk met de twee
mogelijke overgebleven opties (de gelijke keuze is reeds verwerkt) van de computer en bepaal de
winnaar.
Opdracht 269
Linthoudt Geert
Opdracht 270
Linthoudt Geert
Pseudocode Python
INPUT Keuze Speler Speler = input("Geef uw keuze in: R, P of S (rock,
paper, scissors): ")
STORE Keuze Computer Computer = random.choice(Opties)
OUTPUT Keuzes print(f"\nU koos voor {Speler}, de computer

koos {Computer}.\n")
IF Keuze Speler == Keuze Computer THEN if Speler.upper() == Computer:
OUTPUT “Geen winnaar” print("Gelijk, geen winnaar!")
ELSE IF Keuze Speler == “R” THEN elif Speler.upper() == "R":
IF Keuze Computer == “S” THEN if Computer == "S":
OUTPUT “Speler wint” print("Speler wint!")
ELSE else:
OUTPUT “Computer wint” print("Computer wint!")
ELSE IF Keuze Speler == “P” THEN elif Speler.upper() == "P":
IF Keuze Computer == “R” THEN if Computer == "R":
ELSE else:
ELSE IF Keuze Speler == “S” THEN elif Speler.upper() == "S":
IF Keuze Computer == “P” THEN if Computer == "P":
ELSE else:
Opdracht 271
Linthoudt Geert
import random
#Invoer
Speler = input("Geef uw keuze in: R, P of S (rock, paper, scissors): ")
Opties = ["R", "P", "S"]
#Bewerking
Computer = random.choice(Opties)
#Uitvoer
print(f"\nU koos voor {Speler}, de computer koos {Computer}.\n")
#Bewerking en uitvoer
if Speler.upper() == Computer:
print("Gelijk, geen winnaar!")
elif Speler.upper() == "R":
if Computer == "S":
print("Rock wint van Scissors! De speler wint!")
else:
print("Paper wint van Rock! De computer wint.")
elif Speler.upper() == "P":
if Computer == "R":
print("Paper wint van Rock! De speler wint!")
else:
print("Scissors wint van Paper! De computer wint.")
elif Speler.upper() == "S":
if Computer == "P":
print("Scissors wint van Paper! De speler wint!")
else:
print("Rock wint van Scissors! De Computer.")
Opdracht 272
Linthoudt Geert
import random
Importeert de bibliotheek met functies om willekeurige getallen te genereren.
Opties = ["R", "P", "S"]
Opties is een lijst met meerdere waarden van eenzelfde type (de meeste programmeertalen
gebruiken hier het woordje array).
Ik heb nog eens voor de alternatieve print() gekozen waarin u de variabelen direct kunt integreren in
de tekst. Vergeet de f vooraan niet. \n zorgt voor een nieuwe regel.
Speler.upper()
Hiermee wordt de ingevoerde waarde voor Speler omgezet naar hoofdletters. Dit laat toe dat de
speler ook kleine letters mag intypen.
Merk op dat de computer kiest uit een lijst met hoofdletters. Hoofdletters worden dus met
hoofdletters vergeleken.
Opdracht 273
Linthoudt Geert
Opdracht 274
Linthoudt Geert
Opdracht 275
Linthoudt Geert
Opdracht 276
Linthoudt Geert
Opdracht 277
Linthoudt Geert
5.2.1 Functies
Deze code is al vrij complex, zeker de flowchart is met het oog op verdere aanpassingen niet echt
meer handig.
Wat u kunt doen, en wat zelfs aan te bevelen is, is de code die bepaalt wie er wint in een eigen
functie.
Laat ons eerst naar de oplossing kijken, nadien volgt een woordje uitleg. Ik markeer alvast de
belangrijke veranderingen.
Opdracht 278
Linthoudt Geert
import random
def BepaalWinnaar(Speler, Computer):
if Computer == "S":
else:
if Computer == "R":
else:
if Computer == "P":
else:
#Invoer
Opties = ["R", "P", "S"]
#Bewerking
#Uitvoer
BepaalWinnaar(Speler, Computer)
Opdracht 279
Linthoudt Geert
Er is een functie aangemaakt met de naam BepaalWinnaar en met twee parameters Speler en
Computer.
Heel de code die de winnaar bepaalt is gewoon gekopieerd en geplakt binnen deze functie. Let wel
op de nodige insprong die in Python belangrijk is.
De functie wordt aangeroepen via:
Toevallig, en dit is zeker geen verplichting maar eerder een “toeval”, zijn de namen van de
parameters die we hier meegeven dezelfde namen als de namen van de parameters in de functie
zelf.
Nogmaals, dit is geen verplichting.
Uiteraard wordt de eerste parameter aan de eerste parameter van de functie toegekend en de
tweede parameters aan de tweede parameter van de functie.
Opdracht 280
Linthoudt Geert
De Flowchart wordt nu ook herwerkt als volgt. De Flowchart van het hoofdprogramma wordt nu heel
eenvoudig en verwijst naar de functie.
Het symbooltje om een functie aan te roepen is een rechthoek met een dubbele lijn.
Het is deze structuur waar we gaan op verder bouwen in de uitbreidingen.
Opdracht 281
Linthoudt Geert
De functie wordt afzonderlijk uitgewerkt en bevat de complexere code.
Opdracht 282
Linthoudt Geert
5.3 Schaar steen papier 2

U kent het spelletje “Schaar steen papier”?
 “Schaar” verslaat “Papier”.

 “Steen” verslaat “Schaar”.
 “Papier” verslaat “Steen”.
Hoe gaat u te werk?
1. U, de speler, moet een keuze kunnen maken tussen “schaar”, “steen” of “papier”.
2. De computer maakt zijn keuze.
3. Het programma vergelijkt beide keuzes en geeft aan wie er gewonnen is.
Dit hebben we reeds geprogrammeerd.
Uitbreiding
We gaan dit nu uitbreiden met een invoercontrole en de mogelijkheid te blijven spelen zolang de
gebruiker niet op de x-toets druk.
U typt een “P” in voor “Paper”, een “R” voor “Rock”, een “S” voor “Scissors” of een “X” om te
stoppen.
We vertrekken vanaf de versie met de functie.
Opdracht 283
Linthoudt Geert
Uitvoer
 Keuzes van de computer en de spelers: schaar, steen of papier

 Winnaar
Invoer
 Keuze van de speler (“p”, “r”, “s”, “x”)
Bewerkingen
 Computer kiest een random waarde tussen “p”, “r” of “s”.

 Als de keuze van de speler gelijk is aan de keuze van de computer dan “Gelijk”
 Anders Als de keuze van de speler “R” is dan
o Als de keuze van de computer is “S” dan “Speler wint”
 Anders Als de keuze van de speler “P” is dan
o Als de keuze van de computer is “R” dan “Speler wint”
 Anders Als de keuze van de speler “S” is dan
o ALS de keuze van de computer is “P” dan “Speler wint”
Opdracht 284
Linthoudt Geert
Opdracht 285
Linthoudt Geert
Opdracht 286
Linthoudt Geert
import random
if Computer == "S":
else:
if Computer == "R":
else:
if Computer == "P":
else:
#Invoer
Opties = ["R", "P", "S"]
#Bewerking
#Uitvoer
Opdracht 287
Linthoudt Geert
Laat ons dit modulair programmeren, met functies, behouden.
Opdracht 288
Linthoudt Geert
De functie Invoer verloopt als volgt:
Vraag naar de invoer van de speler.
Speler = input("Geef uw keuze in: R, P of S (rock, paper, scissors) of een X om te stoppen: ")
Na de invoer moet er getest worden of de invoer correct is, dit gebeurt bijvoorbeeld via:
while Speler.upper() != "R" and Speler.upper() != "P" and Speler.upper() != "S" and Speler.upper() !=
"X":
Zolang er geen correct invoer is wordt de invoer herhaald.
Speler = input("Geef uw keuze in: R, P of S (rock, paper, scissors) of een X om te stoppen: ")
In de invoer correct dan wordt de invoer geReturned.
return Speler
Opdracht 289
Linthoudt Geert
De aangepaste code:
import random
if Computer == "S":
else:
if Computer == "R":
else:
if Computer == "P":
else:
def Invoer():
Speler = input("Geef uw keuze in: R, P of S (rock, paper, scissors)
of een X om te stoppen: ")
while Speler.upper() != "R" and Speler.upper() != "P" and
Speler.upper() != "S" and Speler.upper() != "X":
Speler = input("Geef uw keuze in: R, P of S (rock, paper,
scissors) of een X om te stoppen: ")
return Speler
Opdracht 290
Linthoudt Geert
#Invoer
Opties = ["R", "P", "S"]
Speler = Invoer()
while Speler.upper() != "X":
#Bewerking
#Uitvoer
#Invoer
Speler = Invoer()
Zolang de speler niet op de X drukt wordt er gespeeld
Stilaan wordt de code complexer en dringt de noodzaak om modulair te werken, met afzonderlijke
functies die herhalende taken op zich nemen, of louter om het overzichtelijker te houden, zich op.
Zoals we later in de cursus gaan zien wordt dit principe DRY (Don’t Repeat Yourself) genoemd
Opdracht 291
Linthoudt Geert
Opdracht 292
Linthoudt Geert
5.3.1 Globale variabelen in Python

Stel, we wensen in het programmaatje “Schaar, steen, papier” bijhouden hoe vaak de computer
gewonnen heeft en hoe vaak de speler gewonnen heeft.
U denkt aan volgende oplossing, de toevoegingen staan gemarkeerd in geel.
import random
AantalGewonnenPC = 0
AantalGewonnenSpeler = 0

if Computer == "S":
AantalGewonnenSpeler += 1
else:
AantalGewonnenPC += 1
if Computer == "R":
else:
if Computer == "P":
else:
def Invoer():
return Speler
#Invoer
Opties = ["R", "P", "S"]
Speler = Invoer()

#Bewerking
#Uitvoer
Opdracht 293
Linthoudt Geert
#Invoer
Speler = Invoer()
#Uitvoer
print(f"\nAantal gewonnen spelletjes door de speler:
{AantalGewonnenSpeler}, aantal gewonnen spelletjes door de PC:
{AantalGewonnenPC}.\n")
Ziet er goed uit, maar als u dit laat lopen krijgt u een foutmelding.
Opdracht 294
Linthoudt Geert
Opdracht 295
Linthoudt Geert
5.3.1.1 Wat is de reden?

Een variabele die u definieert buiten een functie (dit wordt een globale variabele genoemd) kunt u,
in Python, wel lezen binnen de functie maar u mag de variabele niet wijzigen binnen de functie.
Dit is eigen aan Python, andere programmeertalen werken anders.
5.3.1.2 Hoe lost u het op?

U moet binnen de functie, de globale variabelen die wilt gebruiken binnen de functie, eerst
toevoegen binnen de functie met het woordje global. Hieronder aangeduid in het groen.
import random
AantalGewonnenPC = 0
AantalGewonnenSpeler = 0

global AantalGewonnenPC
global AantalGewonnenSpeler
if Computer == "S":
else:
if Computer == "R":
else:
if Computer == "P":
else:
def Invoer():
return Speler
Opdracht 296
Linthoudt Geert
#Invoer
Opties = ["R", "P", "S"]
Speler = Invoer()

#Bewerking
#Uitvoer
#Invoer
Speler = Invoer()
#Uitvoer
print(f"\nAantal gewonnen spelletjes door de speler:
{AantalGewonnenSpeler}, aantal gewonnen spelletjes door de PC:
{AantalGewonnenPC}.\n")
Test maar uit, dit zal werken zoals verwacht.
Opdracht 297

Gestructureerd Programmeren

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Gestructureerd Programmeren

Uploaded by

Copyright:

Available Formats

Informatica Programmeren – Start to Program

Gestructureerd Programmeren met Python

3.3 Is een getal positief of negatief? ......................................................................................... 100

De nadruk ligt op het leren programmeren. De programmeertaal die ik gebruik is Python.

 Kies voor Stroomschema (Flow chart) en bewaar.

 Klik onderaan links op More Shapes….

 Tekst voegt u toe door te dubbelklikken op het symbooltje en de tekst te typen.

 Rechts kunt u de eigenschappen en de stijl van de symbolen, verbindingslijnen en tekst

1.2 Leren programmeren

Hoe leert u dan wel programmeren?

 Ken de syntax van de belangrijkste instructies van de gekozen programmeertaal.

1.3 Wat is Gestructureerd Programmeren?

De 3 basis controlestructuren zijn:

 Sequentie - een opeenvolging van instructies, de ene na de andere.

1.4 Hoe gaan we te werk?

 Uitvoer – wat moet het programma uiteindelijk tonen.

Tenslotte wordt het Python-programma geschreven.

 Een ovaal voor Starten en Stoppen van het programma/script.

 Instructies worden in hoofdletters geschreven.

1.5 Hoe gaat u te werk?

Oké, hoe gaat u wel te wek.

In grote lijnen vindt u in de programmeercode steeds volgende structuur:

2.1 “Hello World”

 De tekst “Hello World”.

 Geen invoer vereist.

 Geen bewerkingen (vermits er geen invoer is).

Volledige code in Phyton.

 In https://www.online-python.com/ typt u de Python-code in, bovenaan, en drukt u op Run.

Bovenaan hebt u een knopje waarmee u de code kunt bewaren op uw schijf.

Let op, Python-bestanden hebben de extensie .PY.

Indien u wenst kunt u uw code delen op sociale media.

2.2 “Hello, ” naam

 De tekst “Hello, ” gevolgd door uw naam.

naam = input("Geef uw naam in: ")

print("Hello, ", naam)

Let op, een variabelenaam mag geen spaties bevatten!

print("Hello, ", naam)

Ziet u de fout in onderstaande code?

2.3 “Hello,” familienaam + voornaam

Familienaam een voornaam worden afzonderlijk ingevoerd.

 De tekst “Hello,” gevolgd door uw familienaam + voornaam.

 naam = familienaam + “ ” + voornaam

 Bovenstaande bewerking voegt een spatie toe tussen de familienaam en de voornaam.

familienaam = input("Geef uw familienaam in: ")

voornaam = input("Geef uw voornaam in: ")

naam = familienaam + " " + voornaam

Merk de commentaarlijntjes op, ik heb ze in het groen geplaatst. Nu de programmeercode iets

In Python begint commentaar met #.

 De som van twee getallen.

 som = getal1 + getal2

Hieronder ziet u de belangrijkste bewerkingsoperatoren van Python.

Operator Naam Voorbeeld

getal1 = int(input("Getal 1: "))

getal2 = int(input("Getal 2: "))

som = getal1 + getal2

print(getal1, " + ", getal2, " = ", som)

ToonGetallen = str(Getal1) + " + " + str(Getal2)

print(ToonGetallen, " = ", som)

Merk op dat als u geen getal ingeeft u een foutmelding krijgt.

Wat zou er gebeuren als we de int() functie niet toevoegen?

getal1 = input("Getal 1: ")

getal2 = input("Getal 2: ")

7 + 2 geeft nu de uitkomst 72.

# Online Python - IDE, Editor, Compiler, Interpreter