Module 10: Lists
Een “list” (Engelse woord voor “lijst”) is een geordende verzameling van data items, net zoals een tuple. Het verschil tussen lists en tuples is dat lists veranderbaar zijn. Dit maakt ze tot een zeer flexibele data structuur, waar je op veel manieren gebruik van kunt maken. Ik gebruik de Engelse benaming “list” (en het meervoud “lists”) in plaats van het Nederlandse “lijst” omdat list een data type is.
10.1 Basis van lists
Een list is een verzameling (of “collectie”) elementen.
De elementen van een list zijn geordend. Omdat ze geordend zijn, kun je ieder element van een list benaderen via een index, net zoals je de tekens in een string kunt benaderen. De indices beginnen bij nul, net als bij strings.
In Python kun je lists herkennen aan het feit dat de elementen van een list tussen vierkante haken ([]) staan. Je kunt het aantal elementen in een list achterhalen door middel van de len() functie. Via een for loop kun je de elementen van de list doorlopen. Je mag data types in een list mixen. Je kunt de functies max(), min() en sum() gebruiken op een list. Je kunt testen of een element voorkomt in een list via de in operator (of het niet voorkomen van een element via de not in operator).
Schrijf een while loop die elementen van een list afdrukt.
Afgezien van de vierkante haken, lijken lists veel op tuples. Maar er is een groot verschil…
10.2 Lists zijn veranderbaar
Omdat lists veranderbaar (Engels: “mutable”) zijn, mag je de inhoud van een list wijzigen.
Om een element van de list te overschrijven, kun je er een nieuwe waarde aan toekennen middels een assignment.
Je kunt ook een sub-list overschrijven door een nieuw list toe te kennen aan de sub-list. De sub-list en de nieuwe list hoeven niet dezelfde lengte te hebben.
Je kunt nieuwe elementen aan een list toevoegen door ze toe te kennen aan een lege sub-list.
Je kunt elementen van een list verwijderen door een lege list aan de te verwijderen sub-list toe te kennen.
Door sub-lists en assignments te gebruiken, kun je lists aanpassen op iedere manier die je wilt. Het is echter eenvoudiger om lists aan te passen via methodes. Er zijn allerlei handige methodes beschikbaar, die ik hieronder bespreek.
Neem een list die alleen woorden bevat (bijvoorbeeld één van de fruitlists hierboven). Verander ieder woord in de list in een woord dat alleen uit hoofdletters bestaat. Op dit punt in het boek doe je dat met behulp van een while loop die een variabele i laat starten bij 0 en laat oplopen tot len(<list>)-1. Gebruik i als index voor de list.
10.3 Lists en operatoren
Lists ondersteunen het gebruik van de operatoren + en ∗. Deze operatoren werken op eenzelfde manier als ze werken bij strings.
Je kunt twee lists bij elkaar optellen middels de + operator, en het resultaat is een list die de elementen bevat van beide opgetelde lists. Je moet het resultaat aan een variabele toekennen om het op te slaan.
Je kunt een list vermenigvuldigen met een integer om een list te creëren die de elementen van de originele list bevat, net zo vaak herhaald als de integer aangeeft. Dit kan een snelle manier zijn om een list te creëren waarvan alle elementen hetzelfde zijn.
Merk op: Met de + kun je twee lists bij elkaar tellen, maar je kunt niet een element aan de list toevoegen, tenzij je dat nieuwe element in een list met slechts één element opneemt door er vierkante haken omheen te zetten. Als je iets dat geen list is probeert op te tellen bij een list, dan zal Python proberen dat iets te interpreteren als een list – en als dat kan (wat mogelijk is voor bijvoorbeeld een string, die kan worden geïnterpreteerd als een list met letters), dan zal het de optelling uitvoeren maar is het resultaat waarschijnlijk niet wat je verwacht. Bijvoorbeeld, de code hieronder probeert “kers” toe te voegen aan een list, maar hoewel geen van de twee manieren die gebruikt worden een fout veroorzaakt, doet alleen de tweede wat bedoeld is.
10.4 List methodes
Python heeft een groot aantal methodes die lists wijzigen of informatie uit lists halen. Je hoeft geen module te importeren om ze te gebruiken. Omdat het methodes betreft, gebruik je de syntax <list>.<methode>().
Belangrijk
Lists zijn veranderbaar en deze methodes veranderen vaak de list waarop ze werken! Dit is niet wat je gewend bent met string methodes, waarbij de methodes een nieuwe string maken en die retourneren, zonder de originele string aan te passen. De meeste list methodes hebben daarentegen een onomkeerbaar effect op de list waarop ze werken. Meestal hebben ze ook geen retourwaarde, en die heb je ook niet nodig, omdat het doel van de methodes is de list te wijzigen.
append()
extend()
insert()
remove()
pop()
del
index()
count()
sort()
reverse()
append()
append() plakt een nieuw element aan het einde van een list. Je roept de methode aan met het nieuwe element als argument.
Zoals hierboven is beschreven, kun je in plaats van de append() methode een element aan een list toevoegen via de + operator, en het resultaat weer toekennen aan de variabele die de list bevat. De append() methode is echter leesbaarder. <list>.append(<element>) is equivalent met <list>[len(<list>):] = [<element>], of <list> += [<element>].
extend()
extend() maakt een list langer door alle elementen van een tweede list aan het einde te van de eerste list toe te voegen. Je roept de methode aan met de list met de nieuwe elementen als argument.
Net als bij de append() methode kun je in plaats van de extend() methode de + operator gebruiken en het resultaat toekennen aan de originele list. En net als bij de append() methode, is het gebruik van de extend() methode te prefereren vanwege de leesbaarheid. <list>.extend(<addlist>) is equivalent met <list>[len(<list>):] = <addlist>.
insert()
insert() geeft de mogelijkheid een element aan een list toe te voegen op een specifieke positie. Je roept de methode aan met twee argumenten, waarvan de eerste de index is van de positie waar het nieuwe element moet komen, en de tweede het nieuwe element zelf. Als je een element toe wilt voegen aan het begin van de list, kun je index 0 gebruiken.
<list>.insert(<i>,<element>) is equivalent met <list>[<i>:<i>] = [<element>].
remove()
remove() laat je een element van de list verwijderen. Het element dat je wilt verwijderen geef je mee als argument. Als dit element meerdere keren voorkomt in de list, wordt de eerste instantie (die met de laagste index) verwijderd. Als je een element probeert te verwijderen dat niet voorkomt op de list, geeft dat een runtime error.
pop()
Net als remove(), verwijdert pop() een element van de list, maar doet dat via een index. Er is één numeriek argument, dat optioneel is, dat de index is van het te verwijderen element. Als geen argument wordt meegegeven, wordt het laatste element van de list verwijdered. Als een index wordt meegegeven die buiten de list valt, volgt een runtime error.
Een groot verschil tussen remove() en pop() is dat pop() een retourwaarde heeft, namelijk het element dat verwijderd is. Dit zorgt ervoor dat je via pop() snel alle elementen van een list kunt verwerken terwijl je de list leegmaakt.
del
del is noch een methode noch een functie, maar omdat het vaak in één adem genoemd wordt met remove() en pop(), zet ik het hier neer. del is een gereserveerd woord dat een list element verwijderd, of zelfs een sub-list, via de index. Het lijkt op wat pop() doet, maar heeft geen retourwaarde. pop() kan ook niet gebruikt worden op sub-lists. del gebruik je via de syntax del <list>[<index>] of del <list>[<index1>:<index2>].
index()
index() retourneert de index van de eerste instantie in een list van het element dat als argument aan de methode is meegegeven. Een runtime error volgt als het element niet voorkomt op de list.
count()
count() retourneert een integer die aangeeft hoe vaak het element dat als argument is meegegeven voorkomt in de list.
sort()
sort() sorteert de elementen van de list, van laag naar hoog. Als de elementen strings zijn, betreft het een alfabetische sortering. Als de elementen getallen zijn, betreft het een numerieke sortering. Als de elementen gemixt zijn, volgt een runtime error, tenzij bepaalde extra argumenten zijn meegegeven.
Om van hoog naar laag te sorteren, kun je een argument reverse=<boolean> meegeven.
Een ander argument dat je sort() kunt meegeven is een “key” (Engels voor sleutel). Je geeft dit argument mee volgens de syntax <list>.sort( key=<key> ), waarbij <key> een functie is die één element meekrijgt (namelijk het element dat gesorteerd moet worden) en die een waarde retourneert die als sorteringssleutel gebruikt moet worden. Een typische toepassing van het key argument is als je een list van strings wilt sorteren, waarbij je de strings “case-insensitive” (dat wil zeggen zonder verschil te maken tussen hoofd- en kleine letters) wilt sorteren. Dus als key wil je de waarde van het element volledig als kleine letters gebruiken. Dat kun je doen door als key functie str.lower() mee te geven. Je roept dan de sort() methode aan als in het volgende voorbeeld:
Merk op dat je bij het key argument geen haakjes achter de functie naam zet. Dit is namelijk geen functie-aanroep, het is een argument dat Python vertelt welke functie gebruikt moet worden om de sorteringssleutel te genereren. Je kunt ook je eigen functies gebruiken als key. Bijvoorbeeld, in de volgende code wordt numlist gesorteerd met de cijfers van de drie-cijferige getallen in omgekeerde volgorde:
Hier is een ander voorbeeld, waarbij een list van strings gesorteerd wordt op string lengte als eerste (korte strings vóór lange strings), en alleen bij gelijke lengte op alfabetische volgorde:
Merk op dat de len_alfabetisch() functie een tuple retourneert. Zoals in hoofdstuk 12 werd uitgelegd, als je twee tuples vergelijkt worden eerst de eerste elementen van de tuples vergeleken, en alleen als die gelijk zijn worden de tweede elementen vergeleken.
Op dit punt kan ik een typisch voorbeeld geven van het gebruik van een “anonieme functie,” die ik introduceerde in hoofdstuk 9 (als je die niet hebt overgeslagen). Als je een anonieme functie gebruikt om de key voor een sort() methode te specificeren, in plaats van als een separate functie elders in het programma, houd je de code compact en leesbaar.
reverse()
reverse() zet de elementen van de list in omgekeerde volgorde.
Oefening
Schrijf een programma dat de gebruiker vraagt wat data in te geven, bijvoorbeeld de namen van zijn of haar vrienden. De gebruiker geeft aan te stoppen met data ingeven als alleen Enter wordt ingedrukt. Het programma toont dan alle ingegeven data items, alfabetisch gesorteerd. Print ieder item apart, op een eigen regel.
Sorteer een list van nummers op absolute waarde. Hint: Gebruik de abs() functie als key.
Tel hoe vaak iedere letter (case-insensitive) voorkomt in een string. Je mag alle tekens negeren die geen letter zijn. Je zou dit natuurlijk kunnen doen met 26 variabelen, maar het is veel beter om een list te gebruiken. Zet alle 26 elementen van de list bij de start op 0. Wanneer de letters geteld zijn, druk je alle resulterende tellingen af. Als index voor de list kun je ord(letter) - ord("a") gebruiken, waarbij “letter” een kleine letter is (de functie ord() is uitgelegd in hoofdstuk 11).
10.5 Alias
Als je een variabele die een list omvat toekent aan een andere variabele middels de assignment operator (=), denk je misschien dat je een kopie hebt gemaakt van de list. Maar dat is niet wat er gebeurt. Je maakt op deze manier een alias voor de list, dat wil zeggen, een nieuwe variabele die refereert aan precies dezelfde list. Je kunt de nieuwe variabele gebruiken als een list, maar iedere wijziging die je maakt in de list waaraan de variabele refereert, is ook te zien is in de list waaraan de originele variabele refereert, en vice versa. Het zijn niet twee verschillende lists.
Iedere variabele in Python heeft een identificatie nummer. Dat nummer kun je zien met de id() functie. Het ID nummer geeft aan welke geheugenadres door de variabele gebruikt wordt. Voor een alias van een list is de ID (logischerwijs) hetzelfde als voor de originele list.
Als je een kopie van een list wilt creëren, kun je dat doen met een klein truukje. In plaats van <nieuwlist> = <oudlist> te gebruiken, gebruik je <nieuwlist> = <oudlist>[:].
IS
Het gereserveerde woord is is geïntroduceerd om de identiteiten van twee variabelen met elkaar te vergelijken.
Zoals je kunt zien, weet is te bepalen dat fruitlist en fruitlist2 een alias van elkaar zijn, maar dat fruitlist3 niet dezelfde list is. Als je ze echter vergelijkt met de == operator, zijn de resultaten anders dan als je ze vergelijkt met is:
De == operator vergelijkt de inhoud van de lists, dus er wordt True geretourneerd voor alle vergelijkingen. Voor data types waarvoor de == niet speciaal gedefinieerd is, wordt een identiteitsvergelijking uitgevoerd. Maar voor lists is de == operator gedefinieerd als een vergelijking van list inhoud.
