def verdrievoudigen(x):
    """Verdrievoudigen."""
    return 3 * x

print(verdrievoudigen(4), verdrievoudigen("ab"), verdrievoudigen(1.5))

12 ababab 4.5

def kwadraat(x):
    """Kwadraat van x."""
    print(x ** 2)

resultaat = kwadraat(5)
print(resultaat)

25
None

def verschil(a, b):
    """Verschil van a en b."""
    return a - b

x = 10
y = 4
print(verschil(y, x), verschil(x, y))

-6 6

def volgende(x):
    """Het volgende getal."""
    return x + 1
    print("klaar")

def volgende_bis(x):
    """Het volgende getal."""
    print("klaar")
    return x + 1

print(volgende(volgende(2)))
print(volgende_bis(volgende_bis(2)))

4
klaar
klaar
4

def verhoog(getal):
    """Getal verhogen met 10."""
    getal = getal + 10
    return getal

getal = 5
nieuw = verhoog(getal)
print(getal, nieuw)

5 15

def opp_vierkant(z):
    """Oppervlakte van een vierkant met zijde z."""
    return z ** 2

def opp_kubus(z):
    """Totale oppervlakte van een kubus met ribbe z."""
    return 6 * opp_vierkant(z)

print(opp_kubus(3), opp_vierkant(opp_vierkant(2)))

54 16

import math

def schuine_zijde(a, b):
    """Schuine zijde van een rechthoekige driehoek met rechthoekszijden a en b."""
    return math.sqrt(a ** 2 + b ** 2)

print(schuine_zijde(3, 4), int(schuine_zijde(5, 5)))

5.0 7

def prijs_met_btw(prijs):
    """Prijs inclusief 21 % btw."""
    return prijs * 1.21

p = input("Prijs zonder btw? ")
print(p * 2, prijs_met_btw(float(p)))

Prijs zonder btw? 100
100100 121.0

def procent(x, p):
    """p procent van x."""
    return x * p / 100

for g in [50, 80, 300]:
    print(f"20 % van {g} is {procent(g, 20)}")

20 % van 50 is 10.0
20 % van 80 is 16.0
20 % van 300 is 60.0

def beoordeling(punt):
    """Geslaagd of niet."""
    if punt >= 10:
        return "geslaagd"
    return "niet geslaagd"

print(beoordeling(12), "-", beoordeling(9.5))

geslaagd - niet geslaagd

def halveren(x):
    """Helft van x."""
    helft = x / 2

print(halveren(10) + 1)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[12], line 5
      1 def halveren(x):
      2     """Helft van x."""
      3     helft = x / 2
      4 
----> 5 print(halveren(10) + 1)

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

def opp_rechthoek(l, b):
    """Oppervlakte van een rechthoek met lengte l en breedte b."""
    return l * b

print(opp_rechthoek(7))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[13], line 5
      1 def opp_rechthoek(l, b):
      2     """Oppervlakte van een rechthoek met lengte l en breedte b."""
      3     return l * b
      4 
----> 5 print(opp_rechthoek(7))

TypeError: opp_rechthoek() missing 1 required positional argument: 'b'

def f(x):
    """f(x) = x² - 4x + 3"""
    return x ** 2 - 4 * x + 3

for x in range(0, 5):
    print(x, f(x))

0 3
1 0
2 -1
3 0
4 3

def bewerking1(a, b):
    """Kwadraat van de som van a en b."""
    return (a + b) ** 2

def bewerking2(a, b):
    """Som van de kwadraten van a en b."""
    return a ** 2 + b ** 2

print(bewerking1(3, 4), bewerking2(3, 4), bewerking1(3, 4) - bewerking2(3, 4))

49 25 24

#uitbreiding (bonusvraag)
class Rechthoek:
    """Klasse Rechthoek."""

    def __init__(self, lengte, breedte):
        """Initialisatie: een rechthoek heeft een lengte en een breedte."""
        self.l = lengte
        self.b = breedte

    def oppervlakte(self):
        """Oppervlakte van de rechthoek."""
        return self.l * self.b

r1 = Rechthoek(4, 3)
r2 = Rechthoek(2, 5)
print(r1.oppervlakte() + r2.oppervlakte(), r1.l)

22 4

def omtrek_vierkant(z)
    """Omtrek van een vierkant met zijde z."""
    return 4 * z

print(omtrek_vierkant(6))

  Cell In[17], line 1
    def omtrek_vierkant(z)
                          ^
SyntaxError: expected ':'

def omtrek_vierkant(z):
    """Omtrek van een vierkant met zijde z."""
    return 4 * z

print(omtrek_vierkant(6))

24

def verdubbelen(x):
    """Verdubbelen."""
    dubbel = 2 * x

print(f"Het dubbel van 7 is {verdubbelen(7)}.")

Het dubbel van 7 is None.

def verdubbelen(x):
    """Verdubbelen."""
    dubbel = 2 * x
    return dubbel

print(f"Het dubbel van 7 is {verdubbelen(7)}.")

Het dubbel van 7 is 14.

def prijs_na_korting(pr, per):
    """Prijs na een korting van per procent op een prijs pr."""
    nieuwe_prijs = pr * (1 - pr / 100)
    return nieuwe_prijs

print(f"De prijs na korting is {prijs_na_korting(100, 35)} euro.")

De prijs na korting is 0.0 euro.

def prijs_na_korting(pr, per):
    """Prijs na een korting van per procent op een prijs pr."""
    nieuwe_prijs = pr * (1 - per / 100)
    return nieuwe_prijs

print(f"De prijs na korting is {prijs_na_korting(100, 35)} euro.")

De prijs na korting is 65.0 euro.

print(opp_driehoek(6, 4))

def opp_driehoek(b, h):
    """Oppervlakte van een driehoek met basis b en hoogte h."""
    return b * h / 2

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[23], line 1
----> 1 print(opp_driehoek(6, 4))
      2 
      3 def opp_driehoek(b, h):
      4     """Oppervlakte van een driehoek met basis b en hoogte h."""

NameError: name 'opp_driehoek' is not defined

def opp_driehoek(b, h):
    """Oppervlakte van een driehoek met basis b en hoogte h."""
    return b * h / 2

print(opp_driehoek(6, 4))

12.0

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

print(round(opp_cirkel(2), 2))

12.57

import math

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

print(round(opp_cirkel(2), 2))

12.57

def inhoud_kubus(z):
    """Inhoud van een kubus met ribbe z."""
    return z ** 3

zijde = input("Ribbe van de kubus? ")
print(f"De inhoud is {inhoud_kubus(zijde)}.")

Ribbe van de kubus? 3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[27], line 6
      2     """Inhoud van een kubus met ribbe z."""
      3     return z ** 3
      4 
      5 zijde = input("Ribbe van de kubus? ")
----> 6 print(f"De inhoud is {inhoud_kubus(zijde)}.")

Cell In[27], line 3, in inhoud_kubus(z)
      1 def inhoud_kubus(z):
      2     """Inhoud van een kubus met ribbe z."""
----> 3     return z ** 3

TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

def inhoud_kubus(z):
    """Inhoud van een kubus met ribbe z."""
    return z ** 3

zijde = int(input("Ribbe van de kubus? "))
print(f"De inhoud is {inhoud_kubus(zijde)}.")

Ribbe van de kubus? 3
De inhoud is 27.

def inhoud_piramide(z, h):
    """Inhoud van een piramide met vierkant grondvlak met zijde z en hoogte h."""
    return z ** 2 * h / 3

# piramide met een vierkant grondvlak met zijde 6 m en hoogte 9 m
print(f"Inhoud: {inhoud_piramide(9, 6)} m³")

Inhoud: 162.0 m³

def inhoud_piramide(z, h):
    """Inhoud van een piramide met vierkant grondvlak met zijde z en hoogte h."""
    return z ** 2 * h / 3

# piramide met een vierkant grondvlak met zijde 6 m en hoogte 9 m
print(f"Inhoud: {inhoud_piramide(6, 9)} m³")

Inhoud: 108.0 m³

def som_lijst(getallen):
    """Som van alle getallen in de lijst."""
    totaal = 0
    for g in getallen:
        totaal += g
        return totaal

print(som_lijst([4, 7, 9]))

4

def som_lijst(getallen):
    """Som van alle getallen in de lijst."""
    totaal = 0
    for g in getallen:
        totaal += g
    return totaal

print(som_lijst([4, 7, 9]))

20

def gemiddelde(a, b, c):
    """Gemiddelde van a, b en c."""
    gem = (a + b + c) / 3
    return gem

gemiddelde(12, 15, 18)
print(gem)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[33], line 7
      3     gem = (a + b + c) / 3
      4     return gem
      5 
      6 gemiddelde(12, 15, 18)
----> 7 print(gem)

NameError: name 'gem' is not defined

def gemiddelde(a, b, c):
    """Gemiddelde van a, b en c."""
    gem = (a + b + c) / 3
    return gem

gem = gemiddelde(12, 15, 18)
print(gem)

15.0

#uitbreiding (bonusvraag)
class Gletsjer:
    """Klasse Gletsjer."""

    def __init__(self, gletsjer_naam, gletsjer_land):
        """Initialisatie: naam en land van de gletsjer."""
        self.naam = gletsjer_naam
        self.land = gletsjer_land

    def kenmerken(self):
        """Geeft attributen weer."""
        print(f"De gletsjer {naam} ligt in {self.land}!")

gletsjer1 = Gletsjer("Aletschgletsjer", "Zwitserland")
gletsjer1.kenmerken()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[35], line 15
     11         """Geeft attributen weer."""
     12         print(f"De gletsjer {naam} ligt in {self.land}!")
     13 
     14 gletsjer1 = Gletsjer("Aletschgletsjer", "Zwitserland")
---> 15 gletsjer1.kenmerken()

Cell In[35], line 12, in Gletsjer.kenmerken(self)
     10     def kenmerken(self):
     11         """Geeft attributen weer."""
---> 12         print(f"De gletsjer {naam} ligt in {self.land}!")

NameError: name 'naam' is not defined

#uitbreiding (bonusvraag)
class Gletsjer:
    """Klasse Gletsjer."""

    def __init__(self, gletsjer_naam, gletsjer_land):
        """Initialisatie: naam en land van de gletsjer."""
        self.naam = gletsjer_naam
        self.land = gletsjer_land

    def kenmerken(self):
        """Geeft attributen weer."""
        print(f"De gletsjer {self.naam} ligt in {self.land}!")

gletsjer1 = Gletsjer("Aletschgletsjer", "Zwitserland")
gletsjer1.kenmerken()

De gletsjer Aletschgletsjer ligt in Zwitserland!

import math

def omtrek_cirkel(r):
    """Omtrek van een cirkel met straal r."""
    ...
    return omtrek

# omtrek van een cirkel met diameter 10 cm
...
print(f"De omtrek is {...} cm.")

De omtrek is Ellipsis cm.

import math

def omtrek_cirkel(r):
    """Omtrek van een cirkel met straal r."""
    omtrek = 2 * math.pi * r
    return omtrek

# omtrek van een cirkel met diameter 10 cm
o = omtrek_cirkel(10 / 2)
print(f"De omtrek is {round(o, 2)} cm.")

De omtrek is 31.42 cm.

def naar_fahrenheit(...):
    """..."""
    ...
    return ...

for c in [0, 20, 37, 100]:
    print(f"{c} °C = {...} °F")

  Cell In[39], line 1
    def naar_fahrenheit(...):
                        ^
SyntaxError: invalid syntax

def naar_fahrenheit(c):
    """Temperatuur c in graden Celsius omzetten naar graden Fahrenheit."""
    f = 1.8 * c + 32
    return f

for c in [0, 20, 37, 100]:
    print(f"{c} °C = {round(naar_fahrenheit(c), 1)} °F")

0 °C = 32.0 °F
20 °C = 68.0 °F
37 °C = 98.6 °F
100 °C = 212.0 °F

# functie


# toepassing

def opp_trapezium(B, b, h):
    """Oppervlakte van een trapezium met grote basis B, kleine basis b en hoogte h."""
    return (B + b) * h / 2

A = opp_trapezium(8, 4, 5)
print(f"De oppervlakte van het trapezium is {A} cm².")

De oppervlakte van het trapezium is 30.0 cm².

import math

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

def opp_ring(R, r):
    """Oppervlakte van een cirkelring met buitenstraal R en binnenstraal r."""
    ...

print(round(opp_ring(5, 3), 2))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[43], line 11
      7 def opp_ring(R, r):
      8     """Oppervlakte van een cirkelring met buitenstraal R en binnenstraal r."""
      9     ...
     10 
---> 11 print(round(opp_ring(5, 3), 2))

TypeError: type NoneType doesn't define __round__ method

import math

def opp_cirkel(r):
    """Oppervlakte van een cirkel met straal r."""
    return math.pi * r ** 2

def opp_ring(R, r):
    """Oppervlakte van een cirkelring met buitenstraal R en binnenstraal r."""
    return opp_cirkel(R) - opp_cirkel(r)

print(round(opp_ring(5, 3), 2))

50.27

def f(x):
    """f(x) = -x² + 6x - 5"""
    ...

for x in ...:
    ...

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[45], line 5
      1 def f(x):
      2     """f(x) = -x² + 6x - 5"""
      3     ...
      4 
----> 5 for x in ...:
      6     ...

TypeError: 'ellipsis' object is not iterable

def f(x):
    """f(x) = -x² + 6x - 5"""
    return -x ** 2 + 6 * x - 5

for x in range(0, 7):
    if f(x) == 0:
        print(x, f(x), "nulpunt")
    else:
        print(x, f(x))

0 -5
1 0 nulpunt
2 3
3 4
4 3
5 0 nulpunt
6 -5

def percentage(behaald, maximum):
    """Percentage van behaald op maximum, afgerond op 1 decimaal."""
    return round(behaald / maximum * 100, 1)

behaald = float(input("Hoeveel punten behaalde je? "))
maximum = float(input("Op hoeveel punten stond de toets? "))
print(f"Je behaalde {percentage(behaald, maximum)} %.")

Hoeveel punten behaalde je? 14
Op hoeveel punten stond de toets? 20
Je behaalde 70.0 %.

def is_rechthoekig(a, b, c):
    """..."""
    ...

print(is_rechthoekig(3, 4, 5), is_rechthoekig(5, 6, 7), is_rechthoekig(5, 12, 13))

None None None

def is_rechthoekig(a, b, c):
    """True als de driehoek met zijden a, b en c (c de langste) rechthoekig is."""
    return a ** 2 + b ** 2 == c ** 2

print(is_rechthoekig(3, 4, 5), is_rechthoekig(5, 6, 7), is_rechthoekig(5, 12, 13))

True False True

if a ** 2 + b ** 2 == c ** 2:
    return True
else:
    return False

import math

class Cirkel:
    """Klasse Cirkel."""

    def __init__(self, ...):
        """Initialisatie: een cirkel heeft een straal."""
        ...

    def omtrek(self):
        """Omtrek van de cirkel."""
        ...

    def oppervlakte(self):
        """Oppervlakte van de cirkel."""
        ...

c1 = ...
print(round(c1.omtrek(), 2), round(c1.oppervlakte(), 2))

  Cell In[50], line 6
    def __init__(self, ...):
                       ^
SyntaxError: invalid syntax

import math

class Cirkel:
    """Klasse Cirkel."""

    def __init__(self, straal):
        """Initialisatie: een cirkel heeft een straal."""
        self.r = straal

    def omtrek(self):
        """Omtrek van de cirkel."""
        return 2 * math.pi * self.r

    def oppervlakte(self):
        """Oppervlakte van de cirkel."""
        return math.pi * self.r ** 2

c1 = Cirkel(2)
print(round(c1.omtrek(), 2), round(c1.oppervlakte(), 2))

12.57 12.57

oproep	`x`	type	`3 * x`	resultaat
`verdrievoudigen(4)`	4	int	3 · 4	`12`
`verdrievoudigen("ab")`	"ab"	str	tekst 3 keer herhalen	`ababab`
`verdrievoudigen(1.5)`	1.5	float	3 · 1,5	`4.5`

stap	wat gebeurt er?	uitvoer
1	`kwadraat(5)` wordt opgeroepen: `x = 5`	–
2	in de functie: `print(x ** 2)`	`25`
3	de functie heeft geen `return` → ze geeft `None` terug	–
4	`resultaat = None`	–
5	`print(resultaat)`	`None`

oproep	`a`	`b`	`a - b`
`verschil(y, x)`	`y` = 4	`x` = 10	4 − 10 = `-6`
`verschil(x, y)`	`x` = 10	`y` = 4	10 − 4 = `6`

stap	oproep	wat gebeurt er?	uitvoer	teruggegeven
1	`volgende(2)`	`return 3` → functie stopt	–	3
2	`volgende(3)`	`return 4` → functie stopt	–	4
3	`print(4)`		`4`

stap	oproep	wat gebeurt er?	uitvoer	teruggegeven
1	`volgende_bis(2)`	eerst `print("klaar")`, dan `return 3`	`klaar`	3
2	`volgende_bis(3)`	eerst `print("klaar")`, dan `return 4`	`klaar`	4
3	`print(4)`		`4`

Verbetersleutel – Oefeningen functies¶

Deel A: Voorspel de uitvoer¶

Oefening 1¶

Oefening 2¶

Oefening 3¶

Oefening 4¶

Oefening 5¶

Oefening 6¶

Oefening 7¶

Oefening 8¶

Oefening 9¶

Oefening 10¶

Oefening 11¶

Oefening 12¶

Oefening 13¶

Oefening 14¶

Oefening 15 (bonusvraag – uitbreiding)¶

Deel B: Zoek de fout!¶

Oefening 16¶

Oefening 17¶

Oefening 18¶

Oefening 19¶

Oefening 20¶

Oefening 21¶

Oefening 22¶

Oefening 23¶

Oefening 24¶

Oefening 25 (bonusvraag – uitbreiding)¶

Deel C: Vul de code aan¶

Oefening 26¶

Oefening 27¶

Oefening 28¶

Oefening 29¶

Oefening 30¶

Oefening 31¶

Oefening 32¶

Oefening 33 (bonusvraag – uitbreiding)¶

stap	`getal` (buiten)	`getal` (binnen de functie)	`nieuw`
`getal = 5`	5	–	–
oproep `verhoog(getal)`	5	5 (kopie van de waarde)	–
`getal = getal + 10` (binnen)	5	15	–
`return getal` → `nieuw = 15`	5	(bestaat niet meer)	15

oproep	berekening	resultaat
`schuine_zijde(3, 4)`	√(3² + 4²) = √(9 + 16) = √25	`5.0`
`schuine_zijde(5, 5)`	√(25 + 25) = √50 ≈ 7,07	7.0710678...
`int(7.0710678...)`	afkappen	`7`

uitdrukking	berekening	resultaat
`p * 2`	tekst 2 keer herhalen	`100100`
`float(p)`	`"100"` → `100.0`	100.0
`prijs_met_btw(100.0)`	100,0 · 1,21	`121.0`

doorloop	`g`	`procent(g, 20)` = `g * 20 / 100`	uitvoer
1	50	1000 / 100 = 10.0	`20 % van 50 is 10.0`
2	80	1600 / 100 = 16.0	`20 % van 80 is 16.0`
3	300	6000 / 100 = 60.0	`20 % van 300 is 60.0`

oproep	`punt >= 10`?	welke `return`?	teruggegeven
`beoordeling(12)`	True	de eerste → functie stopt	`"geslaagd"`
`beoordeling(9.5)`	False	de `if` wordt overgeslagen → de tweede	`"niet geslaagd"`

`x`	`x ** 2`	`- 4 * x`	`+ 3`	`f(x)`	uitvoer
0	0	0	3	3	`0 3`
1	1	−4	3	0	`1 0`
2	4	−8	3	−1	`2 -1`
3	9	−12	3	0	`3 0`
4	16	−16	3	3	`4 3`

uitdrukking	berekening	resultaat
`bewerking1(3, 4)`	(3 + 4)² = 7²	`49`
`bewerking2(3, 4)`	3² + 4² = 9 + 16	`25`
verschil	49 − 25	`24`

	`z`	`h`	`z ** 2 * h / 3`
origineel `(9, 6)`	9	6	81 · 6 / 3 = `162.0` ❌
verbeterd `(6, 9)`	6	9	36 · 9 / 3 = `108.0` ✔️

stap	berekening	resultaat
`omtrek_cirkel(5)`	2 · π · 5 = 10π	31.4159...
`round(..., 2)`	afronden op 2 decimalen	`31.42`

`c`	`1.8 * c + 32`	afgerond	uitvoer
0	0 + 32	32.0	`0 °C = 32.0 °F`
20	36 + 32	68.0	`20 °C = 68.0 °F`
37	66,6 + 32 = 98.60000000000001	98.6	`37 °C = 98.6 °F`
100	180 + 32	212.0	`100 °C = 212.0 °F`

object	`self.l`	`self.b`	`oppervlakte()`
`r1`	4	3	4 · 3 = 12
`r2`	2	5	2 · 5 = 10

doorloop	`g`	`totaal`
start	–	0
1	4	4
2	7	11
3	9	20
na de lus		`return 20`

stap	berekening	resultaat
`opp_cirkel(5)`	π · 25	78.539...
`opp_cirkel(3)`	π · 9	28.274...
verschil	25π − 9π = 16π	50.265...
`round(..., 2)`		`50.27`

`x`	`-x ** 2`	`+ 6 * x`	`- 5`	`f(x)`	nulpunt?
0	0	0	−5	−5
1	−1	6	−5	0	✔️
2	−4	12	−5	3
3	−9	18	−5	4
4	−16	24	−5	3
5	−25	30	−5	0	✔️
6	−36	36	−5	−5

stap	waarde
`behaald = float(input(...))`	15.0
`maximum = float(input(...))`	20.0
`behaald / maximum * 100`	15 / 20 · 100 = 75.0
`round(..., 1)`	75.0

oproep	a² + b²	c²	gelijk?
`(3, 4, 5)`	9 + 16 = 25	25	`True`
`(5, 6, 7)`	25 + 36 = 61	49	`False`
`(5, 12, 13)`	25 + 144 = 169	169	`True`

methode	formule	berekening	afgerond
`c1.omtrek()`	2πr	2 · π · 2 = 4π	`12.57`
`c1.oppervlakte()`	πr²	π · 2² = 4π	`12.57`