Eerste stappen

In dit hoofdstuk zet je de eerste stappen in het programmeren. Na een korte inleiding op wat programmeren nu eigenlijk is, ga je aan de slag met het installeren van Python en een editor. Daarna leer je de basis van Python. Veel onderwerpen komen hier kort aan bod en worden in latere hoofdstukken verder uitgediept.

Leerdoelen

Aan het eind van dit hoofdstuk:

Begrijp je wat een programmeur doet
Begrijp je wat Python is
Heb je Python geïnstalleerd en verkend
Begrijp je de structuur van Python
Kun je werken met getallen
Begrijp je de gegevenstypen None en bool
Kun je werken met tekst
Begrijp je wat collecties zijn

Programmeren in Python

In deze paragraaf leer je wat programmeren is, wat Python is en ga je aan de slag met het installeren van Python en software om eenvoudig met Python te kunnen werken. Na deze voorbereidende stappen ga je direct aan de slag met een eerste verkenning van de programmeertaal.

Wat is programmeren?

Programmeren is het proces van het ontwikkelen van software door instructies te schrijven voor een computer om bepaalde taken uit te voeren. Deze instructies worden geschreven in een specifieke programmeertaal, zoals Python, Java of C++. Het doel van programmeren is om de computer te vertellen wat deze moet doen om problemen op te lossen, gegevens te verwerken, interactieve applicaties te maken en andere nuttige functies uit te voeren die het dagelijks leven en werk vereenvoudigen.

Programmeren is dus het schrijven van instructies voor een computer. Maar, als programmeur ben je niet heel de dag code aan het schrijven. Code schrijven is uiteraard een belangrijk onderdeel en in deze opleiding leer je ook met name dát. Als programmeur ben je echter ook bezig met andere zaken, zoals:

Het probleem helder krijgen
Overleggen met collega’s, klanten, of andere stakeholders^[1] (belanghebbenden)
Nadenken over de juiste benadering voor een oplossing
Prioriteren en inschatten hoeveel tijd een bepaalde implementatie gaat kosten
Code lezen
Documentatie schrijven
Andermans code beoordelen

Bepalen wélke code je wanneer schrijft en waarom, is een net zo belangrijk onderdeel van je werk als het daadwerkelijk schrijven van de code. Kijk er dus niet vreemd van op als je een paar uur verder bent en maar enkele regels code hebt geschreven. Vaak is daar heel wat aan vooraf gegaan!

Wat is Python?

Python is een populaire, krachtige en veelzijdige programmeertaal die eenvoudig te leren en te gebruiken is. Laat je echter niet misleiden door de eenvoud: de taal is zeer capabel!

Het is ontworpen met een focus op leesbaarheid en duidelijkheid van code, wat het schrijven en onderhouden van programma’s vergemakkelijkt. Python wordt gebruikt voor een breed scala aan toepassingen, zoals webontwikkeling, data-analyse, kunstmatige intelligentie en automatisering. Het is een open-source^[2] taal, wat betekent dat het vrij beschikbaar is en door iedereen kan worden aangepast.

Tot slot is het belangrijk om te weten dat Python een zogenaamde geïnterpreteerde taal is. Dat betekent dat de code direct wordt uitgevoerd en niet eerst wordt gecompileerd naar een uitvoerbaar bestand (bijvoorbeeld .exe). Het voordeel hiervan is dat je snel kunt experimenteren: schrijf een stukje code en voer het direct uit, je hebt direct resultaat. Zeker in de context van een opleiding - waar je nog veel moet leren - is dit handig. Het nadeel is dat het uiteindelijke programma vaak trager is dan gecompileerde talen. Tenzij je met processen te maken krijgt waar snelheid absoluut van belang is, is dit in de praktijk echter geen probleem. Python is nog steeds snel genoeg!

Wist je dat Python oorspronkelijk ontwikkeld is door een Nederlander? Het was Guido van Rossum die in 1989 begon met de ontwikkeling van Python. De naam verwijst naar Monty Python.

Python installeren

Om te kunnen werken met Python, dient het wel geïnstalleerd te zijn op je computer of laptop. Ga hiervoor naar python.org. Ga daar naar de downloadpagina en kies de laatste versie voor jouw OS. Voor Windows kun je het best de Windows installer (64 bit) kiezen.

Kies bij het installeren in Windows voor Add python.exe to PATH.

De Python-installer in Windows

Thonny installeren

Python code kun je in de shell^[3] uitvoeren. Je typt in je shell (De opdrachtprompt in Windows, in Linux en MacOS open je de terminal) python in, en je kunt aan de slag:

Python in de opdrachtprompt in Windows

Dit is handig om snel te experimenteren of te controleren hoe iets ook alweer werkt. Voor iets langere stukjes code wordt dit echter al snel onhandig.

In de praktijk plaats je code dan ook in een speciaal tekstbestand, eindigend op .py. Dit bestand voer je vervolgens uit met Python, zodat alle instructies in dat bestand worden uitgevoerd. Het werken met dergelijke bestanden doe je vaak met een zogenaamde Integrated Development Environment (IDE). Dit is software om op een eenvoudige manier met code te werken en bevat vaak vele hulpmiddelen die jouw leven als programmeur eenvoudiger maken.

Veelgebruikte IDEs zoals Pycharm en VSCode kunnen voor een beginnend programmeur nogal overweldigend zijn. In deze opleiding wordt daarom een IDE speciaal voor de beginnende Python programmeur gebruikt: Thonny.

Op de homepage van de website van Thonny kun je Thonny direct downloaden voor Windows, MacOS of Linux. Na het installeren en opstarten zie je het volgende:

Het beginscherm van Thonny, de IDE voor beginnende Python-programmeurs

Het onderste veld is een Python-shell, waarin je direct instructies kunt typen en uitvoeren. Het voordeel van Thonny is dat je ook in een bestand kunt werken, dit maakt experimenteren eenvoudiger. Maak een nieuw bestand aan via Bestand Nieuw. Geef het de naam voorbeeld.py (.py zal automatisch toegevoegd worden) en sla het op een logische plek op.

In dit nieuwe bestand kun je vervolgens instructies plaatsen. Door op F5 of op de groene Play knop te drukken, wordt het bestand uitgevoerd in de shell. Zo kun je eenvoudig aanpassingen doen en je bestand opnieuw uitvoeren. Als je een fout maakt, opent Thonny een scherm met tips.

Thonny in gebruik

Hier is de functie greetings gedefinieerd (in Werken met functies leer je wat een functie is).
Hier wordt de functie correct aangeroepen.
Hier wordt de functie onjuist aangeroepen, bij 6 zie je een toelichting op de fout die dit opwerpt als je het bestand uitvoert.
Met de Play knop (of F5) voer je het bestand uit.
De shell. Hier kun je zelf Python-code intypen, maar de resultaten (en foutmeldingen) van het uitvoeren van het bestand verschijnen ook hier.
Dit scherm verschijnt automatisch wanneer er een fout optreedt. Het bevat handige aanwijzingen over hoe de fout op te lossen.

Python verkennen

Nu je Python hebt geïnstalleerd en een korte kennismaking hebt gehad met de shell en Thonny, is het tijd om Python verder te verkennen.

Structuur van de code: inspringen

Een belangrijk kenmerk van Python is dat het inspringen van code onderdeel uitmaakt van de regels (syntax^[4]) van de taal, dit in tegenstelling tot vele andere programmeertalen.Een eenvoudig voorbeeld om dit te verduidelijken:

for i in range(5):
    x = i * 10
    print(x)

print("Nieuwe opdracht")

In dit voorbeeld zie je twee instructies. De eerste begint op regel één en eindigt op regel drie. De tweede bevindt zich op regel vijf. De eerste instructie lees je als volgt:

Met range(5) genereer je een reeks getallen van 0 tot en met 4
Met for itereer je over deze getallen
Elke iteratie (herhaling of ronde) sla je het getal op in de variabele i. De eerste ronde is i dus gelijk aan 0, de tweede ronde is i gelijk aan 1, etc.
Op regel twee vermenigvuldig je i met 10 en sla je het resultaat op in de variabele x
Op regel drie druk je x af naar je scherm

De eerste regel van de instructie eindigt met een dubbele punt, dit betekent dat daarna een zogenaamd blok volgt dat tot deze instructie behoort. Regel twee en drie springen in, waarmee je aangeeft dat ze tot het blok behoren dat begint op regel één. Regel vier is leeg en doet dus niets. Regel vijf springt níet meer in, waarmee dus een nieuwe instructie begint.

Volgens conventie springt elk niveau in met vier spaties. In de meeste IDEs kun je simpelweg op tab drukken en zal dit automatisch omgezet worden naar vier spaties. Ook in Thonny is dit het geval.

Opdracht 1: Inspringen

Kun je voorspellen wat er gebeurt als je de laatste regel wél laat inspringen? Wat gebeurt er als je het twee spaties laat inspringen in plaats van vier?

Klik om het antwoord te tonen

Als je de regel wel laat inspringen, zal elke ronde van de loop de zin "Nieuwe opdracht" geprint worden. De regel behoort dan namelijk tot het blok van de for-loop. Als je de regel met twee spaties laat inspringen in plaats van vier, zul je een foutmelding krijgen, omdat de mate van inspringen niet overeenkomt met de andere niveaus van inspringen (0 of 4 spaties).

Structuur van de code: commentaren

Je zag al dat de voorlaatste regel - een lege regel - niets doet. Blokken worden gedefinieerd op basis van inspringen, lege regels zijn dus niet per se nodig. Voor de leesbaarheid is het wel prettig om af en toe wat witruimte in te voegen.

Niet alleen lege regels worden door Python genegeerd. Je zag het al even voorbijkomen in de afbeeldingen van Thonny: opmerkingen. Zodra je een # plaatst, negeert Python alles erachter, tot aan de volgende regel. Je kunt dit gebruiken om korte toelichtingen voor jezelf of voor je collega’s te plaatsen.

# Deze functie ontvangt één argument: de naam van de persoon (str)
def greet(name):
    """
    Dit is een docstring, daarover volgt in een later hoofdstuk meer.
    """

    # print("Hello")
    print(f"Hello, {name}")  # Print de begroeting met naam

    """
    Soms heb je iets meer ruimte nodig voor een wat langer 
    commentaar. Je kunt dit doen door te beginnen en 
    eindigen met drie (dubbele) aanhalingstekens.

    Je kunt hierin plaatsen wat je wilt, ook code:

    print(f"Hello, {name}")

    Dit wordt allemaal genegeerd door Python.
    """

In dit voorbeeld zie je de verschillende mogelijkheden om commentaren te plaatsen. Een commentaar hoeft dus niet per se aan het begin van de regel te beginnen. De conventie is dat wanneer je een commentaar áchter een stuk code plaatst - zoals op regel acht - je er twee spaties tussen laat.

Op regel zeven zie je dat er een # voor een instructie is geplaatst. Deze instructie wordt daardoor niet door Python uitgevoerd.

Gegevenstypen

Nu je helder hebt hoe je Python-code structureert, is het tijd om daadwerkelijk kennis te gaan maken met de taal. Programmeren is werken met gegevens en in Python heeft elk gegeven een bepaald type. Overigens geldt dit voor veel programmeertalen.

Een gegevenstype bepaalt wat je met het gegeven kunt doen.

In het dagelijkse leven kom je dit ook tegen. Heb je twee cijfers, dan kun je ze vermenigvuldigen. Heb je twee woorden, dan kan dat niet. Maar de woorden kun je dan wel in de verleden tijd zetten.

In tegenstelling tot veel andere talen voert Python geen typecontrole uit voordat de code wordt uitgevoerd. Neem bijvoorbeeld onderstaande stukje code:

x = "test"
print(x/2)

Voer je dit uit in Thonny, dan zul je een foutmelding krijgen. De variabele x is hier van het gegevenstype str (string, ofwel tekst). Op regel twee probeer je x te delen door twee: x/2. In Python kun je tekst niet delen, en dus krijg je een foutmelding bij het uitvoeren van de code. Dit laatste is belangrijk.

Je kunt de code rustig laten staan in je programma, en Python zal er niet over klagen. Pas wanneer dit stukje code wordt uitgevoerd komt de foutmelding. In veel andere programmeertalen, met name de gecompileerde talen, worden dergelijke fouten al opgeworpen vóórdat het programma in gebruik wordt genomen. Zo worden vele bugs^[5] al eerder opgemerkt.

De laatste jaren is er wel meer aandacht voor controleren van gegevenstypen en worden hulpmiddelen hiervoor in de taal ingebouwd. In deze opleiding wordt hier verder geen aandacht aan besteed. Wil je hier (later) meer over weten, kijk dan eens naar mypy (www.mypy-lang.org/), een veelgebruikt hulpmiddel bij het controleren van gegevenstypen.

In deze paragraaf leer je over een zestal gegevenstypen:

int
float
bool
None
str
collecties

Werken met getallen

Tijdens het programmeren zul je veel te maken krijgen met getallen. Python heeft hiervoor verschillende ingebouwde typen, waarvan de belangrijkste int en float zijn.

int

Het type int (kort voor integer) gebruik je om met gehele getallen te werken. De bekende operatoren^[6] zijn van toepassing:

print(10+5)
print(10*5)
print(10-5)
print(-5-5)
print(10**2)
print(10/2)

Zoals je ziet in de code hierboven zijn integers niet alleen voorbehouden aan positieve getallen.

Opdracht 2: Operatoren

Kun je achterhalen wat ** doet op regel vijf? En wat valt je op aan de uitkomst van regel zes?

Klik om het antwoord te tonen

Twee asteriksen is de operator om machten te verheffen. 10**2 betekent dus tien tot de macht twee, ofwel 10 in het kwadraat. 10**3 betekent tien tot de macht drie.

Op regel zes valt op dat je twee integers deelt, maar de uitkomst is een float. Delen met / levert altijd een float op.

Een int kun je direct noteren, zoals hierboven. Maar soms heb je ook een ander gegevenstype in je code, waarvan je een int wilt maken.

int("5")  # Van str naar int
int(3.5)  # Van float naar int

Opdracht 3: int()

Voer bovenstaande eens in Thonny in, en bekijk wat het resultaat is. Wat gebeurt er als je int("Hallo") invoert? En wat bij int(3.6)?

Klik om het antwoord te tonen

int("5") levert 5 op. int(3.5) levert 3 op. int("Hallo") levert een fout op, omdat Python niet weet hoe je van een woord een integer moet maken. int(3.6) levert, wellicht onverwacht, 3 op. Als je int() gebruikt om van een float een integer te maken, neemt hij het gehele getal van voor de decimaal. Er wordt dus niet afgerond.

float

Het type float (kort voor floating point) gebruik je om niet-gehele getallen mee aan te duiden. Een float maak je door een getal met een decimaal te noteren. Let hierbij op dat je een punt gebruikt in plaats van een komma, zoals wij gewend zijn. Dus noteer 3.14 en niet 3,14.

Net als bij int kun je de verschillende operatoren gebruiken:

print(10.5+5)
print(10.5*5)
print(10.5-5)
print(-5.5-5)
print(10.5**2)
print(10.5/2)

En kun je andere gegevenstypen omzetten naar float:

float("5")  # Van str naar float
float(3)  # Van int naar float

Vaak volstaat het werken met float als je werkt met niet-gehele getallen. Maar er gaat een wereld schuil achter wat eigenlijk een floating point is. Belangrijk om te onthouden is dat het niet een decimaal getal is en dat het niet precies is. Kijk maar eens naar de volgende optelsom:

print(0.1 + 0.1 + 0.1)
# 0.30000000000000004

Maakt de precisie wel uit, dan kun je beter met Decimal werken. Zie de documentatie van Python voor meer.

Werken met lege waarden (None) en Waar/Niet-waar (bool)

Het werken met getallen zoals hierboven zal redelijk intuïtief aanvoelen, in het dagelijkse leven werk je er geregeld mee. Iets minder intuïtief zijn misschien de gegevenstypen None en bool.

Lege waarden

None betekent letterlijk Niets, en is een zogenaamde null waarde, een lege waarde. Zie het als een lege snoeppot:

snoeppot = None  # Een lege snoeppot
print(type(snoeppot))

snoeppot = 100  # Een goedgevulde snoeppot
print(type(snoeppot))

print(snoeppot is None)

Je maakt een variabele snoeppot en wijst de waarde None toe. De waarde van snoeppot heeft dus het gegevenstype None. Daarna 'vul' je de snoeppot en is het gegevenstype int geworden. Met de operator is kun je controleren of een object de waarde None heeft.

Opdracht 4: Waar of niet waar?

Voer bovenstaand voorbeeld in Thonny in.

Wat is het resultaat van de laatste regel?
Wat is het resultaat als de laatste regel vervangt door print(snoeppot is not None)?

Klik om het antwoord te tonen

print(snoeppot is None) levert False op. snoeppot is inmiddels niet meer None, maar een int. print(snoeppot is not None) levert True op. Met not draai je de toets om.

In de code zie je het gebruik van type(). Hiermee kun je altijd het type van een object achterhalen. Regel twee geeft als resultaat <class 'NoneType'> terug, en regel vijf <class 'int'>. Dit lijkt een beetje cryptisch, maar je ziet al snel dat het de gegevenstypen None en int betreft. Wat een class is, leer je in een later hoofdstuk.

None is altijd één object in Python. Voer het volgende maar eens uit:

x = None
y = None

print(id(None))
print(id(x))
print(id(y))

print(x is None)

Met id() haal je het unieke ID op van een object (zie het als het unieke adres in het geheugen van de computer).

Met is vergelijk je het id van twee objecten, en daarom levert x is None ook True op.

Waar of niet waar?

Als je bovenstaande opdracht hebt uitgevoerd kreeg je als het goed is eerst het resultaat False en de tweede keer het resultaat True. Dit zijn waarden van het type bool (kort voor boolean). Het type bool zul je veel tegenkomen tijdens het programmeren, omdat je het zult gebruiken om het verloop van je programma te bepalen: als x waar is, voer dan y uit, als x niet waar is, voer dan z uit.

Met de ingebouwde functie bool() kun je andere gegevenstypen omzetten naar een bool.

print(bool(0))  # False
print(bool(1))  # True
print(bool(38))  # True
print(bool(0.0))  # False
print(bool(0.1))  # True

print(bool(""))  # False
print(bool("Test"))  # True

Bij getallen zijn alleen 0 (zowel bij int als float) False. Bij tekst zijn enkel lege strings False.

Opdracht 5: "False"

Wat is het resultaat van bool("False")?

Klik om het antwoord te tonen

bool("False") levert True op. Alleen een lege str zal False opleveren.

De bool is een subtype van int, met maar twee waardes: True (1) en False (0). Net als bij None is van elke waarde ook maar één object.

Relationele operatoren

Booleans zul je veel gebruiken om het programmaverloop te bepalen. Maar hoe werkt dat? Een belangrijk gegeven hierin is dat relationele operatoren een bool produceren. Relationele operatoren gebruik je om verschillende objecten met elkaar te vergelijken.

De relationele operatoren zijn:

`==`	Zijn twee objecten gelijkwaardig aan elkaar?
`!=`	Zijn twee objecten niet gelijkwaardig?
`<`	Is het ene object kleiner dan het andere?
`>`	Is het ene object groter dan het andere?
`<=`	Is het ene object kleiner dan of gelijk aan het andere?
`>=`	Is het ene object groter dan of gelijk aan het andere?

In het volgende hoofdstuk leer je uitgebreider over hoe je relationele operatoren gebruikt om het programmaverloop te bepalen, maar hierbij alvast een kort voorbeeldje:

x = 20  # Wijs de waarde 20 toe aan de variabele x

if x > 20:
    print("X is groter dan 20!")
else:
    print("X is 20 of kleiner!")

Opdracht 6: Als x groter is dan 20

Waarschijnlijk kun je de uitkomst wel voorspellen. Probeer het eens in Thonny om te kijken of je het goed had. Wat gebeurt er als je > op regel drie vervangt door >=?

Klik om het antwoord te tonen

In de oorspronkelijke code is het resultaat "x is 20 of kleiner!". Dit omdat je met > toetst of x groter is dan 20, wat niet het geval is. Vervang je > door >= - groter dan of gelijk aan - dan zal het resultaat "x is groter dan 20!" zijn.

Misschien weet je van wiskunde nog wel dat = werd gebruikt als symbool voor gelijkheid. Bijvoorbeeld:

x = y + 5

Dit wil zeggen: x is gelijk aan y + 5. In Python (en vele andere programmeertalen) gebruik je een dubbel is-teken (==) om op gelijkheid te toetsen. Het enkele is-teken (=), zoals hierboven, is geen toets op gelijkheid, maar een toewijzing. In dit geval wijs je de waarde y + 5 toe aan de variabele x. In het volgende hoofdstuk leer je meer over variabelen.

Werken met tekst (strings)

In de voorgaande lesstof ben je al een aantal keren het gegevenstype str tegengekomen (kort voor string). Het (Engelse) woord string komt van het feit dat je meerdere tekens (karakters) aan elkaar 'rijgt'. Het type str is het gegevenstype voor tekst, specifiek Unicode-codepunten. Unicode is een standaard om karakters in digitale vorm aan te duiden. Zo is is de letter "A" altijd U+0041 (op Windows, Linux, MacOS). Gelukkig hoef je zelden direct met Unicode te werken, Python handelt dat voor je af.

Strings maken

Er zijn verschillende manieren om een string te maken. Vaak zul je dit simpelweg doen door aanhalingstekens te zetten rondom de tekst. Dit mogen enkele of dubbele aanhalingstekens zijn, als je maar consequent bent!

a = "Dit is een string."
b = 'Dit is ook een string.'
c = "Dit zal niet werken'
d = "Maar dit kan wel: 'Hallo, wereld!'."
e = 'Je kunt ook cijfers (1) of tekens (&) gebruiken.'

Je ziet dat als je een string begint met dubbele aanhalingstekens, je er ook mee moet eindigen. In de string kun je dan wel enkele aanhalingstekens gebruiken, deze zijn dan simpelweg onderdeel van de string.

Een andere manier om een string te maken is met de ingebouwde functie str().

f = str(1)  # "1"
g = str(3.1415)  # "3.1415"

Opdracht 7: str()

Wat is het resultaat van de volgende instructie? str(hallo)
Wat is het resultaat van de volgende code? hallo = 1 print(hallo)

Klik om het antwoord te tonen

str(hallo) levert een foutmelding op, omdat de variabele hallo niet gedefinieerd is. Definieer je hallo, dan print het de waarde van de variabele, in dit geval dus 1.

Meerdere regels

Tot nu toe waren onze teksten vrij kort, maar dit zal in de praktijk niet altijd zo zijn. Om een langere tekst leesbaar te maken, kun je newlines (nieuwe regels) gebruiken. Dit kan op twee manieren. De eerste manier is door te werken met een drietal aanhalingstekens (dubbel of enkel):

gedicht = """
Strings in Python code,
Characters in a sequence,
Words and worlds unfold.
"""

Probeer dit eens in Thonny in te voeren en kijk hoe het wordt weergegeven.

Als je print(gedicht) hebt gebruikt, zag je een net stukje tekst, verspreid over meerdere regels. Heb je echter gedicht direct in de shell ingetypt, dan zag je een aantal keer \n terug in de string. Dit is het escapeteken voor een nieuwe regel (newline).

Een haiku met en zonder print()

Wanneer je de driedubbele aanhalingstekens gebruikt, voegt Python zelf de \n toe waar nodig. Dit kun je ook zelf doen:

i = "Kun je raden\nwaar de newline komt?"

Misschien vind je dit wat rommelig en ben je geneigd spaties te zetten rondom de \n:

j = "Kun je raden \n waar de newline komt?"

Dat oogt beter, maar probeer eens in Thonny hoe beide gevallen eruit zien als je print() gebruikt. Misschien niet wat je wilt!

De \n is niet het enige escapeteken. Je kunt bijvoorbeeld ook tabs invoegen (\t) of Unicode (\u0041). Escapetekens beginnen altijd met een backslash (\). Dit kun je ook gebruiken om tekens met betekenis (zoals aanhalingstekens of de backslash zelf) te escapen:

k = "Dit is een \" in een tekst."
l = "Dit is een \\ in een tekst."

Gebruik steeds print() om te kijken hoe het eruit komt te zien.

Raw string

Soms heb je stukken tekst met veel speciale karakters, die je allemaal wilt escapen. Een veel voorkomend geval zijn bestandspaden in Windows. Een bestandspad bestaat onder andere uit backslashes, die je allemaal moet escapen. In zulke gevallen kun je ook raw-strings gebruiken, door de kleine letter 'r' voor de tekst te zetten:

m = r"C:\Users\Erwin\Documents\Python"

Voer dit in Thonny in, en bekijk het resultaat met en zonder print().

F-strings

Vaak wil je een tekst opbouwen op basis van gegevens in je programma. Een heel kort voorbeeld zag je al aan het begin van het hoofdstuk:

def greet(name):
    print(f"Hello, {name}!")

Dit is een zogenaamde functie (waar je later meer over leert). Je kunt de functie aanroepen met een tekst (een naam), en de functie zal vervolgens de naam in de groet invoegen, en dit naar het scherm printen.

De variabele (name) wordt gebruikt om een stuk tekst op te bouwen. Dit doe je met een zogenaamde f-string (kort voor formatted string literal). Je doet dit door een kleine letter f voor je zin te plaatsen, en met accolades aan te geven waar de variabele (of elke andere expressie) moet komen.

Er zijn nog andere manieren om teksten te formatteren, maar de f-strings zijn flexibel en eenvoudig te lezen.

Operatoren

Bij de getallen ben je al een aantal operatoren^[7] tegengekomen, waarmee je kunt rekenen.

Misschien verrassend, maar een aantal van deze operatoren werken óók bij strings.De belangrijkste zijn de + (concatenatie) en * (herhaling).

zeg_eens = 10*"a"
woorden = 10*"Python "
c_kwadraat = "a-kwadraat " + "plus " + "b-kwadraat"

Collecties

Tot nu toe heb je geleerd over gegevenstypen die op zichzelf staan, zoals int, float, None en bool. Het getal 1 is een int, maar wat als je een reeks aan getallen hebt? Dat zijn collecties. Er zijn een aantal collecties in Python:

Reeksen
Sets
Dictionaries

In deze paragraaf worden ze kort behandeld, in latere hoofdstukken komen ze uitgebreider aan bod.

Reeksen

Een reeks (sequence) is een collectie elementen, waarbij elk element een uniek nummer (integer) heeft, op basis waarvan je het element uit de reeks kunt ophalen.Dat is een hele mond vol!Een voorbeeld maakt het duidelijker:

mijn_lijst = [1, 5, 3, 2]
print(mijn_lijst[2])  # 3

In dit voorbeeld zie je een list (lijst).Je ziet dat je bij een reeks een bepaald element kunt oproepen met de index van dat element door vierkante haakjes met het indexnummer achter de reeks te plaatsen. mijn_lijst[2] betekent dus: haal het element met index 2 op uit de reeks mijn_lijst.

Als je nog niet eerder hebt geprogrammeerd, had je waarschijnlijk verwacht dat mijn_lijst[2] in dit geval 5 zou teruggeven, want die staat op de tweede plaats.Maar het resultaat is 3.Hoe kan dat?

Indexen in reeksen beginnen in Python (en in vele andere programmeertalen) bij 0, en niet bij 1. Het eerste element in een reeks heeft dus index 0. Het tweede element heeft index 1, enzovoorts.

Tabel 1. Elementen in de lijst `mijn_lijst`
Element	1	5	3	2
Plaats	1	2	3	4
Index	0	1	2	3
Ophalen	mijn_lijst[0]	mijn_lijst[1]	mijn_lijst[2]	mijn_lijst[3]

Dit benaderen van elementen door indexering geldt voor alle reeksen in Python. Andere operaties die voor alle reeksen gelden zijn:

Controleren of een element zich in de reeks bevindt met element in mijn_reeks (of not in).
Reeksen bij elkaar voegen met mijn_reeks + mijn_reeks
Reeksen vermenigvuldigen met mijn_reeks * 3
Meerdere elementen ophalen op basis van index met mijn_reeks[2:5] (slicing)
De lengte van de reeks bepalen met len(mijn_reeks)
Het grootste element uit de reeks halen met max(mijn_reeks)
Het kleinste element uit de reeks halen met min(mijn_reeks)
De index ophalen van een element uit een reeks met mijn_reeks.index(element)
Het aantal keer dat een element voorkomt in een reeks met mijn_reeks.count(element)

De twee belangrijkste reeksen zijn de list en de tuple. Beiden zijn erg vergelijkbaar, het grote verschil is dat de tuple niet aanpasbaar is. Het ondersteunt dus alle hierboven beschreven methodes, maar geen methodes om bijvoorbeeld elementen aan de tuple toe te voegen.

mijn_lijst = [1, 5, 3, 2]  # Maak een lijst
mijn_lijst.append(7)  # Voeg een element toe
mijn_lijst[0] = 9  # Vervang het eerste element
print(mijn_lijst)

mijn_tuple = (1, 5, 3, 2)  # Maak een tuple
mijn_tuple.append(7)  # Geeft een fout
mijn_tuple[0] = 9  # Geeft een fout

Naast lists en tuples is nóg een type reeks, die ook al aan de orde is geweest. Namelijk de string. De str is een speciaal type reeks. Net als de tuple is een str niet-muteerbaar. Omdat een str een reeks is, werkt indexeren hier ook.

tekst = "Hello, world"
print(tekst[7])  # "w"
print(tekst[0:5])  # "Hello"

De reeksen list en tuple kunnen allerlei elementen bevatten. De elementen in een reeks hoeven ook niet van hetzelfde type te zijn. Ook kunnen elementen vaker voorkomen. Onderstaande zijn dus geldige lijsten:

mijn_lijst = [1, "twee", 3, 1, 2, "drie"]
mijn_tweede_lijst = [mijn_lijst, 4, "vijf", 5, 5]

Een element in een lijst kan dus zelf ook weer een lijst zijn!

Opdracht 8: lijsten

Voer bovenstaande lijsten eens in Thonny in en druk ze af met print(). Hoe ziet mijn_tweede_lijst eruit?

Klik om het antwoord te tonen

Het resultaat is:

[[1, 'twee', 3, 1, 2, 'drie'], 4, 'vijf', 5, 5]

De gehele eerste lijst wordt dus ook geprint.

Een reeks is een collectie die meerdere elementen kan bevatten. Ze werken op basis van index.

Er zijn een aantal methodes die op alle reeksen werken^[8], zoals indexering, slicing en het ophalen van de lengte van de reeks.

Sets

Vergelijkbaar met reeksen zijn sets. Het belangrijkste verschil is echter dat een set geen dubbele waarden kan bevatten. Een set maak je aan met accolades ({1, 2, 3}) of de ingebouwde functie set(). NB: een lege set aanmaken kan alleen met set(), {} gebruik je om een lege dict aan te maken (zie hierna).

a = {1, 2, 3}
print(a)

b = {1, 1, 1}
print(b)

Sets zijn geen reeksen, en elementen ophalen uit een set werkt dan ook anders. In een Werken met sets leer je hier meer over.

Opdracht 9: uniek

Wat zie je als je de laatste regel uitvoert? Wat gebeurt er als je het volgende invoert?

mijn_lijst = [1, 1, 2, 2, 3, 3]
mijn_set = set(mijn_lijst)

Klik om het antwoord te tonen

Als je de laatste regel uitvoert, zie je {1}, een set met één waarde. Een set kan enkel unieke waarden bevatten. Alle dubbele waarden worden dus verwijderd.

Voer je de gevraagde code uit, dan zie je dat je met set() een set van een list kunt maken, en dat alle dubbele waarden uit de list verwijderd worden. Het resultaat is dus {1, 2, 3}.

Dictionaries

De laatste type collectie zijn de mappings. In deze cursus zul je alleen de woordenboeken gebruiken. In Python noem je dit een dict, kort voor dictionary. Een dict is een collectie waarbij je de elementen niet ophaalt op basis van een index, maar op basis van een sleutel. Je wijst de elementen ook altijd toe aan een sleutel.

Een dict maak je door sleutel-waarden paren tussen accolades te plaatsen, en de sleutel en waarden te scheiden door een dubbele punt. Sleutel-waarden paren scheidt je door een komma.

person = {
    "name": "Erwin",
    "role": "Author",
    "age": 38,
    "languages": ["Dutch", "Python"]
}

Het ophalen van een element lijkt hetzelfde als bij reeksen, alleen gebruik je nu de sleutel in plaats van de index (een integer).

print(person)  # De hele dict
print(person["name"])  # De waarde behorende bij sleutel "name"
print(person["languages"])  # De waarde behorende bij sleutel "languages"

In dit voorbeeld zie je dat de sleutel-waarden paren steeds op een nieuwe regel beginnen. Dit hoeft niet, maar maakt het wel leesbaarder. Hetzelfde principe kun je ook voor reeksen gebruiken:

a = ["a",
     "b",
     "c",
     ]

Voor een korte lijst voegt dit niet zoveel toe, maar voor langere lijsten (of als de elementen langer zijn) wordt het al snel prettiger om te lezen.

Een dict is muteerbaar. Je kunt dus elementen toevoegen, of elementen wijzigen.

person["languages"] = ["Dutch", "English", "Python"]
person["hair"] = "brown"
print(person)

For-lussen

Een kenmerk van alle collecties is, is dat ze itereerbaar^[9] zijn. Ofwel: je kunt elk element één voor één uit de collectie ophalen en daar iets mee doen. De meest gebruikte structuur hiervoor is de for-loop.

fruitsoorten = ["appel", "banaan", "druif", "mango", ]

for fruit in fruitsoorten:
    print(fruit)

Bij tuples en sets werkt het vergelijkbaar. Woordenboeken werken net iets anders, omdat ze niet op basis van een index werken, maar op basis van sleutels. Itereren met een for-loop zal enkel de sleutel teruggeven.

# Fruitsoorten met het aantal dat je in huis hebt
fruitsoorten = {
    "appel": 10,
    "banaan": 5,
    "druif": 20,
    "mango": 0
}

for fruit in fruitsoorten:
    print(fruit, fruitsoorten[fruit])

Itereren over een set is in een belangrijk opzicht anders dan bij een list en een tuple. Maak je een list of een tuple aan, dan blijft de volgorde van aanmaken altijd gehandhaafd. Dus maak je een list ["a", "b", "c"], dan is "a" altijd het eerste element.

Maak je echter de set {"a", "b", "c"} en je roept deze later op, dan is het eerste element misschien wel "b", de volgorde kan dus wijzigen. Itereer je over een set, dan kun je er dus niet van op aan dat de volgorde hetzelfde is als toen je de set maakte.

Opdracht 10: for-loop dict

Kun je voorspellen wat het resultaat is?

Klik om het antwoord te tonen

Het resultaat is:

appel 10
banaan 5
druif 20
mango 0

Met de for-loop itereer je over alle sleutels van de dict. Die print je eerst af, daarachter gebruik je de sleutel om de waarde op te halen uit de dict en ook te printen.

1. Een stakeholder is een persoon, groep of organisatie die direct of indirect belang heeft bij, invloed heeft op, of wordt beïnvloed door een bepaald project, proces of beslissing.

2. Open-Source betekent dat de broncode van een softwareproduct vrij beschikbaar is voor het publiek om te bekijken, te wijzigen en te distribueren.

3. De Python shell is een interactieve omgeving waarin Python code direct kan worden uitgevoerd.

4. 'Syntax' in de context van programmeren verwijst naar de regels die bepalen hoe programma’s in een bepaalde programmeertaal geschreven moeten worden. Het is een set van regels en conventies die bepaalt hoe broncode moet worden geschreven en georganiseerd.

5. Een bug is een fout in een softwareprogramma die leidt tot onverwacht gedrag, verkeerde resultaten of problemen. Deze fouten kunnen voortkomen uit onjuiste code, onvolledige logica, misinterpretatie van specificaties of onbedoelde interacties tussen verschillende componenten.

6. Een operator is in Python een woord of symbool dat een operatie uitvoert op één of meer waarden of variabelen. Een voorbeeld is de plus-operator (`+`), welke twee getallen optelt of twee teksten samenvoegt. Een ander voorbeeld zijn de relationele- of vergelijkingsoperators, zoals `<` (kleiner dan) en `==` (gelijk aan). Hiermee vergelijk je twee objecten.

7. Een operator is in Python een woord of symbool dat een operatie uitvoert op één of meer waarden of variabelen. Een voorbeeld is de plus-operator (`+`), welke twee getallen optelt of twee teksten samenvoegt. Een ander voorbeeld zijn de relationele- of vergelijkingsoperators, zoals `<` (kleiner dan) en `==` (gelijk aan). Hiermee vergelijk je twee objecten.

8. Eigenlijk niet _alle_ reeksen, er is namelijk ook nog `range()`, die ondersteunt bijvoorbeeld niet het samenvoegen met `+`. Over `range()` leer je later nog meer.

9. Itereren is het één voor één doorlopen van items in een collectie (zoals een list, tuple, dictionary)