Uitwerkingen oefenmidterm¶
Hier staan de antwoorden bij de oefenmidterm, met per opdracht de reden waarom dat antwoord het goede is.
Onder elk antwoord staat het programma nog een keer. Op een na draaien die cellen mee wanneer deze pagina wordt gebouwd, dus de uitvoer die je eronder ziet is de echte uitvoer.
Belangrijk
Vier programma’s op deze midterm lopen met opzet fout af: opdracht 8 op een NameError, opdracht 14 op een IndentationError, opdracht 18 op een ZeroDivisionError, en opdracht 20 eindigt nooit. Bij alle vier is “Het programma werkt niet” het goede antwoord. Voorspellen wat code doet, is ook voorspellen wanneer ze stukloopt.
Opdracht 1¶
Toetst: rekenen met floating-point getallen.
Antwoord: d - 3.6999999999999997
score / max_points is een deling, en / geeft in Python altijd een float. Dat wordt 0.3, maar 0.3 is in binair niet precies op te schrijven, net zomin als een derde in decimalen. Bij * 9 wordt dat verschil zichtbaar: er komt 2.6999999999999997 uit in plaats van 2.7, en dus 3.6999999999999997 in plaats van 3.7.
De laatste regel, score = 50, verandert niets meer. grade is dan al berekend.
max_points = 100
score = 30
grade = score / max_points * 9 + 1
score = 50
grade # het programma zelf drukt niets af
3.6999999999999997
Opdracht 2¶
Toetst: if/elif/else, en het type dat / oplevert.
Antwoord: c - 1.0
x is 4, dus de eerste voorwaarde klopt en de rest wordt overgeslagen. 4 / 4 is 1.0 en niet 1: de operator / levert altijd een float, ook als er niets achter de komma staat.
x = 4
if x > 2:
x = x / 4
elif x < 2:
x = x + 3
else:
x = x * 3
x # het programma zelf drukt niets af
1.0
Opdracht 3¶
Toetst: twee losse if-statements achter elkaar.
Antwoord: b - 7
De eerste if maakt van 8 een 4. De tweede if staat daar los van en toetst opnieuw, met de nieuwe waarde: 4 <= 4 klopt, dus x wordt 7. De elif hoort bij die tweede if en komt daardoor niet meer aan de beurt.
x = 8
if x > 5:
x = x - 4
if x <= 4:
x = x + 3
elif x == 7 or x == 4:
x = x * 2
x # het programma zelf drukt niets af
7
Opdracht 4¶
Toetst: strings vergelijken met <.
Antwoord: b - groep 2
Strings vergelijk je op alfabetische volgorde. "Emily" < "E" klopt niet, want "Emily" begint met "E" en is langer. "Emily" < "M" klopt wel, want E komt voor M.
x = "Emily"
if x < "E":
print("groep 1")
elif x < "M":
print("groep 2")
elif x < "Z":
print("groep 3")
else:
print("groep 4")
groep 2
Opdracht 5¶
Toetst: indexeren met een negatieve index.
Antwoord: c - l
Index -1 is het laatste teken van de string.
woord = "Hanzehogeschool"
print(woord[-1])
l
Opdracht 6¶
Toetst: een slice.
Antwoord: c - zeh
[3:6] telt vanaf 0 en loopt tot maar niet tot en met index 6, dus de tekens op index 3, 4 en 5.
woord = "Hanzehogeschool"
print(woord[3:6])
zeh
Opdracht 7¶
Toetst: een slice met een negatieve stapgrootte.
Antwoord: a - loceoen
[-1:1:-2] begint bij het laatste teken, loopt achteruit tot maar niet tot en met index 1, en slaat telkens een teken over.
woord = "Hanzehogeschool"
print(woord[-1:1:-2])
loceoen
Opdracht 8¶
Toetst: de volgorde waarin Python een bestand leest.
Antwoord: d - Het programma werkt niet
De aanroep staat boven de definitie. Python leest een bestand van boven naar beneden, dus op het moment van de aanroep bestaat de naam function nog niet en volgt een NameError.
Ook hier is de foutmelding het antwoord.
print(function(5, 10))
def function(x, y):
if x <= y:
return x
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Cell In[8], line 1
----> 1 print(function(5, 10))
2
3
4 def function(x, y):
NameError: name 'function' is not defined
Opdracht 9¶
Toetst: return in een if.
Antwoord: b - 10
5 > 10 klopt niet, dus de eerste return wordt overgeslagen. De regel eronder geeft y terug, en dat is 10.
def function(x, y):
if x > y:
return x
return y
print(function(5, 10))
10
Opdracht 10¶
Toetst: wat een functie teruggeeft zonder return.
Antwoord: c - None
10 < 5 klopt niet, dus de functie loopt af zonder een return tegen te komen. Een functie die niets teruggeeft, geeft None terug, en dat is wat print afdrukt.
def main():
temp = function(10, 5)
print(temp)
def function(x, y):
if x < y:
return x
main()
None
Opdracht 11¶
Toetst: een functie die een andere functie aanroept.
Antwoord: c - 25
10 < 5 klopt niet, dus function1 slaat de eerste return over en doet return function2(y) met y is 5. function2 geeft 5 * 5.
def main():
temp = function1(10, 5)
print(temp)
def function1(x, y):
if x < y:
return function2(x)
return function2(y)
def function2(x):
return x * x
main()
25
Opdracht 12¶
Toetst: onbereikbare code na een return.
Antwoord: a - 5
5 % 2 == 0 klopt niet, dus x blijft 5. Daarna staat er meteen return x. Alles wat daaronder staat wordt nooit uitgevoerd.
def main():
temp = function1(5, 12)
print(temp)
def function1(x, y):
if x % 2 == 0:
x = x / 2
return x
if x < y:
return x
return y
main()
5
Opdracht 13¶
Toetst: tellen hoe vaak een lus rondgaat.
Antwoord: d - vijf keer
y begint op 4 en gaat elke ronde met 1 omlaag. De voorwaarde y >= 0 klopt bij 4, 3, 2, 1 en 0, en pas bij -1 niet meer. Dat zijn vijf rondes.
def function(y):
while y >= 0:
print("hoi")
y = y - 1
function(4)
hoi
hoi
hoi
hoi
hoi
Opdracht 14¶
Toetst: inspringing als onderdeel van de syntax.
Antwoord: e - Het programma werkt niet
De regel onder while x < 100: springt niet in, terwijl de body van een lus dat moet. Python komt niet eens aan uitvoeren toe en struikelt al bij het lezen, met een IndentationError. Er komt dus helemaal niets uit.
Let op de valkuil. Zet je die ene inspringing er wel, dan drukt het programma 128 af, en dat is optie d. Maar dat is een ander programma dan hier staat. De vraag gaat over deze code.
x = 8
while x < 100:
x = x * 2
print(x)
Cell In[14], line 3
x = x * 2
^
IndentationError: expected an indented block after 'while' statement on line 2
Opdracht 15¶
Toetst: een while-lus met twee variabelen naast elkaar.
Antwoord: c - 120
x en n veranderen samen: x wordt 10 (n is 2), dan 30 (n is 3), dan 120 (n is 4). Bij 120 klopt x < 100 niet meer en stopt de lus.
x = 5
n = 2
while x < 100:
x = x * n
n += 1
print(x)
120
Opdracht 16¶
Toetst: een for-lus waarin de lusvariabele meerekent.
Antwoord: c - 75
Elke ronde gaat n van x af, en daarna verandert n zelf, met i erin. Er gaat achtereenvolgens 1, 1, 2, 5 en 16 van x af. Samen is dat 25, en 100 - 25 is 75.
x = 100
n = 1
for i in range(0, 5):
x = x - n
n = n * i + 1
print(x)
75
Opdracht 17¶
Toetst: een while-lus, en waar een float vandaan komt.
Antwoord: c - 7.0
x wordt gehalveerd zolang hij even is en met 1 verhoogd als hij oneven is: 100, 50, 25, 26, 13, 14, 7. Bij 7 klopt x > 10 niet meer.
Er komt 7.0 uit en niet 7. De allereerste stap, 100 / 2, maakte er al een float van, en dat blijft zo bij alles wat erna komt.
x = 100
while x > 10:
if x % 2 == 0:
x = x / 2
else:
x = x + 1
print(x)
7.0
Opdracht 18¶
Toetst: een range die bij 0 begint.
Antwoord: e - Het programma werkt niet
range(0, 48) begint bij 0, dus de eerste ronde rekent 48 % 0 uit. Delen door nul kan niet en dat levert een ZeroDivisionError.
Ook hier is de foutmelding het goede antwoord, en niet een fout in de opdracht.
lis = []
number = 48
for x in range(0, 48):
if 48 % x == 0:
lis = lis + [x]
print(lis)
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
Cell In[18], line 4
1 lis = []
2 number = 48
3 for x in range(0, 48):
----> 4 if 48 % x == 0:
5 lis = lis + [x]
6 print(lis)
ZeroDivisionError: integer modulo by zero
Opdracht 19¶
Toetst: een lus die een nieuwe lijst opbouwt.
Antwoord: a - [2, 2, 6, 4, 10, 6]
Oneven getallen worden verdubbeld, even getallen blijven zoals ze zijn: 1 wordt 2, 2 blijft 2, 3 wordt 6, 4 blijft 4, 5 wordt 10, 6 blijft 6.
my_list = [1, 2, 3, 4, 5, 6]
result = []
for ix in range(0, 6):
if not my_list[ix] % 2 == 0:
result = result + [my_list[ix] * 2]
else:
result = result + [my_list[ix]]
print(result)
[2, 2, 6, 4, 10, 6]
Opdracht 20¶
Toetst: de vraag wanneer een while-lus klaar is.
Antwoord: e - Het programma werkt niet
Deze lus eindigt nooit. x doorloopt 1, 4, 2.0, 1.0, 4.0, 2.0, 1.0 en komt daarmee nooit op of boven de 5. lis blijft groeien en print wordt nooit bereikt.
Hier heeft vraag 4 van het lusrecept geen antwoord: wanneer is het klaar? Bij een while moet de schrijver zorgen dat de voorwaarde ooit niet meer klopt, en dat gebeurt hier niet.
Deze code staat daarom niet als codecel op de pagina: er valt niets uit te voeren dat afloopt.
lis = []
x = 1
while x < 5:
if not x % 2 == 0:
lis = lis + [2 * x]
x = x * 3 + 1
else:
lis = lis + [x]
x = x / 2
print(lis)