Programmeren in Python: functies, klassen en dictionaries!

Programmeren is naast een handige vaardigheid ook gewoon erg leuk. Een tijdje terug schreef ik daarom al over leren programmeren in Python. Nu is het tijd om weer een stukje verder te gaan! Ga mee op onderzoek uit naar de verdere mogelijkheden die de taal Python te bieden heeft. Zo vertel ik je graag wat meer over functies, klassen en dictionaries.

Als je nog niet bekend met de programmeertaal Python, dan raad ik je aan om eerst deel 1 te lezen. Daar installeerden we Python en maakten we kennis met basisfunctionaliteiten zoals variabelen, loops en if-statements. Maar met deze taal kun je veel meer! Laten we beginnen met functies.

Functies in Python

Tot nu toe hebben we onze code steeds aaneengesloten geschreven in één lang bestand. Je kunt je voorstellen dat bij grote applicaties dat niet ideaal is; je wilt stukjes code kunnen hergebruiken op verschillende plekken. Functies zijn hier uitermate geschikt voor. Dit is een voorbeeld van een simpele functie:

>>> def groet(naam):
...     return f'Hallo, {naam}'

Hierboven maken we met def een functie aan. Met haakjes geven we aan dat de functie één argument heeft. Daar komen we zo op terug. Net zoals bij loops en if-statements springen we vervolgens iets in en kunnen we meer code schrijven. De functie bevat nu een enkele regel, die gebruikmaakt van het return-woord. Dat geeft aan dat de waarde die daarop volgt we willen beschouwen als het resultaat van de functie. Op zichzelf doet dit stukje code helemaal niets, want een functie moet je actief aanroepen. Dat doe je zo:

>>> groet('Mark')
'Hallo, Mark'

We roepen de functie aan met een naam als argument, en de functie stuurt een string terug die deze naam groet. Elke functie is een algoritme: je hebt een paar argumenten (de input), doet daar wat mee binnen de functie volgens wat logica en stuurt wat terug (de output). Functies hoef je maar een keer te schrijven en kun je daarna zo vaak gebruiken als je wilt. Maar met die argumenten kunnen we nog veel meer. Zo kan een functie er vele hebben:

>>> def weer(datum, tijd, plaats='Enschede'):

Die functie krijgt drie argumenten: een datum, tijd en plaats. Met de plaats is echter nog iets geks aan de hand: daar staat een is-gelijk-teken en dan een string. Het betreft een handige feature van Python: als je bij het aanroepen dat laatste argument niet meegeeft, gebruikt hij Enschede als standaardwaarde. Onderstaand is de waarde van het plaats-argument de eerste twee keer dus Enschede, en de laatste keer Hengelo:

>>> weer('01-06-2021', '09:00', plaats='Enschede')
>>> weer('01-06-2021', '09:00')
>>> weer('01-06-2021', '09:00', plaats='Hengelo')

Het argument plaats wordt in dit geval weleens een named argument of keyword argument genoemd.

Onbepaalde argumenten

Als laatste handigheid bij functies kunnen we nog eens kijken naar functies met onbepaalde argumenten. Stel je een functie voor die drankjes in een bar kan bestellen namens een persoon:

>>> def bestel_drankjes(persoon, *drankjes, vip=False, **opties):

En laten we zeggen dat ik wat bestel door de functie aan te roepen:

>>> bestel_drankjes(  # je kunt lange aanroepen opbreken
...     'Mark',
...     'cola', 'fanta', 'cola',
...     citroen=False,
... )

Daar gebeurt een heleboel. Ik heb daarom de regel even opgebroken, zodat het gemakkelijker te lezen valt. Binnen die functie kun je nu de volgende argumenten gebruiken:

• persoon | Een normaal argument, de persoon die de bestelling plaatst.
• drankjes | De asterisk (*) geeft aan dat we alle andere argumenten graag op willen vangen in een variabele die zo heet. Die bevat dus nu een lijst met tweemaal cola en eenmaal Fanta.
• vip | Deze staat op False, omdat dat de standaardwaarde is. Als ik een VIP-bestelling had willen plaatsen, had ik vip=True mee kunnen geven.
• opties | Dit is een dictionary met alle overige keyword-argumenten erin. In dit geval geef ik aan dat ik geen citroen in mijn drankjes wil!

Dictionaries in Python

Je zag het net al heel kort bij het opties-argument van de laatste voorbeeld-functie: een dictionary. Maar wat is dat nu? Feitelijk is een dictionary steeds een link tussen een sleutel en een waarde. Zo maak je ze en ga je er mee om:

>>> leeftijd = {'Mark': 18, 'Henk': 40}  # maak een dictionary
>>> leeftijd['Mark']  # haal Marks leeftijd op
18
>>> leeftijd['Henk'] = 35  # stel Henks leeftijd in
>>> leeftijd['Henk']  # haal Henks (nieuwe) leeftijd op
35

De sleutels zijn in bovenstaand voorbeeld strings van namen en de waarden de leeftijden als getal. Maar een sleutel of waarde kan alles zijn! Zo kunnen sleutels ook getallen zijn en waarden bijvoorbeeld een lijst of zelfs een andere dictionary. Nadat je een dictionary hebt gemaakt, kun je de waarden eruit halen met behulp van blokhaken. Ook kun je op die manier (opnieuw) een waarde toewijzen.

Je kunt er uiteraard met een loop overheen gaan en een lijst van alleen de waarden of alleen de sleutels verkrijgen:

>>> for persoon, leeftijd in leeftijd.items():
...     print(f'{persoon} is {leeftijd} jaar!')
Mark is 18 jaar!
Henk is 40 jaar!
>>> leeftijd.keys()  # krijg lijst met sleutels
>>> leeftijd.values()  # krijg lijst met waarden
>>> len(leeftijd)  # bepaal hoeveel items er zijn
2

Dan zijn er nog een paar andere nuttige tips rondom dictionaries die ik je mee kan geven. Je kunt de ene dictionary met de andere updaten door de update-functie te gebruiken. De dictionary die je als argument meegeeft, overschrijft dan de waarde in de originele dictionary als die al bestond. Anders wordt de waarde toegevoegd.

>>> leeftijd.update({
...     'Jan': 58,
...     'Marieke': 22,
... })  # nu staan er 4 personen in

Als je ooit hebt gewerkt met JSON (waar we overigens hier niet verder op ingaan), zul je merken dat dit prettig samenwerkt met dictionaries in Python:

>>> import json
>>> leeftijd = json.loads('{"Mark": 18}')  # JSON naar dictionary
>>> json.dumps(leeftijd	)  # dictionary naar JSON
'{"Mark": 18}'

Klassen in Python

Net zoals veel programmeertalen beschikt Python ook over een manier om een klasse te maken. Laten we eens een voorbeeld bekijken:

class Auto:

    def __init__(self, kleur, deuren=5):
        self.kleur = kleur
        self.deuren = deuren
    
    def verander_kleur(self, nieuwe_kleur):
        self.kleur = nieuwe_kleur

    def bestel(self, klant):
        # Hier zou code komen, die met ons
        # bestelsysteem communiceert.
        pass  # 'pass' betekent 'doe niets'

    def __str__(self):
        return f'Een {self.deuren}-deurs auto in de kleur {self.kleur}'

Zo zou je dan een 3-deurs rode auto bestellen:

>>> nieuwe_auto = Auto('rood', deuren=3)
>>> print(nieuwe_auto)
Een 3-deurs auto in de kleur rood
>>> nieuwe_auto.bestel('Mark')

Je eerste methodes

Wat gebeurt er hierboven? Met het class-woord geven we aan een klasse te willen maken die we Auto noemen. De speciale methode genaamd __init__ wordt telkens uitgevoerd als er een nieuw exemplaar van de klasse wordt aangemaakt. Die methode krijgt een aantal argumenten, waaronder self.

Een methode is simpelweg een functie, maar dan gebonden aan een klasse. Het eerste argument dat de methode ontvangt, is altijd het exemplaar van de klasse waarmee de functie wordt aangeroepen. Een klasse kan immers onbeperkt veel exemplaren hebben. De methode verander_kleur() wil je echter niet op alle exemplaren toepassen, wanneer je slechts van één exemplaar de kleur wilt aanpassen.

Terug naar die __init__-methode. We stellen de kleur en deuren in op de self aan de hand van wat de methode ontvangt in zijn argumenten. Zo slaan we die twee eigenschappen feitelijk op in ons exemplaar van de klasse. Hoe je die variabelen meegeeft en instelt, komen we zo op. Vervolgens voegen we nog twee methodes toe: eentje om de kleur aan te passen en een methode om de auto te bestellen. Als laatste maken we de __str__-methode. Dat is ook een speciale methode die Python gebruikt wanneer hij een exemplaar van een klasse om wil zetten naar een string. In de praktijk, gebruik je dat bijvoorbeeld als je het exemplaar wilt inspecteren met de print-functie. Kijk daarvoor naar het tweede blokje code.

De klasse gebruiken

De klasse is op dat punt af. Net zoals bij een functie, doet het aanmaken van de klasse nog niets. Je kunt vervolgens zoveel exemplaren van de klasse aanmaken, als nodig is. Dat doen we in het tweede blokje code. Je maakt een nieuw exemplaar aan door de naam van de klasse te schrijven met haakjes erachter, vergelijkbaar met hoe je een functie aanroept. De inhoud van die haakjes (vergelijkbaar dus met de argumenten die je meegeeft aan een functie) komt dan terecht bij die speciale __init__-methode.

Nadat we onze nieuwe auto hebben gemaakt, slaan we deze op in de variabele nieuwe_auto. Zo raken we hem niet kwijt. Als laatste roepen we een methode aan. Dat doe je door een punt te typen met de methodenaam. Eventueel krijgt die methode net zoals een functie nog argumenten mee, maar de bestel-methode neemt één argument aan: de naam van de klant. Let er hierbij op dat het self-argument (het exemplaar van de klasse) door Python automatisch wordt ingevuld. Geef deze dus niet mee met het aanroepen van de methode. Dan zijn we klaar!

Veel programmeerplezier!

Ondanks dat er nog flink wat over Python te vertellen valt, is ook dit blog weer ten einde gekomen. Ik hoop dat je het leuk vond en iets meer hebt geleerd over programmeren. Probeer het gerust zelf uit! Python installeren is zo gepiept en je kunt meteen aan de slag op je eigen computer. Met Python webapplicaties bouwen is ook heel eenvoudig. En als je iets gemaakt hebt wat je graag aan anderen toont, dan plaats je jouw applicatie gemakkelijk op je webhostingpakket. Heel veel ontwikkelplezier gewenst!

P.S. Blijf op de hoogte en volg ons via Facebook, X, Instagram, e-mail en RSS. Heb je vragen, tips of opmerkingen? Laat het achter als reactie. Vond je het artikel nuttig? Deel het dan met anderen!