Deze opdracht verhuist naar de cursus Python 102 of 103.
Je hebt nu al een paar python lessen achter de rug. Je kent integers, strings en lijsten. For-loops, while-loops en if-then-else. Maar hoe maak je nu een programma ? Dat is niet zomaar een bak losse regels code. Nee, daar zit een idee achter: deel het programma op in functies. Dat gaan we deze les dus leren.
Een eenvoudig python programma ziet er als volgt uit
import bla
import blabla
def functie_zus():
a = hetzalwel()
return (a/2)
def functie_zo(x):
b = manman(x)
return (2 * b)
def manman(z):
return(0)
# HIER KOMT HET HOOFDPROGRAMMA:
x = functie_zus()
y = functie_zo(x)
Kortom: na de nodige import-statements komen een aantal functies (def) die je hebt bedacht om het probleem uit het hoofdprogramma op te lossen. Dus je schrijft eerst ruwweg het hoofdprogramma, waar je alvast functies opvoert die je later pas een keer gaat schrijven. Totdat je ze af hebt, laat je ze lekker een fake- of standaard waarde opleveren, zoals manman() in dit voorbeeld, die altijd 0 teruggeeft.
Een functie zoals manman()
- begint met het keyword def
- heeft een naam die uit 1 string – geen spaties – bestaat
- krijgt een aantal parameters mee. Wij als programmeur moeten een beetje letten op welk type dat gaat worden, want python kan het geen f**k schelen en crasht dan gewoon.
- kan (maar moet niet) een return waarde opleveren, via return(dit)
De truc is nu dat je in het hoofdprogramma een aantal variabelen laat rondlopen tussen de ene functie en de volgende… digital magic!
Maak de lotnummers van een loterij
Nu gaan we samen een voorbeeld uitprogrammeren, stap voor stap. Ik neem je mee met de denkstappen, maar je krijgt het niet helemaal kado. Lees ook de theorie, tussendoor (…).
Opdracht: maak een programma dat een variabel aantal lotnummers voor een loterij produceert. Elk lotnummer is een string met als opmaak LLCCCCCC, ofwel 2 hoofdletters en 6 cijfers, zoals “AB123456”.
Loterij stap 1
Je krijgt kado: het hoofdprogramma zelf. Geniet:
import random loten = maak_loten(100) print_loten(loten)
Maak nu zelf de functies die je nodig hebt om dit hoofdprogramma zonder fouten te laten runnen.
- maak_loten levert een lijst op met 2 strings, die eruit zien als een “echt lot”.
- let op die variabele loten. Dat is het doel van dit hele programma. De ene functie poept ‘m uit, de andere functie eet de loten weer op.
- print_loten print allebei die strings uit.
Loterij Stap 2
Nu gaan we de functie maak_loten onder handen nemen. Ook deze gaan we opdelen in een paar leuke functies. Maar eerst krijg je nu de functie header kado, met comments en die helpen je enorm.
def maak_loten(aantal) : # returnt een lijst met lotnummers zodat het er net echt uit ziet. # elk lot is eigenlijk een string # opmaak: 2 Letters, 6 cijfers. bijv 'AB123456' # alles random, we gokken erop dat er geen dubbele loten komen.
Omdat deze functie een lijst moet opleveren, beginnen we gelijk maar met een lege lijst. Een goede gewoonte, gelijk variabelen erin gooien aan het begin van je programma of functie.
loten = [ ]
Omdat dit een flinke functie wordt en we het ‘AB’ gedeelte van het lot toch dubbel nodig hebben, knippen we de kern van deze functie nog op in:
maak_letter() maak_letter() maak_cijfers(6)
Maak nu zelf de functie header (het def gebeuren) van deze 2 functies. Zorg dat het aantal op te leveren cijfers als parameter mee gaat. Laat de functies een nep-resultaat geven met return(“A”) of iets dergelijks. Gebruik variabelen om de return-waardes op te vangen ! Maak ook een # comment onder elke functie header zodat je precies vastlegt wat het ding doet.
Maak nu de magic trick van maak_loten, die de losse stukken van je loten aan elkaar plakt en returnt. Kan zijn iets als:
return(letter1 + letter2 + decijfers)
Op dit moment levert maak_loten maar 1 lot op, maar dat komt straks goed. Zo doe je dat: eerst simpel en dan pas uitbouwen. Ook zal de string “AA123456” nu op losse regels geprint worden door print_loten() maar dat is op zich goed. Dit komt doordat we nu maar 1 string als lot produceren, en niet een lijst met loten. Dat komt zo wel!
Je programma geeft nu dit resultaat:
Loterij Stap 3: sub-functies afmaken
Laten we eens kijken wat we hebben gedaan. We hebben het probleem opgeknipt in het hoofdprogramma door 2 functies te bedenken. En de belangrijkste ervan hebben we weer met 3 subfuncties ingevuld. Hoewel die subfuncties nu een nep-waarde geven, werkt de hele essentie van het programma al wel. Dat wil zeggen: wij weten wel welke loten we moeten kopen 😉 Het echte random loten produceren, dat moet er nog even in gepropt. Makkie!
- maak_loten. Deze moet nog het juiste aantal loten gaan produceren. Je gaf dit aantal al mee als parameter. Gebruik een for-loop over dit aantal.
- In deze for-loop moet je nu de cijfers en letters opvangen en het resultaat niet gelijk returnen, maar appenden aan de lijst met loten: loten.append(letter1 + letter2 + decijfers) Je doet return(loten) pas na deze loop.
Op dit moment levert je code dit mooie resultaat op:
- maak_letter(). Deze return het resultaat van random.choice(). Dit is een handige functie. Geef hem mee als parameter, een lijst met daarin elke letter van A tot Z als string [‘A’,’B’, enz enz]
- maak_cijfers. Gebruik ook de functie choice.random maar dan over de cijfers. Gebruik een for-loop van 6x om 6 cijfers te produceren. Begin deze functie met een variabele cijfers = ” en plak er telkens (in de loop) een stukje aan. Zet je de integers eerst om naar str voor je ze eraan plakt met + ?
Well Done !
Lever je masterpiece maar in.
Extra oefening ?
- Check de lijst met loten op unieke waarden, zo nodig vervangen.
- Maak enkele prijzen en trek de winnende loten uit de 100 (?) verkochte loten.
