Verbetersleutel – Toets Python (tweede 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 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. De oorspronkelijke code van vraag 19 niet uitvoeren: die lus stopt nooit!
Deel 1: Datatypes (12 pt)¶
Vraag 1 (2 pt)¶
Wat is de uitvoer?
In [1]:
a = 17
b = 5
print(a % b, a / b)
print(type(a // b))
2 3.4 <class 'int'>
Uitvoer:
2 3.4
<class 'int'>
Uitleg:
a % bis de rest bij deling: 17 = 3 · 5 + 2, dus17 % 5geeft2.a / bis de gewone deling. Die geeft altijd een float:17 / 5=3.4.printmet een komma zet een spatie tussen de waarden:2 3.4.a // bis de gehele deling:17 // 5=3. Twee integers geven met//een int, dustype(3)toont<class 'int'>.
Vraag 2 (3 pt)¶
Wat is de uitvoer?
In [2]:
code = "3"
x = code + "4"
y = int(code) + 4
print(x, y)
print(x * 2, str(y) * 2)
print(len(x * 3))
34 7 3434 77 6
Uitvoer:
34 7
3434 77
6
Uitleg:
| regel | wat gebeurt er? | resultaat | type |
|---|---|---|---|
code = "3" |
tekst (tussen aanhalingstekens!) | "3" |
str |
x = code + "4" |
tekst + tekst = aan elkaar plakken | "34" |
str |
y = int(code) + 4 |
eerst omzetten naar getal, dan optellen: 3 + 4 | 7 |
int |
print(x, y)→34 7x * 2= tekst 2 keer herhalen →"3434";str(y) * 2="7"2 keer herhalen →"77". Samen:3434 77x * 3="343434"enlen(...)telt de tekens: 6
Vraag 3 (1 pt)¶
Wat is de uitvoer?
In [3]:
print(float("2") + int(3.99))
5.0
Uitvoer:
5.0
Uitleg:
float("2")zet de tekst om naar het kommagetal2.0.int(3.99)kapt af (rondt niet af!) →3.2.0 + 3: float + int geeft een float →5.0.
Vraag 4 (1 pt)¶
Wat is de uitvoer?
In [4]:
print("5" + 5)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[5], line 1 ----> 1 print("5" + 5) TypeError: can only concatenate str (not "int") to str
Uitvoer:
fout
Uitleg:
"5"is tekst (str),5is een getal (int).- Tekst en een getal kun je niet met
+samenvoegen: Python weet niet of je wil plakken of optellen → fout. - (Wel mogelijk:
"5" + str(5)→55ofint("5") + 5→10.)
Vraag 5 (2 pt)¶
Wat is de uitvoer? De gebruiker typt: "12", dan "3".
In [5]:
a = input("Getal 1? ")
b = input("Getal 2? ")
print(a + b, int(a) + int(b))
print(f"{a}/{b} = {int(a) / int(b)}")
Getal 1? 12 Getal 2? 3 123 15 12/3 = 4.0
Uitvoer:
123 15
12/3 = 4.0
Uitleg:
input()geeft altijd tekst terug, ook als de gebruiker een getal typt:a = "12"enb = "3".
| uitdrukking | berekening | resultaat |
|---|---|---|
a + b |
tekst + tekst = plakken | 123 |
int(a) + int(b) |
12 + 3 | 15 |
int(a) / int(b) |
12 / 3 | 4.0 |
- ⚠️ Een deling met
/van twee integers geeft steeds een float, ook als de deling "opgaat". Daarom staat er4.0en niet4. - In de f-string worden
{a}en{b}gewoon als tekst ingevuld:12/3 = 4.0.
Vraag 6 (1 pt)¶
Wat is de uitvoer?
In [6]:
a = 3
b = "3"
print(a == int(b), str(a) == b, a == b)
True True False
Uitvoer:
True True False
Uitleg:
| vergelijking | wordt | resultaat |
|---|---|---|
a == int(b) |
3 == 3 |
True |
str(a) == b |
"3" == "3" |
True |
a == b |
3 == "3" (int tegenover str) |
False |
- Een getal en een tekst zijn nooit gelijk voor Python, ook al zien ze er hetzelfde uit. Dit geeft geen fout, gewoon
False.
Vraag 7 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze. De gebruiker typt: "15".
In [7]:
leeftijd = int(input("Leeftijd? "))
print("Volgend jaar ben je " + leeftijd + 1 + " jaar.")
Leeftijd? 15
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[8], line 2 1 leeftijd = int(input("Leeftijd? ")) ----> 2 print("Volgend jaar ben je " + leeftijd + 1 + " jaar.") TypeError: can only concatenate str (not "int") to str
Gewenste uitvoer: Volgend jaar ben je 16 jaar.
Uitvoer van de originele code:
fout
Verbeterde code:
In [8]:
leeftijd = int(input("Leeftijd? "))
print("Volgend jaar ben je " + str(leeftijd + 1) + " jaar.")
Leeftijd? 15 Volgend jaar ben je 16 jaar.
Uitleg:
leeftijdis een int (15)."Volgend jaar ben je " + leeftijdprobeert tekst en een getal samen te voegen met+→ fout.
Er zijn drie goede oplossingen (alle drie volledig juist):
1. Omzetten naar tekst met str()
print("Volgend jaar ben je " + str(leeftijd + 1) + " jaar.")
- Eerst rekenen, dan omzetten:
str(leeftijd + 1)→"16". Nu is het overal tekst + tekst. - ⚠️
str(leeftijd) + 1werkt niet: dan staat er weer tekst + getal.
2. Een f-string
print(f"Volgend jaar ben je {leeftijd + 1} jaar.")
- Alles tussen
{ }wordt eerst berekend en dan automatisch als tekst ingevuld. Omzetten is niet nodig.
3. Komma's in plaats van de eerste en de laatste +
print("Volgend jaar ben je", leeftijd + 1, "jaar.")
printmag verschillende waarden van een verschillend type krijgen, gescheiden door komma's. Een getal hoeft dus niet omgezet te worden.- De middelste
+(inleeftijd + 1) blijft staan: dat is gewoon een optelling van twee getallen. - ⚠️
printzet zelf een spatie tussen de waarden. Laat je de spaties binnen de aanhalingstekens staan ("Volgend jaar ben je ", leeftijd + 1, " jaar."), dan krijg je dubbele spaties:Volgend jaar ben je 16 jaar.Wie die spaties weghaalt, krijgt exact de gewenste uitvoer.
Deel 2: Opsommingen en operatoren (15 pt)¶
Vraag 8 (2 pt)¶
Wat is de uitvoer?
In [9]:
kleuren = ["rood", "groen", "blauw", "geel"]
kleuren[1] = "paars"
kleuren.insert(0, "wit")
print(kleuren)
print(kleuren[2:], "geel" in kleuren)
['wit', 'rood', 'paars', 'blauw', 'geel'] ['paars', 'blauw', 'geel'] True
Uitvoer:
['wit', 'rood', 'paars', 'blauw', 'geel']
['paars', 'blauw', 'geel'] True
Uitleg:
Hoe de lijst verandert:
| regel | kleuren |
|---|---|
| start | ["rood", "groen", "blauw", "geel"] |
kleuren[1] = "paars" |
["rood", "paars", "blauw", "geel"] (plaats 1 wordt vervangen) |
kleuren.insert(0, "wit") |
["wit", "rood", "paars", "blauw", "geel"] (vooraan ingevoegd, de rest schuift op) |
Indices op het einde:
| index | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| element | wit | rood | paars | blauw | geel |
kleuren[2:]= vanaf index 2 tot het einde →['paars', 'blauw', 'geel']"geel" in kleuren→True- Let op: Python toont tekst in een lijst met enkele aanhalingstekens.
Vraag 9 (2 pt)¶
Wat is de uitvoer?
In [10]:
punten = [7, 3, 9]
punten.append(punten[0] + punten[-1])
punten.sort()
print(punten[-2:], len(punten))
[9, 16] 4
Uitvoer:
[9, 16] 4
Uitleg:
| regel | punten |
|---|---|
| start | [7, 3, 9] |
punten.append(punten[0] + punten[-1]) |
punten[0] = 7, punten[-1] = 9 → 16 achteraan: [7, 3, 9, 16] |
punten.sort() |
[3, 7, 9, 16] |
punten[-2:]= de laatste twee elementen →[9, 16]len(punten)→4
Vraag 10 (2 pt)¶
Wat is de uitvoer?
In [11]:
x = 2 ** (3 ** 2) // 100
x = x + 10 - 2 * (3 ** 2)
y = (2 ** 3) ** 2 // 100
y = y + 10 - 2 * (2 ** 3)
print(x, y)
-3 -6
Uitvoer:
-3 -6
Uitleg:
Volgorde van bewerkingen: haakjes → ** → *, /, //, % → +, - (bij gelijke voorrang van links naar rechts).
| regel | berekening stap voor stap | x |
y |
|---|---|---|---|
x = 2 ** (3 ** 2) // 100 |
3 ** 2 = 9 → 2 ** 9 = 512 → 512 // 100 = 5 | 5 | – |
x = x + 10 - 2 * (3 ** 2) |
3 ** 2 = 9 → 2 * 9 = 18 → 5 + 10 − 18 | −3 | – |
y = (2 ** 3) ** 2 // 100 |
2 ** 3 = 8 → 8 ** 2 = 64 → 64 // 100 = 0 | −3 | 0 |
y = y + 10 - 2 * (2 ** 3) |
2 ** 3 = 8 → 2 * 8 = 16 → 0 + 10 − 16 | −3 | −6 |
print(x, y)→-3 -6- Merk op: waar de haakjes staan maakt een groot verschil: 2 ** (3 ** 2) = 512, maar (2 ** 3) ** 2 = 64.
//geeft het gehele deel van de deling: 64 // 100 = 0 (100 past 0 keer in 64).
Vraag 11 (3 pt)¶
Wat is de uitvoer?
In [12]:
regen = True
temp = 12
print(not regen or temp > 10)
print(regen and (temp < 10 or temp == 12))
print(temp > 5 and not temp % 4 == 0)
True True False
Uitvoer:
True
True
False
Uitleg:
regen = True, temp = 12
| regel | stap 1 | stap 2 | resultaat |
|---|---|---|---|
not regen or temp > 10 |
not True = False; 12 > 10 = True |
False or True |
True |
regen and (temp < 10 or temp == 12) |
haakjes eerst: False or True = True |
True and True |
True |
temp > 5 and not temp % 4 == 0 |
12 % 4 = 0 → 0 == 0 = True → not True = False |
True and False |
False |
oris True zodra één kant True is;andis pas True als beide kanten True zijn.notwerkt op de volledige vergelijkingtemp % 4 == 0(eerst rekenen, dan vergelijken, pas dannot).
Vraag 12 (2 pt)¶
Wat is de uitvoer?
In [13]:
naam = "Ada Lovelace"
print(naam.lower().count("a"))
print(naam[4:].upper() + "!" * 2)
3 LOVELACE!!
Uitvoer:
3
LOVELACE!!
Uitleg:
Eerste regel: print(naam.lower().count("a"))
Je leest dit van links naar rechts, als een ketting:
| stap | wat gebeurt er? | resultaat |
|---|---|---|
naam |
de tekst | "Ada Lovelace" |
.lower() |
maakt een nieuwe tekst in kleine letters | "ada lovelace" |
.count("a") |
telt hoeveel keer "a" voorkomt in die tekst |
3 |
count()geeft een getal terug, geen tekst. Wat inprint(...)staat, is dus enkel het eindresultaat van de ketting: het getal3."ada lovelace"is maar een tussenstap: die tekst wordt gebruikt om in te tellen, maar wordt niet afgedrukt. Daarom staat er enkel3en nietada lovelace 3.- Wil je beide zien, dan moet je ze apart vermelden, bv.
print(naam.lower(), naam.lower().count("a")). naamzelf verandert niet: dat blijft"Ada Lovelace".- Zonder
.lower()zou de hoofdletterAniet meetellen → dan zou er2staan.
Tweede regel: print(naam[4:].upper() + "!" * 2)
| index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| teken | A | d | a | ␣ | L | o | v | e | l | a | c | e |
naam[4:]→ vanaf index 4:"Lovelace"→.upper()→"LOVELACE""!" * 2→"!!"(*gaat voor+)- Samen:
LOVELACE!!
Vraag 13 (2 pt)¶
Wat is de uitvoer? De gebruiker typt: "ik leer Python".
In [14]:
zin = input("Zin? ")
print(f"{zin[1:5].upper()} en de volledige zin heeft {len(zin)} tekens")
print(zin[-4:] * 2)
Zin? ik leer Python K LE en de volledige zin heeft 14 tekens thonthon
Uitvoer:
K LE en de volledige zin heeft 14 tekens
thonthon
Uitleg:
zin = "ik leer Python" (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 | 12 | 13 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| teken | i | k | ␣ | l | e | e | r | ␣ | P | y | t | h | o | n |
| negatief | −14 | −13 | −12 | −11 | −10 | −9 | −8 | −7 | −6 | −5 | −4 | −3 | −2 | −1 |
zin[1:5]→ index 1 tot en met 4 (5 niet!) →"k le"→.upper()→"K LE"(de spatie blijft gewoon staan)len(zin)→ 14: ook de 2 spaties tellen mee als teken.zin[-4:]→ de laatste 4 tekens:"thon"→* 2→"thonthon"
Vraag 14 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [15]:
boodschappen = ["melk", "brood", "kaas"]
boodschappen.append["eieren"]
print(f"{len(boodschappen)} items, laatste is {boodschappen[-1]}")
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[16], line 2 1 boodschappen = ["melk", "brood", "kaas"] ----> 2 boodschappen.append["eieren"] 3 print(f"{len(boodschappen)} items, laatste is {boodschappen[-1]}") TypeError: 'builtin_function_or_method' object is not subscriptable
Gewenste uitvoer: 4 items, laatste is eieren
Uitvoer van de originele code:
fout
Verbeterde code:
In [16]:
boodschappen = ["melk", "brood", "kaas"]
boodschappen.append("eieren")
print(f"{len(boodschappen)} items, laatste is {boodschappen[-1]}")
4 items, laatste is eieren
Uitleg:
appendis een methode: je roept ze op met ronde haakjes( ).- Vierkante haakjes
[ ]gebruik je om een element op te vragen via een index (boodschappen[0]).append["eieren"]geeft dus een fout. - Na de verbetering:
["melk", "brood", "kaas", "eieren"]→len= 4 enboodschappen[-1]="eieren".
Deel 3: Structuren (13 pt)¶
Vraag 15 (1 pt)¶
Wat is de uitvoer?
In [17]:
x = 1
while x < 50:
x = x * 3
print(x)
81
Uitvoer:
81
Uitleg:
| doorloop | x bij de controle |
x < 50? |
nieuwe x |
|---|---|---|---|
| 1 | 1 | True | 3 |
| 2 | 3 | True | 9 |
| 3 | 9 | True | 27 |
| 4 | 27 | True | 81 |
| – | 81 | False → stop | – |
- De
print(x)staat niet ingesprongen, dus pas na de lus wordtxéén keer getoond:81. - Let op: 81 is groter dan 50. De voorwaarde wordt pas gecontroleerd vóór een nieuwe doorloop.
Vraag 16 (2 pt)¶
Wat is de uitvoer?
In [18]:
woord = "programmeren"
teller = 0
for letter in woord:
if letter == "r":
teller += 1
elif letter == "m":
teller -= 1
print(teller)
1
Uitvoer:
1
Uitleg:
letter |
p | r | o | g | r | a | m | m | e | r | e | n |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| actie | – | +1 | – | – | +1 | – | −1 | −1 | – | +1 | – | – |
teller |
0 | 1 | 1 | 1 | 2 | 2 | 1 | 0 | 0 | 1 | 1 | 1 |
- 3 keer een
r(+3) en 2 keer eenm(−2) → 3 − 2 = 1 - De
printstaat na de lus (niet ingesprongen) → er wordt maar één getal getoond.
Vraag 17 (4 pt)¶
Wat is de uitvoer?
In [19]:
getallen = [4, 7, 10, 3, 8]
resultaat = []
for g in getallen:
if g % 2 == 0:
resultaat.append(g // 2)
elif g > 5:
resultaat.append(g * 10)
else:
print(f"overslaan: {g}")
print(len(resultaat))
print(resultaat)
1 2 3 overslaan: 3 3 4 [2, 70, 5, 4]
Uitvoer:
1
2
3
overslaan: 3
3
4
[2, 70, 5, 4]
Uitleg:
Let op de inspringing: print(len(resultaat)) staat in de for-lus, maar niet in de else. Die regel wordt dus bij elk getal uitgevoerd.
g |
g % 2 == 0? |
g > 5? |
wat gebeurt er? | resultaat na deze doorloop |
uitvoer |
|---|---|---|---|---|---|
| 4 | True | (niet gecontroleerd) | append(4 // 2) = 2 | [2] |
1 |
| 7 | False | True | append(7 * 10) = 70 | [2, 70] |
2 |
| 10 | True | (niet gecontroleerd) | append(10 // 2) = 5 | [2, 70, 5] |
3 |
| 3 | False | False | else: tekst tonen | [2, 70, 5] (onveranderd) |
overslaan: 3 en 3 |
| 8 | True | (niet gecontroleerd) | append(8 // 2) = 4 | [2, 70, 5, 4] |
4 |
- Na de lus:
print(resultaat)→[2, 70, 5, 4] - Bij
g = 3verschijnen er dus twee regels: eerst de tekst uit deelse, daarna de lengte (die blijft 3).
Vraag 18 (2 pt)¶
Wat is de uitvoer? Geef de uitvoer voor elk van deze invoeren: "18" en "8".
In [20]:
temp = int(input("Temperatuur? "))
if temp > 25:
print("Het is heet")
elif temp > 10:
print("Het is gematigd")
elif temp > 15:
print("Het is warm")
else:
print("Het is koud")
Temperatuur? 18 Het is gematigd
Uitvoer bij invoer "18":
Het is gematigd
Uitvoer bij invoer "8":
Het is koud
Uitleg:
Bij if / elif / else controleert Python de voorwaarden van boven naar onder en voert enkel het eerste blok uit waarvan de voorwaarde True is. De rest wordt overgeslagen.
| voorwaarde | temp = 18 |
temp = 8 |
|---|---|---|
temp > 25 |
False | False |
temp > 10 |
True → "Het is gematigd", stop | False |
temp > 15 |
(niet meer gecontroleerd) | False |
else |
– | → "Het is koud" |
- Bij 18 is
temp > 15ook waar, maar die regel komt nooit aan bod:temp > 10was al waar. - Eigenlijk kan "Het is warm" nooit verschijnen: elk getal groter dan 15 is ook groter dan 10. De volgorde van de voorwaarden is onlogisch. Correct zou zijn: eerst
> 25, dan> 15, dan> 10.
Vraag 19 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [21]:
teller = 5
while teller > 0:
print(teller, end=" ")
teller -= 1
print("start!")
5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 ... (afgekapt)
⚠ Deze cel stopt nooit (oneindige lus). De uitvoering werd na 5 seconden onderbroken.
Gewenste uitvoer: 5 4 3 2 1 start!
Uitvoer van de originele code:
5 5 5 5 5 5 5 5 5 5 ... (blijft eindeloos doorgaan)
Verbeterde code:
In [22]:
teller = 5
while teller > 0:
print(teller, end=" ")
teller -= 1
print("start!")
5 4 3 2 1 start!
Uitleg:
teller -= 1staat niet ingesprongen, dus die regel hoort niet bij de while-lus. Binnen de lus veranderttellernooit: het blijft 5 enteller > 0blijft altijd True → oneindige lus.- Oplossing:
teller -= 1inspringen (4 spaties), zodat het in de lus staat.
Verloop na de verbetering:
| doorloop | teller bij de controle |
teller > 0? |
getoond | teller daarna |
|---|---|---|---|---|
| 1 | 5 | True | 5 |
4 |
| 2 | 4 | True | 4 |
3 |
| 3 | 3 | True | 3 |
2 |
| 4 | 2 | True | 2 |
1 |
| 5 | 1 | True | 1 |
0 |
| – | 0 | False → stop | – | – |
- Door
end=" "komen alle getallen op één regel, met een spatie ertussen. Daarna volgtstart!op dezelfde regel.
Vraag 20 (2 pt)¶
Zoek de fout! Deze code bevat precies één fout. Verbeter ze.
In [23]:
getallen = [4, 11, 7, 2]
grootste = 0
for g in getallen:
if g < grootste:
grootste = g
print(f"Grootste: {grootste}")
Grootste: 0
Gewenste uitvoer: Grootste: 11
Uitvoer van de originele code:
Grootste: 0
Verbeterde code:
In [24]:
getallen = [4, 11, 7, 2]
grootste = 0
for g in getallen:
if g > grootste:
grootste = g
print(f"Grootste: {grootste}")
Grootste: 11
Uitleg:
- Geen foutmelding, maar een fout resultaat:
grootstebegint op 0 en de voorwaardeg < grootsteis voor geen enkel (positief) getal waar.grootsteblijft dus 0. - Oplossing:
<vervangen door>.
Verloop na de verbetering:
g |
grootste vóór |
g > grootste? |
grootste na |
|---|---|---|---|
| 4 | 0 | True | 4 |
| 11 | 4 | True | 11 |
| 7 | 11 | False | 11 |
| 2 | 11 | False | 11 |
- Tip: nog beter is starten met
grootste = getallen[0]. Dan werkt het ook als alle getallen negatief zijn.
Bonusvraag (geneste herhaling) (+3 pt bonus)¶
Vraag 21 (3 pt)¶
Wat is de uitvoer?
In [25]:
for i in range(1, 4):
lijn = ""
for j in range(4 - i):
lijn += "-"
for j in range(i):
lijn += str(i)
print(lijn)
---1 --22 -333
Uitvoer:
---1
--22
-333
Uitleg:
De buitenste lus loopt over i = 1, 2, 3. Per waarde van i begint lijn opnieuw leeg en draaien er na elkaar twee binnenste lussen:
- de eerste lus draait
4 - ikeer en voegt telkens"-"toe; - de tweede lus draait
ikeer en voegt telkens het cijferstr(i)toe.
i |
range(4 - i) |
streepjes | range(i) |
cijfers | lijn → uitvoer |
|---|---|---|---|---|---|
| 1 | 0, 1, 2 (3 keer) | --- |
0 (1 keer) | 1 |
---1 |
| 2 | 0, 1 (2 keer) | -- |
0, 1 (2 keer) | 22 |
--22 |
| 3 | 0 (1 keer) | - |
0, 1, 2 (3 keer) | 333 |
-333 |
print(lijn)staat in de buitenste lus (4 spaties inspringing) → één regel per waarde vani.- Let op:
jzelf wordt niet gebruikt, de binnenste lussen dienen enkel om iets een aantal keer te herhalen.