Niet alle datastructuren zijn ingebouwd in alle programmeertalen. In de volgende hoofdstukken zullen we enkele complexere datastructuren bespreken die niet standaard aanwezig zijn in Python.

Toch willen we die datastructuren kunnen bespreken aan de hand van codevoorbeelden.

❓ Vraag - Datastructuren definiëren

Kan je zelf een datastructuur definiëren in Python?

Ja, dat kan! Het is mogelijk om zelf datastructuren te bouwen om gekende concepten te modelleren.

❗ Modelleren

Modelleren is het nabootsen van de werkelijkheid. Bij het programmeren modelleren we de werkelijkheid met behulp van datastructuren.

Bij het modelleren gebruiken we soms abstracties: we modelleren enkel die eigenschapen en interacties die van belang zijn voor ons probleem.

👀 Voorbeeld - Maquette

Een voorbeeld van modelleren vind je in de architectuur: een groot gebouw, zoals bijvoorbeeld een kasteel wordt getoond aan de hand van een maquette. Zo heb je het volledige overzicht over het gebouw. De maquette is een soort van beschrijving, in de vorm van een object.

Merk op dat de maquette geen exacte weergave is van het grote gebouw. Er wordt gebruik gemaakt van abstractie. Bij een abstractie worden bepaalde details weggelaten of veranderd om de hoofdzaak te verduidelijken. De grootte van het gebouw is niet van belang voor de maquette, de verhoudingen tussen muren en ramen wel.

Het modelleren van een probleem kan nuttig zijn om bepaalde eigenschappen te onderzoeken of om het schrijven van computerprogramma’s te vergemakkelijken. Aangezien we leren programmeren focussen we ons op dat laatste.

👀 Voorbeeld - Bungeejumpen

We kunnen een bungeejump beschrijven aan de hand van een wiskundige functie die de vorm van de sprong modelleert.

Door deze functie te onderzoeken, kunnen we bijvoorbeeld zeker zijn dat je bij een sprong nooit de grond zal raken. Belangrijk, toch?

👀 Voorbeeld - Tiktok filmpjes

Indien we een computerprogramma willen maken dat Tiktok-filmpjes ondersteunt, moeten we die filmpjes op een bepaalde manier kunnen modelleren.

We kunnen het filmpje voorstellen door een aantal van haar eigenschappen:

• de duur van het filmpje
• de frames waaruit het filmpje bestaat
• de geluiden per tijdstip
• …

Naast deze eigenschappen zijn er ook interacties mogelijk:

• het filmpje afspelen
• het filmpje pauzeren
• het filmpje converteren naar een ander bestandsformaat …

Dit is eigenlijk niets nieuws. Modelleren hebben we al vaak gedaan. Kijk eens naar de volgende twee voorbeelden, waar we

1. een wachtrij aan de kassa modelleren met een lijst als datastructuur en
2. profielen van leerlingen modelleren met een map als datastructuur.

👀 Voorbeeld - Wachtrij aan de kassa

Stel: je maakt een programma voor een winkel en je wil een wachtrij modelleren. We lijsten gewenste de eigenschappen en interacties van ons model op.

eigenschappen:

• de wachtrij bevat personen in een bepaalde volgorde
• de eerste in de rij wordt eerst geholpen

interacties:

1. iemand komt achteraan in de rij
2. de eerste in de rij wordt geholpen en verlaat de rij
3. je kan bekijken wie er als eerste in de rij staat
4. je kan bekijken wie er als laatste in de rij staat

Deze eigenschappen en interacties kunnen we in Python modelleren met een lijst als datastructuur, we moeten hiervoor geen eigen nieuwe datastructuur maken.

wachtrij = ["Alice", "Boris", "Chloé"]

interacties met lijst als datastructuur:

1. iemand komt achteraan in de rij: wachtrij.append("Daan")
2. de eerste in de rij wordt geholpen en verlaat de rij: wachtrij.pop(0)
3. je kan bekijken wie er als eerste in de rij staat: wachtrij[0]
4. je kan bekijken wie er als laatste in de rij staat: wachtrij[-1]

👀 Voorbeeld - Profielen van leerlingen

Stel: je wil de gegevens van leerlingen bijhouden in een programma. Elke student heeft een unieke naam, en daarbij horende eigenschappen. We lijsten de gewenste eigenschappen en interacties van ons model op.

eigenschappen:

• elke leerling is uniek
• elke leerling heeft bijbehorende gegevens, bijvoorbeeld leeftijd en klas

interacties

1. je kan de klas van elke leerling opvragen
2. je kan de leeftijd van elke leerling aanpassen
3. je kan een nieuwe leerling toevoegen
4. je kan een leerling verwijderen

Deze eigenschappen en interacties kunnen we in Python modelleren met een map als datastructuur, we moeten hiervoor geen eigen nieuwe datastructuur maken.

leerlingen = {"Alice": {"leeftijd": 16, "klas": "5A"}, "Boris": {"leeftijd": 17, "klas": "5B"}}

interacties met map als datastructuur:

1. je kan de klas van elke leerling opvragen: leerlingen["Alice"]["klas"]
2. je kan de leeftijd van elke leerling aanpassen: leerlingen["Boris"]["leeftijd"] = 18
3. je kan een nieuwe leerling toevoegen: leerlingen["Chloé"] = {"leeftijd": 16, "klas": "5A"}
4. je kan een leerling verwijderen: leerlingen.pop("Alice")