Pythonbasis: waarden, variabelen en expressies

Een programma is een reeks instructies. De Pythoninterpreter leest Pythoncode en voert die instructies uit. Gebruik Python 3, waarin een aanroep zoals print("Hello") haakjes heeft.

Probeer een regel in de shell

De interactieve shell, of REPL (read–evaluate–print loop), toont >>> wanneer die klaar is voor Pythoncode. Typ een instructie na de prompt en druk op Enter. Je typt >>> niet zelf.

>>> 3 + 4
7
>>> "hi"
'hi'

De shell toont automatisch de waarde van een expressie. Hij zet aanhalingstekens om een string om aan te geven dat het tekst is. Een prompt ... betekent dat een instructie onvoltooid is en Python op meer wacht. Een openingshaakje kan bijvoorbeeld nog een sluithaakje nodig hebben. Typ exit() bij een prompt die klaarstaat om de shell te verlaten.

De shell is handig om één expressie te testen. Hij kan een geschiedenis van commando’s bijhouden, maar die geschiedenis is geen opgeslagen programma. Zet instructies die je opnieuw samen wilt uitvoeren in een script.

Sla een script op en voer het uit

Een script is een bestand met code als platte tekst en de extensie .py. Gebruik een code-editor zoals IDLE, Thonny of VS Code. IDLE wordt meegeleverd met de standaarddistributie van Python. Een tekstverwerker kan rechte aanhalingstekens veranderen in gekrulde aanhalingstekens; die gekrulde tekens kunnen Pythonstrings niet begrenzen.

Voer deze regels in de editor in en sla het script op:

print("Hello, world!")
print("Welcome to Python.")

Kies in IDLE Run → Run Module of druk op F5. De uitvoer is:

Hello, world!
Welcome to Python.

Python voert deze instructies van boven naar beneden uit. Elke print() toont zijn tekst en gaat naar een nieuwe regel. Als je de instructies omkeert, keert ook de uitvoer om.

Je kunt een opgeslagen script ook vanuit een terminal uitvoeren. Open de map met je script en voer het interpretercommando in, gevolgd door de naam waaronder het script is opgeslagen. Op macOS of Linux is het commando meestal python3 gevolgd door de scriptnaam; op Windows wordt vaak python of py gebruikt. Het terminalcommando start de interpreter en vertelt welk script die moet uitvoeren. Dat commando hoort bij de prompt van de terminal, niet na >>> van Python. Een online editor kan in plaats daarvan een uitvoerknop bieden.

Bepaal wat je moet afdrukken

Een script met alleen 3 + 4 berekent een waarde, maar toont niets. Schrijf print(3 + 4) om 7 te tonen. Zo toont print("hi") de tekst ook zonder de aanhalingstekens eromheen. De aanhalingstekens horen bij de code; ze markeren het begin en einde van de tekst.

Python is hoofdlettergevoelig. print en Print zijn verschillende namen, dus Print("hi") levert een NameError op, tenzij die afzonderlijke naam is gedefinieerd. Neem de spelling en hoofdletters van ingebouwde namen precies over.

Spaties aan het begin van een regel hebben ook betekenis. Begin bij deze eenvoudige reeksen instructies elke instructie aan de linkerkant. Een verdwaalde inspringing vóór print("hi") kan IndentationError: unexpected indent veroorzaken. Spaties binnen de tekst tussen aanhalingstekens zijn anders: Python drukt die af als onderdeel van de melding.

Een fout in een programma is een programmeerfout. Die opsporen en herstellen heet debuggen. Bepaal eerst wat voor probleem je hebt: code die Python niet kan lezen, een bewerking die tijdens de uitvoering mislukt of een resultaat dat gewoon verkeerd is.

Drie soorten problemen

Python controleert de syntaxis van het hele script voordat het wordt uitgevoerd. Een syntaxisfout aan het einde verhindert zelfs dat de eerste regel wordt uitgevoerd. Bij een uitvoeringsfout is dat anders: eerdere instructies zijn al uitgevoerd en hun afgedrukte uitvoer blijft zichtbaar.

Voor het gemiddelde wordt de deling vóór de optelling uitgevoerd. Python berekent 92 / 2 als 46.0 en telt daar 88 bij op om 134.0 te krijgen. De bedoelde expressie is (88 + 92) / 2, die 90.0 geeft. Er is geen foutmelding omdat beide expressies geldig zijn. Een berekening met de hand geeft je iets om met het programma te vergelijken.

Lees een stacktrace vanaf de onderkant

Stel dat de code is:

name = "Ada"
print("Hello", nme)

De stacktrace eindigt met een melding zoals NameError: name 'nme' is not defined. De laatste regel noemt de fout en legt uit wat misging. Daarboven toont Python de locatie, het regelnummer en de code. Vergelijk nme met de naam waaraan eerder een waarde is toegekend: name. Als je die spelling verbetert, wordt de uitvoer Hello Ada.

De gemelde locatie is waar Python het probleem opmerkte. Als een regel er correct uitziet, controleer dan ook de regel ervoor. Door een eerder ontbrekend aanhalingsteken of haakje kan Python mogelijk niet begrijpen wat volgt. Recente versies wijzen vaak rechtstreeks naar het openingshaakje zonder bijbehorend sluithaakje.

Laat het fouttype je zoektocht sturen

• NameError: Python kan een naam niet vinden, zoals bij pirnt, Print of een variabele die vóór de toekenning wordt gebruikt. Controleer de spelling, hoofdletters en volgorde van de regels.
• TypeError: de bewerking werkt niet met die typen. "5" + 5 probeert tekst en een getal samen te voegen.
• ValueError: een conversie ontvangt onbruikbare inhoud. int("abc") ontvangt tekst, maar de tekst beschrijft geen geheel getal.
• ZeroDivisionError: een deler is nul. Bekijk de waarde na /, // of %.

Zoek bij een SyntaxError bij elk openingsaanhalingsteken en openingshaakje het bijbehorende afsluitende teken. print('It's late') sluit de string af bij de apostrof in “It's”; gebruik print("It's late"). Python 2-code zoals print "hi" heeft de haakjes van Python 3 nodig: print("hi"). Typ gekrulde aanhalingstekens opnieuw als rechte aanhalingstekens. Verwijder bij onverwachte inspringing de verdwaalde spaties aan het begin van de regel.

Herstel één probleem en voer het programma opnieuw uit. De eerste fout kan hebben verhinderd dat Python een tweede fout bereikte. Bouw een programma enkele regels tegelijk op, zodat je bij elke nieuwe fout een klein stuk hoeft te onderzoeken.

Code vertelt Python wat het moet doen. Een commentaar vertelt een mens waarom de code dat doet of wat een waarde betekent. Python negeert commentaar bij het uitvoeren van het programma.

Markeer commentaar duidelijk

Commentaar begint met # buiten een string en loopt door tot het einde van die regel. Het kan op zichzelf staan of op een instructie volgen:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

Het commentaar op een volledige regel legt het doel van het programma uit. Het commentaar achter code op dezelfde regel volgt op code op dezelfde regel. PEP 8, de stijlgids van Python, beveelt minstens twee spaties aan vóór een # achter code en één spatie erna. Door die spaties is de grens goed zichtbaar.

Een hekje binnen aanhalingstekens is gewone tekst:

print("#1 is not a comment")  # This part is a comment.

De uitvoer is #1 is not a comment. Python leest de hele string tussen aanhalingstekens, inclusief het hekje, als gegevens. Het negeert de tekst na het latere #, omdat dat teken buiten de aanhalingstekens staat.

Leg de betekenis uit, geen voor de hand liggende stappen

Vergelijk deze commentaren:

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

Het eerste commentaar herhaalt een bewerking die al in de code zichtbaar is. Het tweede geeft een reden voor de verandering. Een lezer weet nu wat er met een poging wordt geteld. Een duidelijke naam zoals attempts neemt ook een deel van het werk over dat bij een vage naam aan commentaar zou worden overgelaten.

Nuttig commentaar legt een eenheid, een keuze of een doel uit dat de code alleen niet duidelijk maakt. Zo verbindt tax_rate = 0.08 # 8% sales tax een decimaal tarief met zijn betekenis. Als je dat tarief later verandert, controleer dan ook het commentaar. Verouderd commentaar kan een lezer op het verkeerde spoor zetten, ook als de code werkt.

Voorkom tijdelijk dat een regel wordt uitgevoerd

Om een instructie uit te commentariëren, zet je er # voor:

print("Start")
# print("Checking this step")
print("Finish")

Alleen Start en Finish verschijnen. Door een regel uit te commentariëren blijft die beschikbaar terwijl je het programma zonder die regel test. Verwijder oude uitgeschakelde code wanneer die niet meer helpt; anders moet een latere lezer raden of die nog nodig is.

Voor een aantekening over meerdere regels begin je elke regel met #:

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

Tekst tussen drievoudige aanhalingstekens is anders. Een regel zoals """Convert a temperature.""" is een stringexpressie, geen commentaar. Zulke strings kunnen op bepaalde plaatsen dienen als documentatie, docstrings genoemd. Gebruik # wanneer je gewoon commentaar bedoelt. Een string die nergens wordt gebruikt, kan in een script onzichtbaar blijven. Daardoor kan die op commentaar lijken, hoewel Python hem als waarde leest.

Een waarde is een gegeven, zoals 42, 3.5 of "Ada". Elke waarde heeft een type, dat Python vertelt om wat voor gegeven het gaat. Een letterlijke waarde is een waarde die rechtstreeks in code staat. De schrijfwijze is van belang: 7, 7.0 en "7" hebben verschillende typen.

Vier basistypen

Een decimale punt maakt van 2.0 een float, ook al is de getalswaarde gelijk aan het gehele getal 2. Aanhalingstekens maken van "42" tekst, ook al lijken de tekens op een getal. Het type volgt uit de geschreven waarde, niet uit het doel waarvoor een lezer die zou kunnen gebruiken.

Booleaanse letterlijke waarden hebben een hoofdletter en geen aanhalingstekens. True is een booleaanse waarde; "True" is een string. true met een kleine letter is een naam, en als je die gebruikt zonder hem te definiëren, krijg je NameError. Een vergelijking kan een booleaanse waarde opleveren: 3 < 5 evalueert tot True.

Vraag Python om het type

De ingebouwde functie type() geeft het type van haar argument. In de shell tonen deze aanroepen:

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

Gebruik in een script print() om die resultaten te zien:

print(type(42), type("42"))

Dit drukt <class 'int'> <class 'str'> af. Het woord class maakt deel uit van wat Python teruggeeft; de namen int en str duiden de typen aan.

Typen veranderen de betekenis van operatoren

Bij getallen telt + op. Bij twee strings voegt de operator tekst samen:

print(5 + 3)
print("5" + "3")

De eerste regel drukt 8 af. De tweede drukt 53 af. De tweede expressie heeft twee tekstwaarden, dus Python voegt hun tekens samen. Het bekijkt de cijfertekens niet om vervolgens te besluiten ze op te tellen.

"5" + 5 werpt TypeError op: de ene operand is tekst en de andere is een geheel getal. Controleer de typen wanneer een bewerking zich anders gedraagt dan je verwacht. Cijfers op het scherm bewijzen niet dat de opgeslagen waarde numeriek is.

Kies een type dat bij de betekenis past

Gebruik een geheel getal voor een aantal en een float voor een meting die een breukdeel kan bevatten. Bewaar een identificator zoals een Amerikaanse postcode als tekst. De string "02134" behoudt de eerste nul; die nul hoort bij de identiteit van de code en maakt geen deel uit van een berekening. Telefoonnummers kunnen ook leestekens bevatten die je wilt bewaren.

De shell kan 'Ada' tonen, terwijl print("Ada") de tekst Ada toont. Beide verwijzen naar dezelfde tekst. De aanhalingstekens van de shell geven een string aan; print() toont de tekens aan een lezer. Geen van beide weergaven verandert het opgeslagen type.

Python heeft afzonderlijke typen voor gehele getallen en zwevendekommagetallen. Door ze duidelijk te schrijven voorkom je zowel syntaxisfouten als minder opvallende veranderingen in de gegevens.

Schrijf aantallen als gehele getallen

Een geheel getal heeft geen breukdeel. Schrijf een int zonder decimale punt, zoals in 42, 0 of -7. Gehele getallen in Python kunnen zo groot worden als het beschikbare geheugen toelaat, zonder een vaste groottebeperking. Optellen, aftrekken en vermenigvuldigen van gehele getallen zijn exact. Zo geeft 2 ** 100 het exacte gehele getal 1267650600228229401496703205376.

Gebruik geen komma’s om duizendtallen te groeperen. Schrijf 1000000 of gebruik underscores voor de leesbaarheid: 1_000_000. De underscores veranderen de waarde niet.

Een decimale letterlijke waarde voor een geheel getal anders dan nul mag niet met een nul beginnen. 02134 schrijven is een syntaxisfout. Als die cijfers een identificator vormen waarbij de eerste nul van belang is, schrijf dan "02134" als tekst.

Schrijf hoeveelheden met breukdelen als floats

Een zwevendekommagetal (float) gebruikt een decimale punt of exponentnotatie. 3.5, 2.0 en -0.25 zijn floats. Python accepteert ook .5 en 5., die 0.5 en 5.0 betekenen; de extra nul schrijven maakt ze vaak gemakkelijker leesbaar. Gebruik floats voor metingen zoals temperatuur of afstand en voor inleidende berekeningen met prijzen die een breukdeel hebben.

Pythoncode gebruikt een decimale punt. Een komma scheidt waarden en markeert nooit het breukdeel. Bijvoorbeeld:

x = 3.5
print(x)

drukken 3.5 af, terwijl x = 3,5 een paar waarden maakt, weergegeven als (3, 5). Zo maakt x = 1,000 ook (1, 0), niet duizend. Deze instructies kunnen worden uitgevoerd, dus het ontbreken van een foutmelding betekent niet dat het getal correct is geschreven.

Gebruik wetenschappelijke notatie

De letter e betekent “maal tien tot de macht” in een letterlijke getalswaarde:

Een letterlijke waarde met een exponent is een float, ook als de waarde een geheel getal is. Het minteken na e maakt de exponent negatief, dus 2.5e-3 betekent 2,5 gedeeld door 1.000.

Houd rekening met beperkte precisie

Floats slaan getallen binair op met beperkte precisie, doorgaans ongeveer 15–17 significante decimale cijfers. Veel decimale breuken, waaronder 0.1, kunnen daarin niet exact worden weergegeven. Daardoor:

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

wordt eerst 0.30000000000000004 afgedrukt en daarna 0.3. Het kleine verschil komt door de opgeslagen benaderingen. round(..., 2) rondt het resultaat af op twee decimalen voor de weergave; het verandert niet hoe floats waarden opslaan. Bewaar de oorspronkelijke berekening tot het einde en rond dan het weergegeven resultaat af.

Een teken kan ook een operator zijn. Unaire min verandert het teken van één waarde: -7 is min zeven. In 5 - -3 trekt het eerste minteken af en maakt het tweede de daaropvolgende drie negatief, dus is het resultaat 8. Onderscheid dit teken van de negatieve exponent in een letterlijke waarde zoals 2.5e-3.

Een string is een reeks tekens: letters, cijfers, spaties, leestekens en andere symbolen. Aanhalingstekens vertellen Python waar die reeks begint en eindigt. De tekens ertussen zijn gegevens, ook als ze op Pythoncode lijken.

Kies passende aanhalingstekens

Enkele en dubbele aanhalingstekens maken hetzelfde type, str. Zowel 'Ada' als "Ada" bevat dezelfde drie tekens. Begin en eindig een string met hetzelfde soort aanhalingsteken.

Kies de buitenste aanhalingstekens zo dat je een aanhalingsteken binnenin gemakkelijk kunt schrijven:

print("It's late")
print('She said "hi"')

De uitvoer is:

It's late
She said "hi"

In print('It's late') sluit de apostrof na It de string te vroeg af. Python kan de rest van de instructie dan niet lezen. Met dubbele aanhalingstekens aan de buitenkant blijft de apostrof binnen de tekst.

Gebruik een escapesequentie

Een backslash begint een escapesequentie. Deze gebruikelijke sequenties staan elk voor één teken:

Zo drukt print("Line 1\nLine 2") twee regels af. De backslash en de n in de code staan samen voor een regeleinde, niet voor een zichtbare letter n. Zo drukt print('It\'s late') ook It's late af: het aanhalingsteken met de backslash wordt een teken zonder de string te beëindigen.

Om een letterlijke backslash gevolgd door een letter af te drukken, schrijf je een dubbele backslash. print("A\\B") toont A\B. De eerste backslash geeft aan dat de volgende backslash een teken moet zijn.

Behoud regeleinden of laat tekens weg

Met drievoudige aanhalingstekens kan één string meerdere fysieke regels beslaan. De regeleinden worden onderdeel van de waarde:

print("""Line one
Line two""")

Dit drukt Line one en Line two op afzonderlijke regels af. Drievoudige enkele aanhalingstekens werken ook. Drievoudige aanhalingstekens maken nog steeds een string; ze maken geen #-commentaar.

De lege string, "", heeft geen tekens. Die verschilt van " ", dat één spatie bevat. Die spatie is in de uitvoer soms moeilijk te zien, maar blijft onderdeel van de gegevens.

Maak onderscheid tussen tekst en een expressie of naam

Vergelijk deze instructies:

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

De uitvoer is 3 + 4, dan 7, dan name en dan Ada. De aanhalingstekens maken van het eerste en derde argument letterlijke tekst. Zonder aanhalingstekens evalueert Python een berekening of zoekt het een variabele op.

Als je aanhalingstekens rond een boodschap zoals Hello vergeet, zoekt Python naar een naam. Als Hello niet is gedefinieerd, werpt print(Hello) een NameError op. Schrijf print("Hello") als je dat woord wilt.

Strings kunnen tekens uit veel talen en symbolen bevatten, zoals "café", "naïve" en "°F". Er kunnen ook cijfers tussen staan: "Room 101" is helemaal tekst. Een cijferteken tussen aanhalingstekens wordt geen geheel getal.

Een variabele is een naam die verwijst naar een waarde in het geheugen. Een toekenningsinstructie verbindt een naam links van = met de waarde van een expressie rechts ervan.

Lees eerst de rechterkant

In age = 30 evalueert Python 30 en laat daarna age naar dat gehele getal verwijzen. De linkerkant moet een geldige plaats zijn om een waarde aan toe te kennen. 30 = age is een syntaxisfout: je kunt geen nieuwe waarde toekennen aan de letterlijke waarde 30.

Het teken = betekent “ken toe”. Het vraagt niet of twee waarden gelijk zijn. Om gelijkheid te controleren gebruik je ==. Als je een toekenning leest als een werkrichting, worden instructies zoals x = x + 1 begrijpelijk: gebruik de oude x rechts, bereken de nieuwe waarde en ken die toe aan x links.

Bekijk een rechthoek:

width = 4
height = 2.5
area = width * height
print(area)

Na de eerste regel verwijst width naar 4. Na de tweede verwijst height naar 2.5. Voor de derde regel zoekt Python beide huidige waarden op en evalueert het 4 * 2.5, wat 10.0 oplevert. Het kent dat resultaat toe aan area. De laatste regel drukt 10.0 af.

Een toekenning zelf drukt de waarde niet af. Gebruik de naam in een latere aanroep van print() als je de waarde wilt tonen.

Ken een waarde toe voordat je een naam gebruikt

Python volgt de volgorde van de instructies. Deze code mislukt op de eerste regel:

print(total)
total = 10

Op dat moment heeft total geen waarde. De latere toekenning kan geen waarde leveren aan een eerdere instructie. Verplaats total = 10 naar vóór print(total).

Een shell kan namen uit eerdere experimenten onthouden. Een opgeslagen programma moet de toekenningen die het nodig heeft in zijn eigen uitvoeringsvolgorde bevatten, zodat het resultaat niet afhangt van wat je eerder hebt getypt.

Ken een bestaande naam een nieuwe waarde toe

Een hernieuwde toekenning laat een naam naar een nieuwe waarde verwijzen:

score = 10
score = 15

Nu is score gelijk aan 15; de eerdere waarde 10 is niet meer via die naam bereikbaar. Voor een bijwerking op basis van de oude waarde:

x = 3
x = x + 1

De tweede regel evalueert 3 + 1 en kent daarna 4 toe aan x. Er is geen vergelijking om op te lossen en geen tegenspraak.

Een type hoort bij de waarde, niet blijvend bij de variabelenaam. Python staat temp = 3 gevolgd door temp = "three" toe; daarna geeft type(temp) het type str. Als je de betekenis en het verwachte type van een naam consistent houdt, is een programma meestal gemakkelijker te volgen.

Een gekopieerde waarde is geen blijvende koppeling

a = 5
b = a
a = 10
print(a, b)

Dit drukt 10 5 af. Bij b = a verwijzen beide namen naar het huidige gehele getal 5. Een hernieuwde toekenning aan a verandert naar welke waarde a verwijst; b blijft naar 5 verwijzen. Zo slaat het bewaren van width * height ook het resultaat op, geen formule die zichzelf bijwerkt wanneer width verandert.

Eén instructie kan waarden aan meerdere namen toekennen. a = b = 0 geeft beide namen de waarde 0. In x, y = 1, 2 worden de waarden op positie aan de namen gekoppeld, zodat x gelijk wordt aan 1 en y aan 2.

Een naam moet voldoen aan de grammatica van Python en iemand helpen het programma te begrijpen. Dat zijn twee afzonderlijke eisen: Python kan een naam accepteren die de code toch moeilijk leesbaar maakt.

Volg de naamgevingsregels

Een variabelenaam mag letters, cijfers en underscores bevatten. Hij mag niet met een cijfer beginnen, geen spatie bevatten en geen leestekens zoals een koppelteken gebruiken.

Python accepteert ook letters uit andere alfabetten. Engelse letters zijn een gebruikelijke keuze voor identificatoren. Welke letters je ook kiest, houd de spelling consistent: age, Age en AGE zijn drie verschillende namen. Met age = 30 definieer je Age niet.

Houd gereserveerde woorden en ingebouwde namen uit elkaar

Een gereserveerd woord is gereserveerd voor de grammatica van Python. Je kunt het niet als variabelenaam gebruiken. De vast gereserveerde woorden zijn:

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

Je hoeft de lijst niet uit je hoofd te leren voordat je een programma schrijft. Herken voorlopig dat een naam zoals class niet beschikbaar is: class = 3 is een syntaxisfout. Editors tonen gereserveerde woorden vaak in een speciale kleur.

Namen van ingebouwde functies, waaronder print, input, int, str, type, sum en max, zijn geen gereserveerde woorden. Python staat toe dat je er waarden aan toekent, maar die toekenning verbergt de oorspronkelijke functie:

print = 5
print("hi")

De tweede regel probeert het gehele getal 5 aan te roepen en werpt TypeError op. Kies een naam die je gegevens beschrijft, zoals total, zodat de ingebouwde functie beschikbaar blijft. Als je een shell opnieuw start, worden onbedoelde vervangingen tijdens experimenten gewist.

Schrijf namen in een consistente stijl

PEP 8 beveelt snake_case aan voor variabelenamen: woorden in kleine letters, verbonden met underscores, zoals in hourly_rate en first_name. De underscore houdt een naam van meerdere woorden zonder spaties bij elkaar.

Een constante is een waarde die je onveranderd wilt houden. Volgens afspraak schrijf je de naam met hoofdletters:

SALES_TAX_RATE = 0.08

Python vergrendelt die naam niet. Een latere toekenning kan de waarde veranderen; de hoofdletters maken een bedoeling duidelijk aan de lezer.

Vermeld betekenis en eenheden

hours_worked = 38 vertelt meer dan h = 38. Een naam zoals distance_miles of temp_f geeft ook de eenheid aan. Daardoor is de kans kleiner dat je mijlen gebruikt alsof het kilometers zijn of Fahrenheit alsof het Celsius is. Korte namen zoals x en y werken goed voor coördinaten of een korte formule waarbij hun betekenis al duidelijk is.

Vermijd bijna identieke namen zoals total en totl. Een typefout kan een NameError opleveren, maar kan ook per ongeluk een andere bestaande variabele gebruiken. PEP 8 raadt ook de losse letters l, O en I af, omdat die op cijfers kunnen lijken. Enkele extra letters kunnen een berekening veel gemakkelijker te controleren maken.

Bij een bijwerking gebruik je de huidige waarde van een variabele om de volgende waarde te berekenen. Door elke bijwerking op volgorde te volgen, kun je uitvoer voorspellen en logische fouten vinden voordat je het programma uitvoert.

Geef een waarde voordat je die bijwerkt

count = count + 1 telt één op bij de oude waarde van de teller. Die verandering is een verhoging. Een variabele die een lopend totaal bijhoudt, is een accumulator; geef die een beginwaarde zoals total = 0 voordat je bedragen optelt.

Samengestelde toekenning combineert een bewerking met een toekenning. Voor getallen heeft x += 3 hetzelfde effect als x = x + 3. De beschikbare vormen zijn onder meer +=, -=, *=, /=, //=, %= en **=.

score = 10
score -= 3
score **= 2
print(score)

De aftrekking verandert score in 7. De machtsverheffing verandert die daarna in 49, dat wordt afgedrukt. Zonder de eerste toekenning zou een bijwerking een niet-gedefinieerde naam proberen te gebruiken en NameError opwerpen.

De gekozen operator beïnvloedt ook het type. Als je begint met n = 7, levert n /= 2 de float 3.5 op. Als je opnieuw begint met n = 7, levert n //= 2 het gehele getal 3 op. Python heeft geen verhogingsoperator ++: x++ is ongeldig. Met ++x pas je tweemaal de unaire plus toe en werk je x niet bij; gebruik x += 1.

Volg één instructie tegelijk

Een uitvoeringstabel legt de waarden van variabelen vast na elke instructie. Schrijf één kolom per variabele en één rij per stap:

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

De uitvoer is 65 25. Door price te veranderen werd de eerdere vermenigvuldiging niet herhaald. De variabele total bevatte de berekende waarde 60; het was geen spreadsheetformule gekoppeld aan price. Pas door de latere bijwerking van de variabele zelf veranderde de waarde in 65.

Bij het volgen met de hand evalueer je de rechterkant met behulp van de rij direct erboven en werk je daarna de naam bij waaraan wordt toegekend. Laat alle andere kolommen onveranderd. Vergelijk je voorspelling met de werkelijke uitvoer van het programma.

Behoud beide waarden bij het verwisselen

Stel dat a = 1 en b = 2. De poging a = b gevolgd door b = a geeft 2 2. Door de eerste toekenning is de oorspronkelijke waarde van a niet meer via die naam bereikbaar, dus kopieert de tweede regel de nieuwe waarde terug.

Een tijdelijke variabele houdt de oorspronkelijke waarde beschikbaar:

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

Dit drukt 2 1 af. Je kunt ook a, b = b, a schrijven. Python evalueert beide waarden rechts voordat het een van beide namen links een waarde toekent, zodat beide oorspronkelijke waarden beschikbaar zijn voor de verwisseling. Volg de versie met de tijdelijke variabele als je precies wilt zien waar elke oorspronkelijke waarde behouden blijft.

Een expressie evalueert tot één waarde. Dat kan één letterlijke waarde zijn, een variabele of een combinatie zoals 2 + 3. De + is een operator; de waarden waarop die werkt, zijn de operanden.

Kies de operator

De rekenkundige operatoren van Python werken als volgt:

Schrijf vermenigvuldiging expliciet met *. Wiskundige notatie zoals 2x werkt niet als vermenigvuldiging in Python. Schrijf 2 * x of 2 * (x + 1). Met x = 1 probeert 2(x + 1) het gehele getal 2 aan te roepen alsof het een functie is en werpt het TypeError op.

De machtsoperator is **, niet ^. Zo is 7 ** 2 gelijk aan 49, terwijl 7 ^ 2 gelijk is aan 5 omdat het dakje een andere bewerking uitvoert. Een programma kan dus worden uitgevoerd terwijl het een resultaat berekent dat je niet bedoelde.

Voorspel zowel het type als het getal

Delen met / geeft bij gehele operanden een float, ook als de deling precies uitkomt: 6 / 2 is 3.0. Gebruik // voor een geheel aantal volledige groepen: 6 // 2 is 3.

Met twee gehele operanden geven optellen, aftrekken, vermenigvuldigen, gehele deling en rest gehele resultaten. Niet-negatieve gehele machten doen dat ook: 2 ** 10 geeft het exacte gehele getal 1024. Een negatieve exponent verandert dit: 2 ** -1 geeft de float 0.5.

Bij gewone rekenkundige bewerkingen met een geheel getal en een float gebruikt de berekening zwevendekommawaarden. 3 + 4.0 geeft 7.0; 7.0 // 2 geeft 3.0. Gehele deling beschrijft hoe het quotiënt wordt afgerond en belooft niet dat het type altijd int is.

Met een gebroken exponent kun je een wortel van een positief getal berekenen. 4 ** 0.5 geeft 2.0 en 2 ** 0.5 geeft ongeveer 1.4142135623730951.

Maak een berekening met benoemde waarden

Een auto rijdt 287 mijl op 10,25 gallon:

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

De deling berekent 28.0, dus de uitvoer is Miles per gallon: 28.0. De namen geven de grootheden aan en het afgedrukte label geeft de eenheid van het resultaat aan. Door 28.0 * 10.25 te vermenigvuldigen krijg je 287 mijl terug, als controle op de deling.

Een deler nul leidt bij /, // en % tot een fout. Zo werpt 10 / 0 een ZeroDivisionError op. Controleer bij die fout een variabele die als deler wordt gebruikt.

Spaties rond operatoren veranderen hun betekenis niet: 2+3 en 2 + 3 geven beide 5. Spaties rond = en de meeste operatoren maken de onderdelen gemakkelijker leesbaar. Ze kunnen een operator niet vervangen; 2 x betekent nog steeds geen vermenigvuldiging.

Python berekent een expressie niet zomaar van links naar rechts. Operatorprioriteit bepaalt welke bewerkingen eerst plaatsvinden. Met haakjes kun je een andere groepering kiezen of de bedoelde groepering duidelijk maken.

Pas de niveaus op volgorde toe

Gebruik voor de hier geïntroduceerde operatoren deze volgorde:

1. Expressies tussen haakjes.
2. Machten, **.
3. Unaire tekens, zoals de min in -x.
4. Vermenigvuldigingen en delingen: *, /, //, %.
5. Optellingen en aftrekkingen: +, -.

Evalueer voor 3 + 4 * 2 ** 2 eerst 2 ** 2 om 4 te krijgen. De expressie wordt 3 + 4 * 4. De vermenigvuldiging geeft 16 en de optelling geeft 19. Bij (3 + 4) * 2 ** 2 is de som tussen haakjes 7; de macht is 4; het product is 28.

Operatoren op het niveau van vermenigvuldigen en delen hebben gelijke prioriteit. Werk van links naar rechts: 8 / 2 * 4 betekent (8 / 2) * 4 en geeft 16.0. Vermenigvuldigen gaat niet vóór delen. Zo geeft 100 / 10 / 5 ook 2.0 en geeft 10 - 4 - 3 de waarde 3.

Let goed op bij machten en tekens

Herhaalde machtsverheffingen groeperen van rechts naar links. 2 ** 3 ** 2 betekent 2 ** (3 ** 2). Eerst geeft 3 ** 2 de waarde 9; daarna geeft 2 ** 9 de waarde 512. Groeperen vanaf links zou 64 geven, een ander resultaat.

Een vooropstaand minteken wordt toegepast na een daaropvolgende machtsverheffing: -2 ** 2 betekent -(2 ** 2) en geeft -4. In (-2) ** 2 maken haakjes van min twee het grondtal, zodat het resultaat 4 is. Een minteken na ** kan bij de exponent horen: 2 ** -1 geeft 0.5.

Zet de volledige groepering van een formule om

Voor een gemiddelde moet je beide waarden optellen voordat je door twee deelt:

average = (88 + 92) / 2

De som is 180, daarna geeft de deling 90.0. Zonder haakjes deelt 88 + 92 / 2 alleen 92 en geeft het 134.0.

Een breukstreep groepeert ook alles erboven en eronder. Een teller met a + b en een noemer met c + d worden (a + b) / (c + d). Als je een van beide paren haakjes weglaat, kan veranderen welke termen worden gedeeld.

Hetzelfde probleem zie je bij een temperatuurconversie:

celsius = (98.6 - 32) * 5 / 9

De aftrekking geeft 66.6, de vermenigvuldiging geeft 333.0 en de deling geeft 37.0. Zonder de groepering geeft 98.6 - 32 * 5 / 9 de waarde 80.82222222222222.

Gebruik de juiste groeperingstekens

Ronde haakjes groeperen een expressie. Vierkante en gekrulde haakjes hebben een andere betekenis in Python. Zo levert [2 + 3] * 4 de waarde [5, 5, 5, 5] op, niet 20.

Haakjes rond een bewerking die toch al eerst zou plaatsvinden, laten het resultaat onveranderd: (2 * 3) + 1 en 2 * 3 + 1 geven beide 7. Haakjes die de groepering veranderen, kunnen de waarde veranderen: 2 * (3 + 1) geeft 8. Voeg haakjes toe waar die de betekenis van de berekening duidelijker maken.

Gehele deling en rest beantwoorden twee samenhangende vragen: hoeveel volledige groepen passen erin en wat blijft er na die groepen over? Voor niet-negatieve gehele hoeveelheden is dit paar nuttig bij tijd, geld, verpakken en cijfers.

Bepaal quotiënt en rest samen

17 // 5 geeft 3, het aantal volledige groepen van vijf. 17 % 5 geeft 2, de hoeveelheid die overblijft. Met de twee resultaten kun je de oorspronkelijke hoeveelheid reconstrueren:

print((17 // 5) * 5 + 17 % 5)

De expressie geeft 17: drie groepen van vijf plus twee. Algemeen geldt voor gehele getallen en een deler ongelijk aan nul dat (a // b) * b + a % b gelijk is aan a. Gebruik die relatie om beide antwoorden te controleren.

Verdeel praktische hoeveelheden

Voor 135 minuten:

hours = 135 // 60
minutes = 135 % 60

Er zijn 2 volledige uren en 15 minuten over. De deler is 60 omdat één uur 60 minuten bevat. Delen met / geeft 2.25, wat uren met een breukdeel uitdrukt; het geeft de overgebleven minuten niet afzonderlijk.

Dezelfde structuur werkt met een andere groepsgrootte:

Het aantal dozen is het aantal volle dozen. Als je ook voor de overgebleven eieren een doos nodig hebt, is dat een andere vraag dan hoeveel volledige groepen erin passen.

Gebruik plaatswaarde en pariteit

Voor een positief geheel getal haalt delen door tien het laatste cijfer apart. 1234 % 10 geeft 4 en 1234 // 10 geeft 123. Door 123 * 10 + 4 te berekenen krijg je 1234 terug.

Voor elk geheel getal n is n % 2 gelijk aan 0 als het even is en aan 1 als het oneven is. Dit werkt ook voor negatieve getallen: -7 % 2 is 1. Voor gehele getallen en een positieve deler b ligt de rest in het bereik van 0 tot en met b - 1.

Begrijp delingen met negatieve getallen

Gehele deling rondt naar beneden af, richting min oneindig en niet richting nul. Omdat min zeven gedeeld door twee gelijk is aan -3,5, geeft -7 // 2 de waarde -4. De rest is dan 1, omdat -4 * 2 + 1 gelijk is aan -7.

Een rest ongelijk aan nul heeft het teken van de deler. Met een negatieve deler geeft 7 % -2 de waarde -1 en geeft 7 // -2 de waarde -4. Ook hiermee krijg je het oorspronkelijke getal terug: -4 * -2 + -1 is 7.

Dit verschilt van een quotiënt omzetten met int(): int(-7 / 2) geeft -3 omdat de conversie afkapt richting nul.

Beide operatoren accepteren ook floats. 7.5 // 2 is 3.0 en 7.5 % 2 is 1.5. Ze hebben dezelfde prioriteit als * en /, dus 5 * 3 + 17 % 5 geeft 17. De operator % betekent hier rest, geen procent: bereken 8 procent van een prijs met price * 0.08 of price * 8 / 100.

Het symbool van een operator is maar een deel van de betekenis. Python gebruikt ook de typen van de operanden. De operatoren + en * werken met strings, maar voeren daar tekstbewerkingen uit.

Voeg strings samen met plus

Concatenatie voegt een string toe aan het einde van een andere:

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

Deze regels drukken abcd, HelloAda en Hello Ada af. Concatenatie voegt zelf geen spatie toe. De spatie in het derde resultaat komt van het laatste teken van "Hello ".

Cijfertekens volgen dezelfde regel: "5" + "3" geeft de string "53". Zonder aanhalingstekens geeft 5 + 3 het gehele getal 8. Kies getalswaarden als je wilt rekenen en strings als je tekst bedoelt.

Herhaal een string met vermenigvuldiging

Een string vermenigvuldigd met een geheel getal herhaalt zijn tekens. "3" * 2 geeft "33", terwijl 3 * 2 de waarde 6 geeft. Het aantal herhalingen mag aan beide kanten staan: 3 * "ab" geeft "ababab". Nul keer herhalen geeft de lege string, dus "ab" * 0 is "".

Het aantal herhalingen moet een geheel getal zijn. "ab" * 2.5 werpt TypeError op, net als "ab" * "cd". Bij deze bewerking bestaat geen gebroken aantal kopieën.

Combineer bewerkingen op volgorde

Ook voor deze expressies heeft vermenigvuldigen een hogere prioriteit dan optellen:

print("-" * 4 + "Menu" + "-" * 4)

Eerst maakt elke herhaling "----". Daarna voegen de optellingen de drie strings samen tot ----Menu----. De volgorde van het samenvoegen behoudt de volgorde van hun tekens.

Voor een berekening die onderdeel wordt van een string:

print("7" + str(3 * 2))

De binnenste berekening geeft het gehele getal 6. str(6) maakt de string "6". Ten slotte levert concatenatie "76" op. Het resultaat is geen 13, omdat de laatste + twee strings als operanden heeft.

Los onverenigbare typen bewust op

"Age: " + 30 werpt TypeError op. Zet het gehele getal om voordat je de strings samenvoegt:

print("Age: " + str(30))

Dit levert Age: 30 op. Je kunt ook print("Age:", 30) gebruiken, dat de twee waarden met een spatie ertussen toont. Dat is het gedrag van print() met afzonderlijke argumenten, geen optelling van tekst.

Gehele getallen en floats kun je combineren in gewone rekenkundige bewerkingen: 2 * 3.0 geeft de float 6.0. Python zet een string met een getal bij + niet op dezelfde manier om in een getal. Als je met "30" moet rekenen, zet het dan eerst om naar een numeriek type.

Aftrekken werkt niet op deze stringoperanden. "10" - 3 werpt TypeError op, ook al zouden de tekens 10 een getal kunnen beschrijven. Om een expressie met verschillende typen te voorspellen, bepaal je het type van elke operand, evalueer je de bewerkingen met hogere prioriteit en controleer je de typen opnieuw bij de volgende bewerking. Een conversie kan veranderen welke regel de volgende operator volgt.

Typeconversie maakt een waarde van een ander type. Met de functies int(), float() en str() kun je de vorm kiezen die voor de volgende bewerking nodig is.

Bewaar het resultaat van de conversie

x = "42"
int(x)
print(type(x))

Dit drukt nog steeds <class 'str'> af. De conversie heeft een geheel getal gemaakt, maar geen toekenning heeft het bewaard. Schrijf x = int(x) om x naar dat gehele getal te laten verwijzen, of ken het toe aan een andere naam als je beide vormen wilt bewaren.

Kies een numerieke conversie

int() accepteert een string met een geheel getal, eventueel met een teken en spaties eromheen. int("42"), int("-12") en int(" 42 ") leveren 42, -12 en 42 op.

Een decimale punt in een string verhindert directe conversie naar een geheel getal. int("3.5") en int("4.0") werpen ValueError op; dat geldt ook voor int("abc") en int(""). Het feit dat 4,0 wiskundig een geheel getal is, maakt van "4.0" nog geen string in de vorm van een geheel getal.

float() accepteert decimale tekst en exponentnotatie. float("3.5") geeft 3.5, float("3") geeft 3.0 en float("1e3") geeft 1000.0. Het zet ook gehele getallen om: float(7) geeft 7.0. Een decimale komma mislukt: float("3,5") werpt ValueError op.

Kies bewust voor afkappen of afronden

Als je een float omzet naar int, wordt het breukdeel richting nul verwijderd. int(3.99) geeft 3 en int(-3.99) geeft -3. Het dichtstbijzijnde gehele getal wordt niet gekozen. Om decimale tekst om te zetten en daarna af te kappen, gebruik je int(float("3.5")), dat 3 geeft.

round() kiest een dichtstbijzijnde waarde. round(3.7) geeft het gehele getal 4; round(3.14159, 2) geeft de float 3.14. Het tweede argument bepaalt het aantal decimalen.

Als een waarde precies halverwege ligt, kiest Python de even buur: round(2.5) geeft 2, terwijl round(3.5) de waarde 4 geeft. Decimale breuken die als float zijn opgeslagen, liggen mogelijk niet precies halverwege. round(2.675, 2) geeft 2.67 vanwege de binaire representatie.

Deze bewerkingen beantwoorden verschillende vragen. Kies de bewerking die bij het bedoelde resultaat past, vooral als negatieve waarden mogelijk zijn.

Zet om in tekst om samen te voegen

str(42) levert "42" op en str(3.0) levert "3.0" op. Na de conversie voegt + hun tekens samen:

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

De uitvoer is 73, 10, 73 en 10.0. De conversies bepalen of de laatste + tekst of getallen ontvangt.

Een ValueError wijst op ongeschikte inhoud voor een conversie, zoals int("abc"). Een TypeError wijst op een bewerking die niet verenigbaar is met de operanden, zoals "5" + 5. Gebruik dat verschil om te bepalen of je de invoertekst moet onderzoeken of de bewerking moet veranderen.

print() toont waarden zodat iemand ze kan lezen. De argumenten zijn de waarden of expressies tussen de haakjes. Komma’s scheiden de argumenten; Python evalueert ze voordat het de resultaten toont.

Toon waarden met duidelijke labels

print("Total:", 5)
print(3 + 4)
print("3 + 4")

De regels tonen Total: 5, 7 en 3 + 4. Een label vertelt de lezer wat een waarde betekent. Een berekening zonder aanhalingstekens wordt geëvalueerd; een expressie tussen aanhalingstekens wordt als tekst getoond.

Standaard zet print() één spatie tussen argumenten en eindigt het met een nieuwe regel. Het zet elke waarde om voor weergave, zodat print("Total:", 5) tekst en een geheel getal kan combineren zonder expliciet str() te gebruiken.

Vergelijk dit met print("Total:" + str(5)), dat Total:5 afdrukt. Hier maakt de + één string voordat print() die ontvangt. Concatenatie voegt niet automatisch een spatie toe en er is maar één argument om te tonen.

Stel de scheidingstekst in

Het benoemde argument sep bepaalt welke tekst tussen argumenten komt:

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

De uitvoer is:

a-b
1, 2, 3
A12

Gebruik de naam sep. Als je print("a", "b", "-") schrijft, geef je een derde waarde mee, dus is het resultaat a b -. Een lege scheidingstekst voegt de getoonde argumenten direct samen; spaties die al binnen hun strings staan worden niet verwijderd.

Stel de regelafsluiting in

Het benoemde argument end verandert wat na de laatste waarde komt. Standaard is dat een nieuwe regel. Een lege afsluiting houdt de volgende uitvoer op dezelfde regel:

print("a", end="")
print("b")

Dit toont ab op één regel. Je kunt leestekens en een nieuwe regel combineren:

print("Hello,", "Ada", end="!\n")

De uitvoer is Hello, Ada! gevolgd door een nieuwe regel. sep geldt tussen argumenten binnen één aanroep; end geldt na het laatste argument van die aanroep. Ze bepalen verschillende plaatsen.

Voeg regeleinden toe en kies de weergegeven precisie

Een aanroep van print() zonder argumenten drukt een lege regel af. Een \n binnen een string maakt een regeleinde binnen die string, zoals in print("Line 1\nLine 2"). Herhaalde tekst kan een scheidingslijn vormen: print("=" * 20) toont twintig isgelijktekens.

Python toont een float in een korte vorm die de opgeslagen waarde weergeeft. print(1 / 3) toont 0.3333333333333333. Om een afgeronde waarde te tonen, bereken je die eerst binnen de aanroep: print(round(1 / 3, 2)) toont 0.33.

Afronden garandeert geen vast aantal zichtbare decimalen. round(2.50, 2) wordt weergegeven als 2.5, omdat de float nullen aan het einde niet als weergave-instructie opslaat. Gebruik bij het controleren van een programma de uitvoer precies zoals Python die produceert.

input() toont een invoervraag, wacht totdat iemand iets typt en op Enter drukt, en geeft daarna de getypte tekst terug als string zonder de Enter. Een kort, volledig programma leest de benodigde gegevens, verwerkt ze en toont een resultaat.

Lees tekst en zet getallen om

name = input("What is your name? ")
print("Hello", name)

De spatie aan het einde van de invoervraag scheidt het getypte antwoord van de vraag. De variabele slaat tekst als tekst op, ook als de gebruiker cijfers typt. Als je 30 invoert bij input(), levert dat "30" op, niet het gehele getal 30.

Kies een conversie voordat je gaat rekenen:

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

De binnenste input() wordt eerst uitgevoerd. Als de gebruiker 30 typt, geeft die "30" terug; int() zet dat om in 30; de toekenning bewaart het gehele getal. De optelling levert daarna 31 op.

Gebruik float(input(...)) als waarden met breukdelen zijn toegestaan. Een invoervraag moet aangeven wat voor antwoord wordt verwacht. Als je 2.5 of thirty invoert voor een conversie met int(), wordt ValueError opgeworpen. Ook 98,6 invoeren voor een conversie met float() mislukt; het decimale scheidingsteken moet een punt zijn.

Een ontbrekende conversie werpt niet altijd een fout op. Als twee aanroepen voor invoer 5 en 3 ontvangen, worden hun niet-omgezette waarden als strings opgeteld en leveren ze 53 op. Beide operanden hebben een type dat + ondersteunt, maar het is de verkeerde bewerking om hoeveelheden op te tellen.

Doorloop een volledige berekening

Het patroon invoer–verwerking–uitvoer maakt de hoofdstappen gemakkelijk te controleren:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

Bij invoer 98.6 leest het programma de float 98.6. Het trekt 32 af en krijgt 66.6, vermenigvuldigt met 5 en krijgt 333.0, en deelt door 9 en krijgt 37.0. De weergegeven regel is 98.6 °F is 37.0 °C. Invoer 50 wordt 50.0, dus is de regel 50.0 °F is 10.0 °C.

Hier is een programma met gehele gegevens:

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

Invoer 135 levert Hours: 2 Minutes: 15 op. De labels werken voor nul, één en grotere resultaten zonder dat de formulering verandert. De twee verwerkingsregels gebruiken hetzelfde oorspronkelijke totaal; een waarde toekennen aan hours haalt niets weg uit total_minutes.

Test gewone waarden en grenswaarden

Kies invoer met antwoorden die je met de hand kunt berekenen. Voor het temperatuurprogramma moet 32 als resultaat 0.0 °C opleveren en 212 als resultaat 100.0 °C. Test voor minuten 0, 59 en 60: hiermee controleer je de beginwaarde en de overgang van geen volledig uur naar één volledig uur.

Test ook een gebruikelijke waarde zoals 135. Vergelijk de exacte labels, spaties, numerieke resultaten en typen met je voorspelling. Als de code wordt uitgevoerd maar het resultaat verkeerd is, volg dan de opgeslagen waarden en de bewerkingsvolgorde. Als een conversie mislukt, onderzoek dan de getypte tekst en het type waarom je invoervraag vraagt.