2. Lijsten#

Een list is een verzameling van waarden. Hieronder zie je een paar voorbeelden.

>>> powers_of_2 = [2, 4, 8, 16]
>>> random_floats = [10.0, 7.5, 3.33, 0.2]
>>> colors = ['rood', 'groen', 'blauw']
>>> mixed_bag = [1, 'oranje', 3.14, [5, 6, 7]]

Zoals je kunt zien, geven we in Python een list aan met vierkante haken. De waarden in de list worden gescheiden door komma’s. Een list kan verschillende datatypes bevatten, zoals strings, integers, floats en zelfs andere lists.

Indices#

Een list is niet zomaar een verzameling, het is een geordende verzameling. Dat wil zeggen: de volgorde van de waarden in de list is belangrijk. Elke waarde in de list heeft een zogenoemde index. De index is een getal dat aangeeft op welke positie de waarde in de list staat. Let op: we tellen hierbij niet vanaf 1 maar vanaf 0! De eerste waarde in de list heeft dus index 0, de tweede waarde heeft index 1, enzovoort.

Index	`0`	`1`	`2`	`3`
Waarde	`'water'`	`'fire'`	`'wind'`	`'earth'`

Met behulp van de index kun je een waarde uit een list opvragen:

>>> fruits = ['appel', 'banaan', 'citroen']
>>> fruits[1]
'banaan'

Of een waarde in een list veranderen:

>>> fruits = ['appel', 'banaan', 'citroen']
>>> fruits[1] = 'bosbes'
>>> fruits
['appel', 'bosbes', 'citroen']

Lengte van een list: len()#

Het komt vaak voor dat je wilt weten hoeveel waarden er in een list staan. Dat kan met de functie len(). Deze functie geeft het aantal waarden in de list terug.

>>> fruit = ['appel', 'banaan', 'citroen']
>>> len(fruit)
3

De functie len() stelt je tevens in staat om het laatste item in een list op te vragen:

>>> fruit = ['appel', 'banaan', 'citroen']
>>> fruit[len(fruit) - 1]
'citroen'

Merk op dat je hier len(fruits) - 1 als index moet gebruiken, omdat we bij 0 beginnen met tellen, waardoor de index van het laatste item in de list gelijk is aan de lengte van de list min 1.

Python biedt echter een snellere manier om het laatste item in een list op te vragen. Je kunt namelijk ook een negatieve index gebruiken. De index -1 verwijst naar het laatste item in de list, -2 naar het op één na laatste item, enzovoort.

>>> fruit = ['appel', 'banaan', 'citroen']
>>> fruit[-1]
'citroen'
>>> fruit[-2]
'banaan'

Items toevoegen en verwijderen#

Om een nieuwe waarde aan bestaande list toe te voegen, kun je de functie append() gebruiken. Deze functie is een methode van de list en daarom roep je hem aan met een punt achter de list naam:

>>> groenten = ['andijvie', 'broccoli', 'courgette']
>>> groenten.append('doperwt')
>>> groenten
['andijvie', 'broccoli', 'courgette', 'doperwt']

Een waarde uit een list verwijderen kan met de methode remove(). Deze functie verwijdert de eerste waarde die overeenkomt met de opgegeven waarde. Als je bijvoorbeeld de waarde 'broccoli' uit de list wilt verwijderen, doe je dat als volgt:

>>> groenten = ['andijvie', 'broccoli', 'courgette']
>>> groenten.remove('broccoli')
>>> groenten
['andijvie', 'courgette']

Wanneer je de index weet van de waarde die je wilt verwijderen, kun je de functie pop() gebruiken. Deze methode verwijdert de waarde op de opgegeven positie uit de list:

>>> groenten = ['andijvie', 'broccoli', 'courgette']
>>> groenten.pop(0)
>>> groenten
['broccoli', 'courgette']

De functie pop() geeft de verwijderde waarde ook terug. Dit kan handig zijn als je de verwijderde waarde nog even wilt gebruiken in je programma. Hier is een voorbeeld:

>>> groenten = ['andijvie', 'broccoli', 'courgette']
>>> verwijderde_waarde = groenten.pop(0)
>>> groenten
['broccoli', 'courgette']
>>> verwijderde_waarde
'andijvie'

Alle items in een list langslopen#

Het langslopen van alle items in een list noemen we itereren. Dit kan op verschillende manieren. De meest gebruikelijke manier is met een for loop. Hier is een voorbeeld:

kleuren = ['rood', 'groen', 'blauw']
for kleur in kleuren:
   print(kleur)

De uitvoer van dit programma is:

rood
groen
blauw

Soms wil je bij het itereren ook de index weten van het item dat je aan het verwerken bent. Dit kan met de functie enumerate():

kleuren = ['rood', 'groen', 'blauw']
for index, kleur in enumerate(kleuren):
   print(index, kleur)

De uitvoer van dit programma is:

rood
groen
blauw

List comprehensions#

Stel dat je een lijst wilt maken met de kwadraten van de getallen 1 tot en met 10. Dit kan met een for loop:

kwadraten = []
for n in range(1, 11):
   kwadraten.append(n * n)
print(kwadraten)

In regel 1 maken we een lege list aan met de naam kwadraten. In regel 2 gebruiken we een for loop om door de getallen 1 tot en met 10 te itereren. In regel 3 voegen we het kwadraat van elk getal toe aan de list kwadraten. Tot slot printen we de list naar het scherm. De uitvoer van dit programma is:

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Met een zogenoemde list comprehension kan dit echter sneller en eleganter:

kwadraten = [n * n for n in range(1, 11)]
print(kwadraten)

Met een list comprehension kun je in één regel een nieuwe list maken op basis van een bestaande list. De syntax is als volgt:

nieuwe_list = [<uitdrukking> for <item> in <bestaande_list>]

Misschien denk je nu, hoezo bestaande list? We hebben toch helemaal geen bestaande list gebruikt voor de kwadraten list? Klopt, maar we kunnen ook een range gebruiken als bestaande list. De volgende twee regels zijn dus gelijkwaardig:

kwadraten = [n * n for n in [0, 1, 2, 3]]
kwadraten = [n * n for n in range(4)]

List comprehensions zijn heel handig om snel lijsten te maken. Bijvoorbeeld, wanneer je een lijst met 100 nullen wilt maken:

nullen = [0 for n in range(100)]

Tweedimensionale lists#

Zoals gezegd kan een list andere lists bevatten:

>>> my_list = [['a', 'b', 'c'], ['d', 'e']]
>>> my_list[0]
['a', 'b', 'c']
>>> my_list[1]
['d', 'e']

Hoe zou je de waarde 'b' uit de list my_list kunnen ophalen? Het is het tweede item in de eerste list. Dus je moet eerst de eerste list opvragen en dan het tweede item uit die list:

>>> my_list[0][1]
'b'

Met een list comprehension kun je ook een lijst maken van lijsten. Dit noemen we een tweedimensionale list. Hier is een voorbeeld:

tabel = [[n for n in range(1, 4)] for m in range(1, 7)]
for row in tabel: print(row)

Regel 1 ziet er ingewikkeld uit hè? Laten we hem even ontleden. We maken een list met de naam tabel. Deze list bevat 6 lists, omdat we in de buitenste list comprehension for m in range(1, 7) gebruiken. De binnenste list comprehension maakt met n for n in range(1, 4) een lijst met de getallen 1 tot en met 3. Dit gebeurt 6 keer, omdat we in de buitenste list comprehension 6 keer itereren. De for loop in regel 2 print elke rij van de tabel naar het scherm.
De uitvoer van dit programma is:

[1, 2, 3]
[1, 2, 3]
[1, 2, 3]
[1, 2, 3]
[1, 2, 3]
[1, 2, 3]

Als je alles wat hierboven staat hebt begrepen, ben je klaar om met de tekstversie van het spel beginnen. Zijn er dingen die je nog niet helemaal snapt? Lees de uitleg dan nog eens door en experimenteer zelf met lists in Mu Editor.