Verbetersleutel – Toets Python (derde kans): datatypes, opsommingen en operatoren, structuren (herhaling en keuze)¶
Vak: informatica-wetenschappen · Leerkracht: I. De Schrijver
| Deel | 1 | 2 | 3 | Bonus | Totaal |
|---|---|---|---|---|---|
| Maximum | 12 | 15 | 13 | +3 | 40 |
Bij elke vraag vind je de code, de juiste uitvoer en een uitleg stap voor stap. Bij deel 3 en de bonusvraag staat telkens een overzicht van de waarden van de variabelen per doorloop.
- Bij een foutmelding volstaat het antwoord fout: welk soort fout hoeft niet vermeld te worden.
- Wat de gebruiker typt, hoort niet bij de uitvoer.
- Je mag de codecellen uitvoeren om het antwoord te controleren. Bij vragen met
input()typ je dan zelf de opgegeven invoer.
Deel 1: Datatypes (12 pt)¶
Vraag 1 (2 pt)¶
Wat is de uitvoer?
In [1]:
x = 7.0
y = 2
print(x // y, x % y)
print(type(x // y), int(x) / y)
3.0 1.0 <class 'float'> 3.5
Uitvoer:
3.0 1.0
<class 'float'> 3.5
Uitleg:
x = 7.0is een float (er staat een punt),y = 2is een int.- Zodra er een float meedoet in een bewerking, is het resultaat ook een float, ook bij
//en%.
| uitdrukking | berekening | resultaat | type |
|---|---|---|---|
x // y |
gehele deling: 2 past 3 keer in 7 | 3.0 |
float |
x % y |
rest: 7 = 3 · 2 + 1 | 1.0 |
float |
type(x // y) |
het type van 3.0 |
<class 'float'> |
– |
int(x) |
7.0 → 7 |
7 |
int |
int(x) / y |
7 / 2 (gewone deling) | 3.5 |
float |
- ⚠️ Valkuil:
x // ygeeft niet3maar3.0, omdatxeen float is. /geeft altijd een float, ook met twee integers.
Vraag 2 (3 pt)¶
Wat is de uitvoer?
In [2]:
getal = "12"
a = getal * 2
b = int(getal) * 2
print(a, b)
print(a + str(b), int(a) - b)
print(len(str(b) * 4))
1212 24 121224 1188 8
Uitvoer:
1212 24
121224 1188
8
Uitleg:
| regel | wat gebeurt er? | resultaat | type |
|---|---|---|---|
getal = "12" |
tekst (tussen aanhalingstekens!) | "12" |
str |
a = getal * 2 |
tekst × 2 = tekst herhalen | "1212" |
str |
b = int(getal) * 2 |
eerst omzetten naar getal, dan 12 · 2 | 24 |
int |
print(a, b)→1212 24a + str(b)="1212"+"24"→ tekst plakken →121224int(a) - b= 1212 − 24 =1188str(b) * 4="24"4 keer herhalen →"24242424"→len(...)telt de tekens: 8
Vraag 3 (1 pt)¶
Wat is de uitvoer?
In [3]:
print(str(int(4.7)) + str(float(3)))
43.0
Uitvoer:
43.0
Uitleg: werk van binnen naar buiten.
| stap | resultaat |
|---|---|
int(4.7) |
4 (afkappen, niet afronden!) |
str(4) |
"4" |
float(3) |
3.0 |
str(3.0) |
"3.0" |
"4" + "3.0" |
tekst plakken → "43.0" |
- Omdat beide kanten tekst zijn, wordt er niet opgeteld (dus niet
7.0) maar aan elkaar geplakt.
Vraag 4 (1 pt)¶
Wat is de uitvoer?
In [4]:
print(int("3.5") + 1)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[5], line 1 ----> 1 print(int("3.5") + 1) ValueError: invalid literal for int() with base 10: '3.5'
Uitvoer:
fout
Uitleg:
int()kan een tekst enkel omzetten als die tekst een geheel getal voorstelt, zoals"3"of"-12"."3.5"bevat een punt →int("3.5")geeft een fout.- Opgelet, het verschil:
int(3.5)(een float) →3✔️ (afkappen)int("3.5")(een tekst) → fout ❌int(float("3.5"))→ eerst3.5, dan3✔️
Vraag 5 (2 pt)¶
Wat is de uitvoer? De gebruiker typt: "4", dan "2.5".
In [5]:
a = input("Breedte? ")
b = input("Hoogte? ")
print(a * 2, float(b) * 2)
print(f"Oppervlakte: {int(a) * float(b)}")
Breedte? 4 Hoogte? 2.5 44 5.0 Oppervlakte: 10.0
Uitvoer:
44 5.0
Oppervlakte: 10.0
Uitleg:
input()geeft altijd tekst terug:a = "4"enb = "2.5".
| uitdrukking | berekening | resultaat |
|---|---|---|
a * 2 |
tekst 2 keer herhalen | 44 |
float(b) * 2 |
2.5 · 2 | 5.0 |
int(a) * float(b) |
4 · 2.5 (int × float = float) | 10.0 |
- ⚠️
a * 2is niet 8:ais nog altijd tekst. - 4 · 2.5 = 10, maar omdat er een float meedoet, toont Python
10.0.
Vraag 6 (1 pt)¶
Wat is de uitvoer?
In [6]:
x = 10
y = "10"
print(str(x) + y == "1010", x == float(y), type(x) == type(y))
True True False
Uitvoer:
True True False
Uitleg:
| vergelijking | wordt | resultaat |
|---|---|---|
str(x) + y == "1010" |
eerst + (rekenen gaat voor vergelijken): "10" + "10" = "1010" → "1010" == "1010" |
True |
x == float(y) |
10 == 10.0 |
True |
type(x) == type(y) |
int tegenover str |
False |
- Een int en een float met dezelfde waarde zijn gelijk:
10 == 10.0isTrue. - Een getal en een tekst zijn nooit gelijk, en hun types ook niet.
Vraag 7 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze. De gebruiker typt: "8".
In [7]:
prijs = input("Prijs? ")
print(f"Dubbele prijs: {prijs * 2} euro")
Prijs? 8 Dubbele prijs: 88 euro
Gewenste uitvoer: Dubbele prijs: 16 euro
Uitvoer van de originele code:
Dubbele prijs: 88 euro
Verbeterde code:
In [8]:
prijs = int(input("Prijs? "))
print(f"Dubbele prijs: {prijs * 2} euro")
Prijs? 8 Dubbele prijs: 16 euro
Uitleg:
input()geeft tekst:prijs = "8". Dan isprijs * 2="88"(tekst herhalen), niet 16.- Er komt dus geen foutmelding, maar wel een fout resultaat:
Dubbele prijs: 88 euro.
Er zijn twee goede oplossingen (allebei volledig juist):
1. Meteen bij de invoer omzetten
prijs = int(input("Prijs? "))
2. Omzetten in de berekening
print(f"Dubbele prijs: {int(prijs) * 2} euro")
- Met
float(...)in plaats vanint(...)krijg je16.0→ niet exact de gewenste uitvoer.
Deel 2: Opsommingen en operatoren (15 pt)¶
Vraag 8 (2 pt)¶
Wat is de uitvoer?
In [9]:
dieren = ["kat", "hond", "vis", "muis"]
dieren.remove("vis")
dieren.append("uil")
dieren[0] = dieren[-1]
print(dieren)
print(dieren[1:3], len(dieren), "kat" in dieren)
['uil', 'hond', 'muis', 'uil'] ['hond', 'muis'] 4 False
Uitvoer:
['uil', 'hond', 'muis', 'uil']
['hond', 'muis'] 4 False
Uitleg:
Hoe de lijst verandert:
| regel | dieren |
|---|---|
| start | ["kat", "hond", "vis", "muis"] |
dieren.remove("vis") |
["kat", "hond", "muis"] (het element "vis" verdwijnt, de rest schuift op) |
dieren.append("uil") |
["kat", "hond", "muis", "uil"] (achteraan toegevoegd) |
dieren[0] = dieren[-1] |
dieren[-1] is "uil" → plaats 0 wordt "uil": ["uil", "hond", "muis", "uil"] |
Indices op het einde:
| index | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| element | uil | hond | muis | uil |
dieren[1:3]= index 1 en 2 (3 niet!) →['hond', 'muis']len(dieren)→4"kat" in dieren→False:"kat"werd overschreven door"uil".- Python toont tekst in een lijst met enkele aanhalingstekens.
Vraag 9 (2 pt)¶
Wat is de uitvoer?
In [10]:
cijfers = [5, 2, 8, 1]
cijfers.insert(2, cijfers[1] * 3)
cijfers.sort()
print(cijfers[:3], cijfers[-1] - cijfers[0])
[1, 2, 5] 7
Uitvoer:
[1, 2, 5] 7
Uitleg:
| regel | cijfers |
|---|---|
| start | [5, 2, 8, 1] |
cijfers.insert(2, cijfers[1] * 3) |
cijfers[1] = 2 → 2 · 3 = 6 wordt ingevoegd op plaats 2: [5, 2, 6, 8, 1] |
cijfers.sort() |
[1, 2, 5, 6, 8] |
cijfers[:3]= de eerste drie (index 0, 1, 2) →[1, 2, 5]cijfers[-1] - cijfers[0]= 8 − 1 =7- Let op bij
insert(plaats, waarde): eerst de plaats, dan de waarde.
Vraag 10 (2 pt)¶
Wat is de uitvoer?
In [11]:
a = 20 - 3 * 4 // 5 + 2 ** 3
b = (20 - 3) * 4 // (5 + 2) ** 2
c = 7 % 3 * 2 + 10 // 4
print(a, b, c)
26 1 4
Uitvoer:
26 1 4
Uitleg:
Volgorde van bewerkingen: haakjes → ** → *, /, //, % → +, - (bij gelijke voorrang van links naar rechts).
| variabele | berekening stap voor stap | resultaat |
|---|---|---|
a = 20 - 3 * 4 // 5 + 2 ** 3 |
2 ** 3 = 8 → 3 * 4 = 12 → 12 // 5 = 2 → 20 − 2 + 8 |
26 |
b = (20 - 3) * 4 // (5 + 2) ** 2 |
haakjes: 17 en 7 → 7 ** 2 = 49 → 17 * 4 = 68 → 68 // 49 = 1 |
1 |
c = 7 % 3 * 2 + 10 // 4 |
7 % 3 = 1 → 1 * 2 = 2 → 10 // 4 = 2 → 2 + 2 |
4 |
*,//en%hebben dezelfde voorrang: dan reken je gewoon van links naar rechts (3 * 4eerst, daarna// 5).**gaat vóór//: inbwordt eerst(5 + 2) ** 2= 49 berekend, pas dan68 // 49.
Vraag 11 (3 pt)¶
Wat is de uitvoer?
In [12]:
zon = False
uur = 14
print(zon or uur >= 12 and uur < 18)
print(not (zon or uur % 7 == 0))
print(not zon and uur > 15 or uur == 14)
True False True
Uitvoer:
True
False
True
Uitleg:
zon = False, uur = 14
Volgorde bij logische operatoren: vergelijkingen → not → and → or.
| regel | stap 1 (vergelijkingen) | stap 2 | resultaat |
|---|---|---|---|
zon or uur >= 12 and uur < 18 |
14 >= 12 = True; 14 < 18 = True |
and eerst: True and True = True → False or True |
True |
not (zon or uur % 7 == 0) |
14 % 7 = 0 → 0 == 0 = True |
haakjes: False or True = True → not True |
False |
not zon and uur > 15 or uur == 14 |
not False = True; 14 > 15 = False; 14 == 14 = True |
and eerst: True and False = False → False or True |
True |
andgaat vóóror(net zoals*vóór+).oris True zodra één kant True is;andis pas True als beide kanten True zijn.
Vraag 12 (2 pt)¶
Wat is de uitvoer?
In [13]:
woord = "Informatica"
print(woord.upper().count("I") + woord.count("a"))
print(woord[2:6] + woord[-3:].upper())
4 formICA
Uitvoer:
4
formICA
Uitleg:
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| teken | I | n | f | o | r | m | a | t | i | c | a |
| negatief | −11 | −10 | −9 | −8 | −7 | −6 | −5 | −4 | −3 | −2 | −1 |
Eerste regel
| stap | resultaat |
|---|---|
woord.upper() |
"INFORMATICA" |
.count("I") |
2 (de hoofdletter vooraan én de i die nu ook een I is) |
woord.count("a") |
2 (in het originele woord: index 6 en 10) |
| 2 + 2 | 4 |
woordzelf verandert niet door.upper(): dat maakt een nieuwe tekst.countgeeft een getal → getal + getal = optellen.
Tweede regel
woord[2:6]→ index 2 tot en met 5 →"form"woord[-3:]→ de laatste 3 tekens:"ica"→.upper()→"ICA"- Samen:
formICA
Vraag 13 (2 pt)¶
Wat is de uitvoer? De gebruiker typt: "Hallo wereld".
In [14]:
zin = input("Zin? ")
print(f"{zin[0]}{zin[-1]} - {zin.lower().count('l')} keer l")
print(zin[6:] + zin[:5] * 2)
Zin? Hallo wereld Hd - 3 keer l wereldHalloHallo
Uitvoer:
Hd - 3 keer l
wereldHalloHallo
Uitleg:
zin = "Hallo wereld" (de tekst die de gebruiker typt, staat zelf niet in de uitvoer)
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| teken | H | a | l | l | o | ␣ | w | e | r | e | l | d |
Eerste regel
zin[0]="H",zin[-1]="d"→ in de f-string staan ze vlak naast elkaar:Hdzin.lower().count('l')→lop index 2, 3 en 10 →3- Resultaat:
Hd - 3 keer l
Tweede regel
zin[6:]→ vanaf index 6 →"wereld"zin[:5]→ index 0 t.e.m. 4 →"Hallo"→* 2→"HalloHallo"(*gaat voor+)- Samen, zonder spaties:
wereldHalloHallo
Vraag 14 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [15]:
namen = ["An", "Bert", "Cleo"]
namen.insert(1, "Dirk")
print(f"Tweede: {namen[2]}, aantal: {len(namen)}")
Tweede: Bert, aantal: 4
Gewenste uitvoer: Tweede: Dirk, aantal: 4
Uitvoer van de originele code:
Tweede: Bert, aantal: 4
Verbeterde code:
In [16]:
namen = ["An", "Bert", "Cleo"]
namen.insert(1, "Dirk")
print(f"Tweede: {namen[1]}, aantal: {len(namen)}")
Tweede: Dirk, aantal: 4
Uitleg:
| regel | namen |
|---|---|
| start | ["An", "Bert", "Cleo"] |
namen.insert(1, "Dirk") |
["An", "Dirk", "Bert", "Cleo"] |
| index | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| element | An | Dirk | Bert | Cleo |
- De tweede naam staat op index 1 (Python telt vanaf 0).
namen[2]geeftBert. - Oplossing:
namen[2]vervangen doornamen[1]. - Na de verbetering:
namen[1]=Dirkenlen(namen)= 4 →Tweede: Dirk, aantal: 4. - Opgelet: wie
insert(1, ...)verandert ininsert(2, ...), krijgt ookTweede: Dirk, maar dan staat Dirk eigenlijk op de derde plaats. De fout zit in de index bij het afdrukken.
Deel 3: Structuren (13 pt)¶
Vraag 15 (1 pt)¶
Wat is de uitvoer?
In [17]:
n = 100
while n > 10:
n = n // 3
print(n)
3
Uitvoer:
3
Uitleg:
Een while-lus controleert de voorwaarde vóór elke doorloop. Zolang ze True is, wordt het ingesprongen blok uitgevoerd.
| doorloop | n bij de controle |
n > 10? |
berekening | nieuwe n |
|---|---|---|---|---|
| 1 | 100 | True | 100 // 3 | 33 |
| 2 | 33 | True | 33 // 3 | 11 |
| 3 | 11 | True | 11 // 3 | 3 |
| – | 3 | False → stop | – | – |
- ⚠️ Valkuil: bij
n = 11is11 > 10nog True, dus er volgt nog een doorloop. Wie stopt bij 11, heeft het fout. print(n)staat niet ingesprongen → wordt pas na de lus één keer uitgevoerd:3.
Vraag 16 (2 pt)¶
Wat is de uitvoer?
In [18]:
zin = "banaan"
punten = 0
for letter in zin:
if letter == "a":
punten += 2
elif letter == "n":
punten -= 1
else:
punten += 5
print(punten)
9
Uitvoer:
9
Uitleg:
De for-lus overloopt de tekst letter per letter. Per letter wordt precies één van de drie takken uitgevoerd.
| doorloop | letter |
welke tak? | actie | punten na deze doorloop |
|---|---|---|---|---|
| start | – | – | – | 0 |
| 1 | b | else |
+5 | 5 |
| 2 | a | if |
+2 | 7 |
| 3 | n | elif |
−1 | 6 |
| 4 | a | if |
+2 | 8 |
| 5 | a | if |
+2 | 10 |
| 6 | n | elif |
−1 | 9 |
- Controle: 1 ×
b(+5), 3 ×a(+6), 2 ×n(−2) → 5 + 6 − 2 = 9 print(punten)staat na de lus → er wordt maar één getal getoond.
Vraag 17 (4 pt)¶
Wat is de uitvoer?
In [19]:
waarden = [6, 7, 2, 9, 11]
lijst = []
for w in waarden:
if w % 3 == 0:
lijst.append(w // 3)
print("deelbaar:", w)
elif w > 4:
lijst.append(w + 1)
else:
print(f"te klein: {w}")
print(lijst, len(lijst))
deelbaar: 6 te klein: 2 deelbaar: 9 [2, 8, 3, 12] 4
Uitvoer:
deelbaar: 6
te klein: 2
deelbaar: 9
[2, 8, 3, 12] 4
Uitleg:
Let goed op de inspringing:
print("deelbaar:", w)staat in deif→ enkel bij getallen deelbaar door 3.- In de
elifwordt er niets getoond, enkel iets toegevoegd. print(lijst, len(lijst))staat na de lus → één keer, helemaal op het einde.
| doorloop | w |
w % 3 |
w % 3 == 0? |
w > 4? |
welke tak? | toegevoegd | lijst na deze doorloop |
uitvoer |
|---|---|---|---|---|---|---|---|---|
| start | – | – | – | – | – | – | [] |
– |
| 1 | 6 | 0 | True | (niet gecontroleerd) | if |
6 // 3 = 2 | [2] |
deelbaar: 6 |
| 2 | 7 | 1 | False | True | elif |
7 + 1 = 8 | [2, 8] |
– |
| 3 | 2 | 2 | False | False | else |
– | [2, 8] |
te klein: 2 |
| 4 | 9 | 0 | True | (niet gecontroleerd) | if |
9 // 3 = 3 | [2, 8, 3] |
deelbaar: 9 |
| 5 | 11 | 2 | False | True | elif |
11 + 1 = 12 | [2, 8, 3, 12] |
– |
- Na de lus:
print(lijst, len(lijst))→[2, 8, 3, 12] 4 print("deelbaar:", w)gebruikt een komma → Python zet zelf een spatie na de dubbele punt:deelbaar: 6.- Bij 6 en 9 is ook
w > 4waar, maar dat wordt niet meer gecontroleerd: deifwas al True.
Vraag 18 (2 pt)¶
Wat is de uitvoer? Geef de uitvoer voor elk van deze invoeren: "15" en "12".
In [20]:
punt = int(input("Punt? "))
if punt >= 10:
print("Geslaagd")
if punt >= 14:
print("Onderscheiding")
elif punt >= 8:
print("Bijna")
else:
print("Niet geslaagd")
Punt? 15 Geslaagd Onderscheiding
Uitvoer bij invoer "15":
Geslaagd
Onderscheiding
Uitvoer bij invoer "12":
Geslaagd
Bijna
Uitleg:
⚠️ De valkuil: er staan twee aparte keuzestructuren na elkaar.
- Een losse
if punt >= 10(zonder elif/else). - Een nieuwe
if punt >= 14 / elif punt >= 8 / else.
De tweede if is geen elif van de eerste! Python controleert ze dus allebei, los van elkaar. Er kunnen dus twee regels uitvoer verschijnen.
| controle | punt = 15 |
punt = 12 |
|---|---|---|
structuur 1: punt >= 10 |
True → Geslaagd |
True → Geslaagd |
structuur 2: punt >= 14 |
True → Onderscheiding, rest van structuur 2 overslaan |
False |
elif punt >= 8 |
(niet meer gecontroleerd) | True → Bijna, stop |
else |
– | – |
- Bij 12 is
Bijnaeigenlijk een vreemde boodschap naGeslaagd: het programma zit logisch slecht in elkaar, maar we voorspellen wat Python doet, niet wat de bedoeling was. - Wie bij een invoer maar één regel schrijft, heeft de tweede
ifals eenelifgelezen.
Vraag 19 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [21]:
for i in range(1, 5):
print(i * 2, end=" ")
print("klaar")
2 4 6 8 klaar
Gewenste uitvoer: 2 4 6 8 10 klaar
Uitvoer van de originele code:
2 4 6 8 klaar
Verbeterde code:
In [22]:
for i in range(1, 6):
print(i * 2, end=" ")
print("klaar")
2 4 6 8 10 klaar
Uitleg:
range(1, 5)geeft de getallen 1, 2, 3, 4: de eindwaarde 5 doet niet mee.- Daardoor ontbreekt
10in de uitvoer. - Oplossing:
range(1, 6).
Verloop na de verbetering:
| doorloop | i |
i * 2 |
getoond (met end=" ") |
|---|---|---|---|
| 1 | 1 | 2 | 2 |
| 2 | 2 | 4 | 4 |
| 3 | 3 | 6 | 6 |
| 4 | 4 | 8 | 8 |
| 5 | 5 | 10 | 10 |
- Door
end=" "komt alles op één regel, met een spatie in plaats van een nieuwe regel. Daarna volgtklaarop dezelfde regel:2 4 6 8 10 klaar. - Ook correct:
for i in range(2, 11, 2):metprint(i, end=" "), maar dan verander je twee regels; de bedoelde verbetering isrange(1, 6).
Vraag 20 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [23]:
woorden = ["appel", "ei", "banaan", "kiwi"]
for w in woorden:
lang = 0
if len(w) > 3:
lang += 1
print(f"Lange woorden: {lang}")
Lange woorden: 1
Gewenste uitvoer: Lange woorden: 3
Uitvoer van de originele code:
Lange woorden: 1
Verbeterde code:
In [24]:
woorden = ["appel", "ei", "banaan", "kiwi"]
lang = 0
for w in woorden:
if len(w) > 3:
lang += 1
print(f"Lange woorden: {lang}")
Lange woorden: 3
Uitleg:
lang = 0staat in de lus: bij elk woord wordt de teller opnieuw op 0 gezet. Daardoor onthoudtlangenkel of het laatste woord lang is.- Er komt geen foutmelding, maar een fout resultaat:
Lange woorden: 1.
Verloop van de originele code:
| doorloop | w |
lang = 0 |
len(w) |
len(w) > 3? |
lang na deze doorloop |
|---|---|---|---|---|---|
| 1 | appel | 0 | 5 | True | 1 |
| 2 | ei | 0 (gewist!) | 2 | False | 0 |
| 3 | banaan | 0 (gewist!) | 6 | True | 1 |
| 4 | kiwi | 0 (gewist!) | 4 | True | 1 |
- Oplossing:
lang = 0vóór de lus zetten (niet ingesprongen). Een teller begin je altijd één keer, vóór de herhaling.
Verloop na de verbetering:
| doorloop | w |
len(w) |
len(w) > 3? |
lang na deze doorloop |
|---|---|---|---|---|
| start | – | – | – | 0 |
| 1 | appel | 5 | True | 1 |
| 2 | ei | 2 | False | 1 |
| 3 | banaan | 6 | True | 2 |
| 4 | kiwi | 4 | True | 3 |
→ Lange woorden: 3
Bonusvraag (geneste herhaling) (+3 pt bonus)¶
Vraag 21 (+3 pt bonus)¶
Wat is de uitvoer?
In [25]:
for i in range(1, 4):
lijn = ""
for j in range(1, 5):
if j <= i:
lijn += str(j * i)
else:
lijn += "."
print(lijn)
1... 24.. 369.
Uitvoer:
1...
24..
369.
Uitleg:
- De buitenste lus loopt over
i= 1, 2, 3 (4 niet). - Per
ibegintlijnopnieuw leeg en loopt de binnenste lus overj= 1, 2, 3, 4. - Is
j <= i, dan wordt het productj * ials tekst toegevoegd; anders een punt. print(lijn)staat in de buitenste lus (niet in de binnenste) → één regel peri.
i = 1
j |
j <= 1? |
toegevoegd | lijn |
|---|---|---|---|
| 1 | True | str(1 * 1) = "1" |
1 |
| 2 | False | "." |
1. |
| 3 | False | "." |
1.. |
| 4 | False | "." |
1... |
i = 2
j |
j <= 2? |
toegevoegd | lijn |
|---|---|---|---|
| 1 | True | str(1 * 2) = "2" |
2 |
| 2 | True | str(2 * 2) = "4" |
24 |
| 3 | False | "." |
24. |
| 4 | False | "." |
24.. |
i = 3
j |
j <= 3? |
toegevoegd | lijn |
|---|---|---|---|
| 1 | True | str(1 * 3) = "3" |
3 |
| 2 | True | str(2 * 3) = "6" |
36 |
| 3 | True | str(3 * 3) = "9" |
369 |
| 4 | False | "." |
369. |
- Omdat
lijntekst is, worden de cijfers aan elkaar geplakt ("2" + "4"="24"), niet opgeteld. - Elke regel heeft precies 4 tekens, want de binnenste lus draait altijd 4 keer.