Hoofdstuk 5 - Functies (deel 1)

Functies zijn een van de belangrijkste concepten bij programmeren. Het is krachtig, er kan heel veel mee, daarnaast verhoogt het de kwaliteit van je code: overzichtelijker, minder fout-gevoelig, en herbruikbaar. In hoofdstukken 5 en 6 leer je zelf functies schrijven.

---

Met een functie kun je code gebruiken dat een ander voor je geschreven heeft. Functies hebben we al eerder gebruikt, bijvoorbeeld bij het positief maken van een getal:

positief_getal = abs( -4 ) 
print( positief_getal )

Iemand anders heeft de code voor abs geschreven. Die functie kun je nu zelf gebruiken zonder dat je hoeft te weten hoe het precies geprogrammeerd is. Programmeren is lastig. Het is daarom fijn als er sommige details zijn waar je niet over na hoeft te denken. Daarnaast maakt het gebruik van functies je code overzichtelijk, en kun je makkelijk code hergebruiken. In deze les ga je leren om je eigen functies te schrijven.

We gaan nu uitgebreider in op wat een functie precies is en hoe het werkt.

H5.1 - Het nut van functies

Waarom zou je functies willen maken?

• Decompositie: Een (complexe) probleem opdelen in kleinere stukken om het makkelijker op te lossen. Ieder stuk ontwikkel en test je los van de rest op. De code kun je dan later gebruiken zonder er verder over na te denken.
• Hergebruik: Met functies kun je een bepaalde stuk code op meerdere plekken in je programma gebruiken. Je kunt dan beter verwijzen naar waar de code staat (de functie) dan het te kopiëren. Ook kun je dan code aan andere programmeurs beschikbaar stellen (via modules).
• Abstractie: Met parameters kun je de code voor meerdere toepassingen gebruiken, en wordt het ook makkelijker te lezen en te onderhouden.
• Overzichtelijkheid: Met functies kun je lange code opsplitsen en daardoor overzichtelijker maken.

H5.2 - Onderdelen van een functie

[VIDEOUITLEG over onderdelen van functies](https://web.microsoftstream.com/video/ad6f2778-c589-4dae-aa29-9ed15f123489)

Een functie is een blok herbruikbare code dat een bepaalde actie uitvoert. Om een functie aan te roepen (gebruiken) moet je drie dingen weten:

• Functienaam: hoe de functie heet
• Parameters: informatie die de functie nodig heeft
• Retourwaarde: wat de functie teruggeeft (als die iets teruggeeft)

Een functie kan gezien worden als een taak dat je aan iemand uitbesteed. Je roept een commando, geeft bepaalde informatie dat nodig hebben om de taak uit te voeren, en die persoon levert iets op (soms een getal of tekst, soms een dienst).

Voorbeeld van een functie: max

We geven een voorbeeld van een functie en bespreken de functienaam, parameters en retourwaarde.

Wil je het grootste getal van een rijtje getallen weten, dan roep je de functie max aan. Als je iemand vraagt om de grootste van een rijtje getallen voor je te bepalen, dan heeft die persoon als extra informatie het rijtje getallen nodig waarvan je de grootste wilt weten. Dat rijtje getallen zijn de parameters. Als resultaat wordt er een getal als antwoord geroepen. Dat resultaat moeten we zelf meteen opslaan anders vergeten we die.

grootste = max( -4, 2, 6 ) 

Voor de code hierboven is:

• Functienaam: max
• Parameters: -4, 2, 6. Dit is het rijtje getallen waarvan de grootste bepaald moet worden.
• Retourwaarde: het antwoord van de functie max dat we opslaan als grootste.

Parameters

Sommige functies hebben parameters (informatie) nodig. De parameters geef je tussen de haakjes mee. Hier volgen wat voorbeelden:

• Een getal als parameter:
  In de code hieronder is het getal -5 een parameter:
  

  positief_getal = abs( -5 )   # maak van het gegeven getal een positief getal

• Een string als parameter:
  In de code hieronder is de tekst "hallo" een parameter:
  

  print( "hallo" )

• Geen parameter:
  Functies hoeven niet altijd parameters te hebben. Bijvoorbeeld, print() kan ook aangeroepen worden zonder parameter:
  

  print()          #print een nieuwe regel

• Meerdere parameters:
  Als een functie meerdere parameters krijgt, maakt de volgorde wel uit. Bijvoorbeeld, de standaard functie pow() krijgt twee parameters, en rekent de waarde uit van de eerste tot de macht van de tweede:

  basis = 2
  exponent = 3
  antwoord = pow( basis, exponent )  # bereken 2 tot de macht 3
  print( antwoord )
  

Retourwaarde

Een functie kan wat opleveren of teruggeven, dit noemen we de retour waarde. Deze waarde wordt niet zomaar vanzelf onthouden. Het resultaat van een functie moet je daarom meteen opslaan.

In het voorbeeld hieronder levert de functie max het getal 6 op. Deze retourwaarde slaan we op in de variabele grootste. Bij de aanroep van zo'n functie moet je dus altijd een '='-teken gebruiken met aan de linkerkant een variabele waarin de retourwaarde opgeslagen wordt.

grootste = max( -4, 2, 6 ) 

Niet alle functies leveren iets op, bijvoorbeeld print() 'doet iets'. Die levert geen getal of tekst op, maar een dienst. Dan hoeven we ook niks op te slaan en kunnen we het aanroepen zonder een '='-teken.

Opgave 5.2.1 Onderdelen van een functie benoemen

Hieronder staat code. Geef voor elk van de volgende termen een voorbeeld uit de code:

1. Naam van de functie
2. Parameters
3. Type van parameters
4. Retourwaarde
5. Variabele waarin retourwaarde wordt opgeslagen
6. Type van retourwaarde

afgerond = round(3.14342, 2)  #afronden op 2 cijfers achter de komma

Voorbeeld uitwerking

H5.3 - Eigen Functies maken

VIDEOUITLEG over maken van eigen functies

Je kunt ook zelf een functie schrijven. Dan moet je bedenken hoe die heet, wat de parameters zijn en wat het oplevert. In het algemeen ziet dat er zo uit:

def functieNaam ( parameter1_naam, parameter2_naam ):
    actie()
    return .. # als de functie iets oplevert, gebeurt dit pas aan het einde

Functienaam</h2> Een functienaam moet duidelijk omschrijven wat een functie doet: gebruik daarom werkwoorden. Bestaat de naam uit meerdere woorden, plak die dan aan elkaar en begin elk nieuw woord met een hoofdletter. Bijvoorbeeld: berekenOppervlakte

Functiedefinitie

Een functiedefinitie is een beschrijving van een functie. Met een def geef je aan dat het om een definitie gaat. Daarna volgen de parameter(s) en een ':'. De code dat bij een functie hoort staat daaronder ingesprongen.

Voor de overzichtelijkheid zet je functiedefinities bij elkaar bovenaan de code.

Voorbeeld van een programma met een eigen functie</h2> Bekijk en run het onderstaand programma.

#FUNCTIEDEFINITIE
def totZiens():
	print( "..en dan..")
	print( "tot ziens!" )

#HOOFDPROGRAMMA MET AANROEP VAN FUNCTIE
print( "Hallo!" )
totZiens()
print( "Klaar! ")

De code is opgebouwd uit twee delen:

1. Functiedefinitie (def): Dit programma heeft één functie, namelijk totZiens() (regel 2). Deze functie heeft geen parameters (er staat niets tussen de haakjes). De twee ingesprongen regels horen bij de functie (regels 3 en 4).
2. Hoofdprogramma: Omdat functiedefinities alleen beschrijvingen zijn, wordt de code daarvan niet zomaar uitgevoerd. Python begint bij het uitvoeren van de regels van het hoofdprogramma (regel 8). Deze code wordt één-voor-één uitgevoerd. Functiedefinities horen dus niet bij het hoofdprogramma.

Hieronder zie je een stroomdiagram voor het hoofdprogramma.

De code van een functie wordt niet zomaar uitgevoerd, dat gebeurt pas als totZiens() in het hoofdprogramma aangeroepen wordt.

Bekijk het volgende filmpje voor extra uitleg over functies:

Filmpje met extra uitleg over functies

Volgorde van code uitvoer met functies

We bekijken nu de volgorde waarin code met functies uitgevoerd wordt.

Doorloop de bovenstaande code stapsgewijs door op het icoontje met de kleinere Play-knop te drukken:

Toon de regelnummers: Klik op de balk boven de code (naast de M) en druk dan op L.

1. Bij het uitvoeren van het programma worden de functiedefinities overgeslagen: er wordt meteen naar het hoofdprogramma gesprongen. Daar wordt als eerste "Hallo!" geprint (regel 7).

2. Daarna wordt de functie totZiens() aangeroepen (regel 8).

3. Het programma springt naar de definitie van totZiens() (regel 2).

4. De eerste regel in de functie print de tekst "..en dan.. "" (regel 3)

5. De volgende regel in de functie print "tot ziens!"(regel 4).

6. Dan is de functie afgelopen (er wordt namelijk niet meer ingesprongen).

7. Na afloop van de functie keert het terug naar het hoofdprogramma, waar hij verder gaat met de volgende regel code: het print "Klaar!"(regel 9).

8. Het programma is dan klaar en stopt. </ol> Functiedefinities worden dus in eerste instantie overgeslagen. De code van een functie wordt alleen uitgevoerd als de functie wordt aangeroepen.</p>

Opgave 5.3.1 Een functie aanroepen

Door functies aan te roepen ga je nu heel makkelijk het volgende tekenen:

In de code hieronder staat een functiedefinitie voor het tekenen van een vierkant. Jouw opdracht is om dit te gebruiken om de bovenstaande afbeelding met 2 vierkantjes te maken. Maak de afbeelding door in het hoofdprogramma:

1. Op regel 17: De functie tekenVierkant() aan te roepen

2. Op regel 18: 45 graden naar rechts te draaien

3. Op regel 19: De functie tekenVierkant() nog eens aan te roepen. </ol> Voor regelnummers: klik op de balk boven de code en dan op 'L'.

import turtle

### FUNCTIEDEFINITIE
#Definitie: Instructies voor het tekenen van een vierkant met grootte van 20
def tekenVierkant(  ):
    turtle.forward( 20 )
    turtle.right(90)
    turtle.forward( 20 )
    turtle.right(90)
    turtle.forward( 20 )
    turtle.right(90)
    turtle.forward( 20 )
    turtle.right(90)

### HOOFDPROGRAMMA MET AANROEP VAN FUNCTIE
turtle.pendown()
#Stap1: roep hier de functie aan voor tekenen van vierkant
#Stap2: draai rechts 45 graden
#Stap3: roep hier de functie aan voor tekenen van vierkant

turtle.done()

Voorbeeld uitwerking

Opgave 5.3.2 Een eigen functie maken: TekenSnoep()

Je gaat nu een eigen functie maken voor het tekenen van een lolly:

De code hieronder tekent een lolly, dat gebeurt zo:

• Het rode snoep-rondje in het eerste deel: code regels 6 t/m 9
• Het zwart stokje in het tweede deel: code regels 12 en 13

Ieder blok code heeft zijn eigen taak. Het is daarom logisch om hier twee functies van te maken:

• tekenSnoep()
• tekenStok()

Jouw opdracht:

1. Maak een functiedefinitie def tekenSnoep(): voor het tekenen van de snoep (dus voor de code regels 6 t/m 9).
2. Roep je functie tekenSnoep() aan in het hoofdprogramma.
3. Maak een functiedefinite voor tekenStok() van het tekenen van de stok.
4. Roep je functie tekenStok() aan in het hoofdprogramma.

import turtle

#### FUNCTIEDEFINITIES

# code voor het tekenen van de snoep:
turtle.fillcolor("red")
turtle.begin_fill()
turtle.circle(30)
turtle.end_fill()

# code voor het tekenen van de stok:
turtle.right(90)
turtle.forward(100)

### HOOFDPROGRAMMA
turtle.pendown()
#roep hier je functie tekenSnoep() aan
#roep hier je functie tekenStok() aan
turtle.done()

Voorbeeld uitwerking

Overzichtelijke hoofdprogramma

Het grote voordeel van gebruik maken van functies is dat het hoofdprogramma nu duidelijk samenvat wat de code als geheel doet, zonder dat je naar allerlei code details hoeft te kijken. Dat zie je in de code van je vorige opdracht ook: in het hoofdprogramma wordt de pen neergezet, snoep getekend en daarna het stokje:

Dit leest als een soort inhoudsopgave van een boek. Als je details wilt zien ga je naar de bijbehorende functiedefinitie. Als je bijvoorbeeld wilt zien hoe groot de snoep precies getekend wordt, kun je naar de code van tekenSnoep()) gaan.

#HOOFDPROGRAMMA
turtle.pendown()

tekenSnoep()
tekenStok()

turtle.done()

Dit leest als een soort inhoudsopgave van een boek. Als je details wilt zien ga je naar de bijbehorende functiedefinitie. Als je bijvoorbeeld wilt zien hoe groot de snoep precies getekend wordt, kun je naar de code van tekenSnoep()) gaan.

H5.4 - Functies met en zonder parameters en retourwaarden

Een functie bij het programmeren is net als een functie die iemand heeft in een bedrijf: ze moeten iets doen. Soms moet die persoon informatie van je hebben om zijn werk goed te doen (invoer). Soms levert het een concreet product op (iemand maakt iets voor je), en soms een dienst op (iemand doet iets voor je). Neem de bakker bijvoorbeeld:

• Wat doet de bakker? Hij bakt brood.
• Welk informatie heeft de bakker van je nodig? Hij moet weten welk brood je wilt, en bijvoorbeeld of je een hele of een half brood wil. Dit informatie geef je aan de bakker (als parameter).
• Wat geeft de bakker jou? De bakker levert een brood op dat hij aan jou geeft (als retourwaarde).

Algemene uitleg over verschillende soorten functies

Je hebt verschillende soorten functies:

1. Zonder parameters, zonder retourwaarde:
   Deze geef je geen informatie (dus zonder parameters), en geeft niets terug (dus levert geen retourwaarde op). Soms kan iemand iets doen zonder dat hij of zij daar specifiek informatie voor nodig heeft, en zonder dat het echt een tastbare retourwaarde (of resultaat) oplevert. Bijvoorbeeld de buschauffeuse, deze rijdt rondjes en stopt op vaste locaties, je stapt in de bus, je hoeft haar niet te vertellen waar ze heen (geen parameters) moet rijden en ze geeft jou ook niets (levert geen concreet resultaat op).
2. Met parameters, zonder retourwaarde:
   Deze geef je wel informatie aan (dus met parameters), maar geeft niets terug (dus levert geen retourwaarde op). Soms heeft iemand specifiek informatie om iets te doen, maar het hoeft niet per se een tastbare retourwaarde (of resultaat) op te leveren. Bijvoorbeeld de bibliothecaresse die boeken inneemt, je geeft haar jouw boeken, zei registreert dat je ze in hebt geleverd en zet op de juiste plek terug in de bibliotheek.
3. Met parameters, met retourwaarde:
   Deze geef je wel informatie aan (dus met parameters), en geeft je iets terug (dus levert met return een concrete retourwaarde op). Soms heeft iemand specifiek informatie om iets te doen, en geeft je ook iets terug (een resultaat) waar je daarna iets mee kan doen. Bijvoorbeeld de loketmedewerker bij een geldwisselkantoor: je geeft haar Euro’s omdat je Dollars nodig hebt voor je vakantie in Amerika, ze berekent hoeveel Dollars die Euro’s waard zijn, en geeft je Dollars terug.
4. Zonder parameters, met retourwaarde:
   Deze geef je geen informatie aan (dus zonder parameters), maar geeft je wel iets terug (dus levert met return een concrete retourwaarde): Soms heeft iemand geen specifiek informatie nodig om iets te doen, maar geeft je wel iets terug (een resultaat) waar je daarna iets mee kan doen. Bijvoorbeeld een verkeersregelaar, die geeft aanwijzingen wat je moet doen.

We bekijken nu specifieke voorbeelden van functies met en zonder parameters (hierboven, de eerste twee). In het volgende hoofdstuk kijken we naar retourwaarden (hierboven, de onderste twee).

Functies zonder parameters en zonder retourwaarde

Code dat bij elkaar hoort of dat vaker gebruikt wordt, zet je samen in een functie. Soms heeft een functie geen parameters, omdat deze geen specifieke informatie nodig heeft. Soms levert een functie geen retourwaarde op, maar "doet het iets".

Bekijk het voorbeeld hieronder. De 5 regels code voor het tekenen van een driehoek horen bij elkaar omdat ze samen een doel bereiken, daarom staan ze bij elkaar in een functie tekenDriehoek(). Deze functie heeft geen parameters (er staat niets tussen de haakjes) en ook geen retourwaarde (het levert niks op, maar het doet iets).

import turtle

#FUNCTIEDEFINITIE
def tekenDriehoek():
	turtle.forward(50)
	turtle.right(120)
	turtle.forward(50)
	turtle.right(120)
	turtle.forward(50)

#HOOFDPROGRAMMA MET FUNCTIEAANROEP
turtle.pendown()
tekenDriehoek()

Opgave 5.4.1 Figuurtje tekenen

Bekijk de code hieronder. Zonder de code te runnen, beantwoord voor jezelf de volgende vragen:

1. Vat in je eigen woorden samen wat de functie tekenFiguur() doet. Wat zou een betere naam voor de functie zijn?

2. Heeft tekenFiguur() informatie nodig om zijn werk te doen, oftewel, krijgt hij parameters mee?

3. Levert tekenFiguur() informatie op (dat bijvoorbeeld later in het programma nog gebruikt kan worden), oftewel, heeft tekenFiguur() een code regel met return?

4. Roep tekenFiguur() aan op regel 16, dus na turtle.right(135).

5. Als tekenFiguur()niet in een functie had gestaan, hoe vaak had je dan turtle.forward(50) moeten intikken om hetzelfde resultaat te krijgen? </ol> Run de code om je vermoedens te controleren.

import turtle

### FUNCTIEDEFINITIE
def tekenFiguur():
	turtle.forward(50)
	turtle.right(120)
	turtle.forward(50)
	turtle.right(120)
	turtle.forward(50)

### HOOFDPROGRAMMA MET FUNCTIEAANROEP
turtle.pendown()
tekenFiguur()
turtle.right(135)

turtle.done()

Voorbeeld uitwerking

Functies met parameters, maar zonder retourwaarde

VIDEOUITLEG over parameters

Heb je code dat je vaker gebruikt, maar er telkens iets anders uit ziet? Dan kan je met parameters aangeven wat er in de functie anders moet.

Stel tekenDriehoek() moet steeds een ander kleur gebruiken. De functie tekenDriehoek() moet de kleur weten. De kleur geef je als parameter (extra informatie) mee:

• Aanroep: Geef de kleur mee bij de aanroep van de functie: tekenDriehoek( "red" ) (regel 14).
• Functiedefinitie: Geef in de functiedefinitie aan hoe dat informatie binnen de functie genoemd wordt: hier kleur (regel 3). In de functie zelf wordt elke voorkomen van kleur, vervangen door "red", bijvoorbeeld op regel 4.

import turtle

#FUNCTIEDEFINITIE
def tekenDriehoek( kleur ):
    turtle.pencolor( kleur )
    turtle.forward(50)
    turtle.right(120)
    turtle.forward(50)
    turtle.right(120)
    turtle.forward(50)

#HOOFDPROGRAMMA MET FUNCTIEAANROEP
turtle.pendown()
tekenDriehoek( "red" )

turtle.done()

Opgave 5.4.2 Cirkels met verschillende maten tekenen

Hieronder zie je de functie tekenCirkel( kleur ) die als extra informatie (parameter) een kleur meekrijgt. Run de code.

Breid de code uit zodat ook de grootte van de cirkel meegegeven wordt:

1. Zet de regelnummers aan. Klik op de balk boven de code (naast de M) en druk dan op L.
2. Pas de functiedefinitie aan op regel 5 zodat deze ook een grootte meekrijgt: def tekenCirkel( kleur, grootte ):
3. Vervang in je functie de 'harde waarde' (het getal 50) door de naam die je gekozen hebt voor de informatie: grootte
4. Roep in je hoofdprogramma de functie aan met de juiste informatie (op regel 10).
5. Roep in je hoofdprogramma de functie nog een keer aan (op regel 11), deze keer met een andere kleur en andere grootte.

import turtle

### FUNCTIEDEFINITIE
#tekent een cirkel, en krijgt als informatie (parameter) de kleur mee
def tekenCirkel( kleur ):
	turtle.pencolor( kleur )
	turtle.circle( 50 )

### HOOFDPROGRAMMA
tekenCirkel( "blue" )

turtle.done()

Voorbeeld uitwerking

Opgave 5.4.3 Persoonlijke groet

Hieronder staat een functiedefinitie die een groet print. Jouw opdracht is om dat persoonlijker te maken: "Hallo Sebas uit Spanje!". De boodschap is natuurlijk afhankelijk van wat er als informatie aan de functie wordt meegegeven.

Pas de functiedefinitie aan zodat naam en land meegegeven wordt, en dat informatie gebruikt wordt voor het afdrukken van de persoonlijke groeten.

### FUNCTIEDEFINITIE
groet( ):
    print( "Hallo!" )

### HOOFDPROGRAMMA MET AANROEP VAN FUNCTIE
groet( "Sebas", "Spanje" )
groet( "John", "Engeland" )
groet( "Janneke", "Nederland" )

Voorbeeld uitwerking

H4.4 - Functies aanroepen vanuit andere functies

Functies mogen andere functies aanroepen. Bijvoorbeeld, hieronder zie je hoe de functie tekenLolly() (regel 17) de functies tekenSnoep() en tekenStok() gebruikt om de lolly als geheel te tekenen:

import turtle

#FUNCTIEDEFINITIES
#teken snoep
def tekenSnoep( straal, kleur ): 
  turtle.fillcolor( kleur)
  turtle.begin_fill()
  turtle.circle( straal )
  turtle.end_fill()

#teken stok
def tekenStok( lengte_stok ):
  turtle.right(90)
  turtle.forward( lengte_stok )
        
#tekent lolly
def tekenLolly( straal, kleur, lengte_stok ):
  tekenSnoep( straal, kleur )
  tekenStok( lengte_stok ) #andere functie wordt aangeroepen om stok te tekenen

#HOOFDPROGRAMMA
turtle.pendown()
tekenLolly(40, "blue", 100 ) #parameters: straal, kleur, lengte_stok)
turtle.done()

H5.5 - Leesbaarheid

Overzichtelijke code

Code wordt leesbaarder door:

• goede keuze van variabelnamen en functienamen: zinvol en volgens conventies (zoals var_naam of functieNaam),
• gebruik te maken van witregels tussen functies of blokken code die bij elkaar horen,
• code bij elkaar te zetten dat bij elkaar hoort, zoals het scheiden van functiedefinities van het hoofdprogramma,
• globale variabelen (constanten en variabelen die door het hele programma gebruikt worden) bij elkaar bovenaan de code te zetten.

Functies om leesbaarheid te verbeteren

Je code wordt ook overzichtelijker als je code dat bij elkaar hoort, en dus een doel heeft, bij elkaar zet in een functie. De doel vat je samen in de functienaam. Een functie hoort geen zijeffecten te hebben, het doet wat de samenvatting zegt, en verder niks. Dat wil zeggen, een functie isEven() bepaalt of een getal even of oneven is, maar doet verder helemaal niks! Anders wordt het namelijk moeilijker om over je code te redeneren

Commentaar om leesbaarheid te verbeteren

Commentaar is bedoeld om code toe te lichten. Commentaar geef je aan met een #. Python negeert deze tijdens de uitvoering. Commentaar is niet alleen nuttig voor anderen die je code lezen, maar ook voor jezelf, aangezien je soms je eigen code later nog moet wijzigen. Gebruik het dus om blokken code samen te vatten, ingewikkelde code uit te leggen, of als je een bestaande functie voor het eerst gebruikt, uit te leggen wat het doet.

#Deze functie heeft als doel om ....
def doeIets():
	print( "Iets..." ) # Dit is commentaar

Functiecommentaar

Het idee achter een functie is dat de gebruiker van de functie de code van de functie niet hoeft te kennen. Functiecommentaar schrijf je boven ieder functiedefinitie. Met functiecommentaar geef je aanwijzingen over het gebruik van je functie:

• Samenvattend: Hoe de functie werkt
• Onder welke omstandigheden de functie (niet) goed werkt
• Welke parameters meegegeven moeten worden
• Wat de functie retourneert, ook bij ongeldige invoer

Bijvoorbeeld:

### FUNCTIEDEFINITIE
#Doel: rekent aantal kilometers (groter of gelijk aan 0) om naar meters
#Invoer: kilomters, als int of float
#Uitvoer: meters, als int of float (zelfde type als de invoer)
def rekenKmNaarMeters(afstand_in_km):
	afstand_in_m = afstand_in_km * 1000
	return( afstand_in_m )

### HOOFDPROGRAMMA MET AANROEP VAN FUNCTIE
aantal_meters = rekenKmNaarMeters( 4 )
print( aantal_meters 

Strategie: Commentaar gebruiken tijdens debuggen

Je kunt commentaar ook goed gebruiken om de oorzaak van fouten in je code op te sporen. Met # kan je een regel in commentaar zetten. Die doet dan niet meer mee aan het programma, en kun je uitsluiten dat de regel een fout veroorzaakt. Ook kun je meerdere regels in commentaar zetten en regel-voor-regel de commentaar weg halen om zo te ontdekken wat de fout veroorzaakt.

Tip: meerdere regels in één keer in commentaar:

1. Selecteer de code dat je in commentaar wilt zetten.
2. Druk gelijktijdig op Ctrl en / om de geselecteerde regels allemaal in één keer in commentaar te zetten.
3. Run de code. Is de fout opgelost? Dan zit de fout in de code dat je net in commentaar hebt gezet.
4. Haal één regel uit commentaar en run de code opnieuw.
5. Herhaal regel-voor-regel totdat je de oorzaak van de fout hebt ontdekt.

Opgave 5.5.1 Commentaar

Het onderstaande programma staat helemaal in commentaar.

1. Haal, met behulp van Ctrl en /, het hele programma uit commentaar.
2. Voeg commentaar toe om de functiedefinities van het hoofprogramma te scheiden. Gebruik hiervoor ### FUNCTIEDEFINITIE en ### HOOFDPROGRAMMA.
3. Zoals na elke wijziging: test het programma.

# def rekenKmNaarMeters(afstand_in_km):
# 	afstand_in_m = afstand_in_km * 1000
# 	return( afstand_in_m )


# aantal_meters = rekenKmNaarMeters( 4 )
# print( aantal_meters )

Voorbeeld uitwerking

H5 - Functies (deel 1): Leerdoelen

Vink je behaalde leerdoelen af:

1. dubbelklik op het leerdoel
2. zet er een [X] neer
3. klik ergens anders in je notebook om het vinkje te zien

Ik kan:

• [ ] uitleggen dat functies helpen om code overzichtelijk en herbruikbaar te maken.
• [ ] uitleggen dat een parameter informatie is dat een functie meekrijgt om zijn werk te kunnen uitvoeren.
• [ ] uitleggen dat een retourwaarde informatie is dat een functie teruggeeft aan het hoofdprogramma.
• [ ] een programma met functies traceren, door in te zien dat def's worden overgeslagen en de code in het hoofdprogramma als eerste wordt uitgevoerd.
• [ ] een eigen functie maken en aanroepen.
• [ ] parameters gebruiken om functies generieker te maken.
• [ ] functies aanroepen vanuit andere functies.
• [ ] code overzichtelijk maken door functiedefinities boven aan de code bij elkaar te zetten, apart van de code van het hoofdprogramma.
• [ ] zinvolle (functie)commentaar toevoegen om de leesbaarheid van mijn code te verbeteren.
• [ ] met Ctrl en / meerdere regels code in één keer in (of uit) commentaar te zetten.

---

H5 - Functies (deel 1): Afsluitende Opgaven

Met de volgende afsluitende opgaven kun je kijken hoe goed je de stof beheerst. Controleer steeds je eigen oplossing met de voorbeeldoplossing.

---

Afsluitende opgave 5.1 Teken lolly met parameters

De code hieronder (uit opgave 5.3.2) tekent een lolly: rode snoep met een zwart stokje.

We willen de gebruiker vragen welke kleur gewenst is, hoe groot de lolly moet zijn en hoe lang het stokje moet zijn.

Pas je code stapsgewijs aan en test steeds tussendoor!

1. Vraag de gebruiker om een kleur en sla de gewenste kleur op in een variabele.
2. Pas de functiedefinitie van tekenSnoep (op regel 5) aan zodat deze een kleur verwacht.
3. Gebruik de gegeven kleur in plaats van "red".
4. Pas de aanroep van tekenSnoep (in je hoofdprogramma) aan zodat de gewenste kleur meegegeven wordt.
5. Test je programma.

Breid je code dan uit voor de gewenste straal van de snoep. Test je programma. Tip: de invoer moet je omzetten naar een int.

Als dat werkt, vraag je de gebruiker ook hoe lang het stokje moet zijn.

Teken de gewenste lolly.

import turtle

### FUNCTIEDEFINITIES
#teken snoep
def tekenSnoep( ): 
        turtle.fillcolor("red")
        turtle.begin_fill()
        turtle.circle( 40 ) 
        turtle.end_fill()

#teken stok
def tekenStok( ):
        turtle.right( 90 )
        turtle.forward( 100 )

### HOOFDPROGRAMMA
turtle.pendown()
tekenSnoep()
tekenStok()						
turtle.done()

Voorbeeld uitwerking

Afsluitende opgave 5.2 Olympische Ringen

Schrijf een programma dat, in kleur, de olympische ringen tekent.

Hier zijn de gegevens van elk van de 5 cirkels:

• Blauwe (blue) cirkel op coördinaat (0,0)
• Paarse (purple) cirkel op coördinaat (-120,0)
• Rode (red) cirkel op coördinaat (60,60)
• Gele (yellow) cirkel op coördinaat (-60, 60)
• Groene (green) cirkel op coördinaat (-180,60)

Bedenk dat je steeds een cirkel wilt tekenen, maar op een ander coördinaat met een ander kleur. Om dit voor elkaar te krijgen schrijf je een functie tekenGekleurdeRing() die 3 parameters als informatie meekrijgt: de kleur, de x-coördinaat en de y-coördinaat.

Tips:

• met turtle.setposition(x,y) kun je turtle naar coördinaat (x,y) laten lopen
• met turtle.circle(50) kun je een cirkel met straal 50 laten tekenen
• met turtle.pencolor("red") kun je een penkleur aangeven

import turtle

### FUNCTIEDEFINITIE:


### HOOFDPROGRAMMA:


turtle.done()

Voorbeeld uitwerking

Afsluitende opgave 5.3 Wat voor een getal?

Schrijf een functie die een getal als parameter krijgt en afdrukt of deze kleiner is dan 0, gelijk is aan 0, of groter is dan 0.

Dus, als je functie het getal 2 meekrijgt (bv. checkGetal(2) ) moet de functie afdrukken: "Het getal 2 is groter dan 0."

Test je functie. Welke testgevallen zijn geschikt om te testen of je functie altijd goed werkt? Tip: Er zijn minstens drie testgevallen, dus je roept je functie minstens drie keer aan om te testen.

### FUNCTIEDEFINITIE
# typ hier je functie



### HOOFDPROGRAMMA MET AANROEP VAN FUNCTIE 
# typ hier je functie aanroep

Voorbeeld uitwerking

Afsluitende opgave 5.4 Tekenprogramma

Het onderstaande programma heeft functies voor het tekenen van verschillende vormen. Breid het hoofprogramma uit zodat je de gebruiker vraagt welk figuur die wil laten tekenen, of dat ze allemaal getekend moeten worden: "Wat wil je dat ik teken: cirkel, vierkant, driehoek, of allemaal.", en het dan ook tekent. Als de gebruiker iets anders intypt, geef dan een foutmelding.

import turtle
### FUNCTIEDEFINITIES
def tekenCirkel():
    turtle.circle(50)

def tekenDriehoek():
    for i in range(3):
        turtle.forward(100)
        turtle.right(120)

def tekenVierkant():
    for i in range(4):
        turtle.forward(100)
        turtle.right(90)

### HOOFDPROGRAMMA
print("Wat wil je dat ik teken: cirkel, vierkant, driehoek, of allemaal.")





print("Klaar")
turtle.done()

Voorbeeld uitwerking

Afsluitende opgave 5.5 Bereken je cijfer

Je cijfer op een wiskundetoets bestaande uit 60 punten wordt zo berekend: cijfer = (aantal_punten*9) / 60 + 1

Heb je 40 punten gehaald, dan is je cijfer een 7.

Schrijf een functie berekenCijfer( aantal_punten ) dat, gegeven het aantal behaalde punten, je cijfer uitrekent en print. In je hoofdprogramma roep je de functie aan. Test je code met verschillende waarden. Hoeveel punten moet je halen voor een 10? En wat is je cijfer als je 0 punten scoort?

Voorbeeld uitwerking

Afsluitende opgave 5.6 Dorp tekenen: Functies aanroepen vanuit andere functies

We gaan verder met de code voor het tekenen van een huis waarbij we twee functies hebben:

1. tekenMuren(): voor het tekenen van de muren
2. tekenDak(): voor het tekenen van het dak

Deel A. Functie voor een huis
We maken een functie voor een huis zodat je deze makkelijk vaker kunt aanroepen.

1. Schrijf een functie tekenHuis() voor het tekenen van een huis:
   1. Op regel 25 schrijf je in commentaar wat je functie doet (zoals op regels 5 en 15)
   2. Op regel 26 maak je een FUNCTIEDEFINITIE: def ... (maak zelf verder af)
   3. Binnen de functie, op regels 27 en 28 roep je de functies tekenMuren() en tekenDak() aan. Tip: let erop dat je inspringt.
2. In het hoofdprogramma op regel 31 wordt de functie tekenHuis() al aangeroepen. Test of het werkt.

DEEL B. Dorp tekenen
Om een dorp te tekenen roep je tekenHuis() een aantal keer achter elkaar aan (in het hoofdprogramma). Tussendoor verplaats je de startpunt voor het tekenen met turtle.setposition(x, y) waarbij je voor x en y coördinaat kiest, bijvoorbeeld turtle.setposition(250, 0). Met turtle.setheading(0) zorg je dat de pen in de juiste startrichting staat (naar rechts) Met turtle.penup() zorg je dat er tussendoor geen lijntje wordt getekend. Wil je weer tekenen, gebruik dan weer turtle.pendown().

import turtle

### FUNCTIEDEFINITIES

#Tekent zwarte vierkant
def tekenMuren():
	turtle.forward(150)
	turtle.right(90)
	turtle.forward(150)
	turtle.right(90)
	turtle.forward(150)
	turtle.right(90)
	turtle.forward(150)

#Tekent een rood gevulde dak
def tekenDak():
	turtle.fillcolor("red")
	turtle.begin_fill()
	turtle.right(30)
	turtle.forward(150)
	turtle.right(120)
	turtle.forward(150)
	turtle.end_fill()






### HOOFDPROGRAMMA
tekenHuis()

turtle.done()

Voorbeeld uitwerking

Afsluitende opgave 5.7 De wielen van de bus

Hieronder staat de tekst van het kinderlied De wielen van de bus. Zoals je ziet is er best veel herhaling. Elk couplet lijkt veel op de vorige, alleen het onderdeel en de bijbehorende actie is anders.

1. Schrijf een functie zingCouplet() dat de eerste couplet afdrukt. Hiervoor gebruik je vier keer een print(): een print() per tekstregel.

2. Pas de functie zingCouplet aan zodat die twee parameters meekrijgt: een onderdeel en actie.

3. In de code van de functie vervang je wielen door onderdeel, en draaien rond vervang je door actie.

4. Roep je functie aan met zingCouplet( "wielen", "draaien rond" ).

5. Roep vervolgens de functie zingCouplet() een paar keer aan, telkens met andere parameters aan voor de volgende drie coupletten. </ol> Tip: Een lege regel druk je af met print( "\n" ). Bedenk waar je dat het handigst kan doen. Je hoeft je niet druk te maken om hoofdletters.

   De wielen van de bus draaien rond
   Draaien rond, draaien rond
   De wielen van de bus draaien rond
   Als de bus gaat rijden
   
   

   De deuren van de bus gaan open en dicht
   Gaan open en dicht, gaan open en dicht
   De deuren van de bus gaan open en dicht
   Als de bus gaat rijden
   
   

   De wissers van de bus gaan heen en weer
   Gaan heen en weer, gaan heen en weer
   De wissers van de bus gaan heen en weer
   Als de bus gaat rijden
   
   

   De lichten van de bus gaan aan en uit
   Gaan aan en uit, gaan aan en uit
   De lichten van de bus gaan aan en uit
   Als de bus gaat rijden

Voorbeeld uitwerking