In Python zijn er meerdere soorten standaard collecties. We gaan er met een aantal werken, namelijk:
- List
- Tuple
- Dictionary
List
De list kan worden vergeleken met een lijst zoals we deze in de dagelijkse praktijk ook vaak tegenkomen, bijvoorbeeld een boodschappenlijst, todo-lijst of een lijst van huishoudelijke karweitjes.
Het grote voordeel van een lijst in Python is, is dat deze digitaal is en daardoor zijn er verschillende acties mogelijk zoals bijvoorbeeld:
- Sorteren
- Tussen voegen van extra items
- Samenvoegen met andere lijsten
Dit alles maakt een lijst een veelzijdig datatype, want je mag een lijst (en andere collecties) zien als een datatype.
Hoe maak je en vul je een lijst
Waarden opvragen uit een lijst
Lengte van de lijst
Toevoegen elementen
Verwijderen van elementen
Wijzigen van elementen
Sorteren van de lijst
Tot zover hebben we alleen de waarden van het datatype float, de gebroken getallen, gebruikt. In een lijst kan je echter elk beschikbaar datatype van Python stoppen. .Je mag zelfs verschillende datatypen, door elkaar, in dezelfde lijst gebruiken.
Wanneer gebruik je nou een lijst?
Dit doe je als je gerelateerde data wilt onthouden in een specifieke volgorde, maar waarbij wel wijzigingen moeten kunnen worden doorgevoerd door de waarde van de elementen aan te passen of nieuwe elementen toe te voegen. Denk bijvoorbeeld aan je kluslijst: je hebt een specifieke volgorde waarin je aan de slag gaat. Eerst schuren, ontvetten en dan verven. Het kan zijn dat je daar nog de klus ‘accenten aanbrengen’ aan toe wil voegen. Een lijst is dan handig.
Tuples
Tuples zijn ook datatypes uit de collections. Ze zijn vergelijkbaar met de lijst. Een tuple herken je aan de ronde haken (). Dit moet je niet verwarren met de rechte haken [] van een lijst.
Een voorbeeld van een tuple met netwerkgegevens kan er als volgt uitzien:
Network_information=(“192.168.1.4”,1200,”tcp”)
Print(network_information)
Bovenstaande tuple kunnen we dan als volgt weergeven:
| Tuple | “192.168.1.4” | 1200 | “TCP” |
| Element | 1 | 2 | 3 |
| Index | 0 | 1 | 2 |
Er is een groot verschil bij een tuple, ten opzichte van een lijst, en dat is dat een tuple achteraf niet meer kan worden aangepast. Dat betekent dat we er geen elementen aan toe kunnen voegen of uit kunnen verwijderen danwel wijzigen. Dat klinkt onhandig, maar er bestaan ook heel veel lijstjes die nooit wijzigen (geen nieuwe waarden, geen veranderingen etc). Denk bijvoorbeeld aan de afmetingen van beeldschermen die te koop zijn in een webshop of gebruikersinformatie zoals username en password. Die laatsten kunnen wel wijzigen uiteraard, maar dan wordt er ook een nieuwe tuple aangemaakt.
Elementen opvragen
Je kan op dezelfde manier de waarde van elementen opvragen als bij een lijst. Dit gebeurt ook door middel van indexen. Ook hier krijg je een foutmelding als je buiten de lengte van de tuple gaat met je indexen. Indexen mag je maken met expressies.
Een voorbeeld:
Poort_number=Network_information[1]Bovenstaande zal als resultaat de waarde 1200 opleveren.
Hoeveel elementen zitten er in een tuple?
Van een tuple kunnen we ook de lengte opvragen. Met code doen we dat als volgt:
Number_of_elements=Len(Network_information)
Print(number_of_elements)
Bovenstaande zal als resultaat de waarde 3 opleveren
Dictionaries
De dictionary is het belangrijkste datatype binnen Python. Een dictionary is een Key/Value-pair. Dat betekent dat elk element bestaat uit een key en een daaraan gekoppelde value. In het Nederlands hebben we het dan over sleutel en waarde. Een dictionary herken je aan de accolades {}. Een lege dictionary maak je als volgt:
Computer_data={}Dictionary vullen
Opvragen van een key/value-pair
Om een waarde op te vragen moet je een key meegeven. Stel we willen het jaar van levering van de computer weten:
Delivery_year=computer_data[“year”]
Print(delivery_year)
Bovenstaande zal als resultaat de waarde 2021 opleveren.
Voor elke andere key had je de volgende waarde teruggekregen:
| Key | Value |
| “Brand” | “Dell” |
| “Type” | “Alienware” |
| “Year” | 2021 |
| “Price” | 3788,43 |
Wanneer je een key vraagt die niet bestaat dan krijg je een foutmelding terug. Stel je vraagt de key “SSD” op dan krijg je de tekst op je scherm te zien:
Key error: “SSD”
Toevoegen van een key/value-pair
Wanneer we een key/value pair willen toevoegen aan de dictionary dan moeten we een unieke key opgeven omdat een dictionary nooit twee dezelfde keys kan bevatten. Alle keys zijn uniek.
Stel we gaan het processor type toevoegen dan kan dat met de volgende code:
Computer_data[“Processor”]=”IQ”
Print(computer_data)
De tuple zou er dan als volgt kunnen uitzien:
{“Brand”;”Dell”,”Type”:”Alienware”,”Year”:2021,”Price”:3788,43,”Processor”:”IQ”}
Als de key die je gebruikt al bestaat in de tuple, dan wordt de oude waarde van die key overschreven met de nieuwe waarde.
Opvragen van het aantal elementen in een dictionary
Ook van een dictionary kunnen we vragen hoeveel key/value-pairs er aanwezig zijn. Dit kan met de volgende code:
Number_data_points=Len(computer_data)
Print(number_data_points)
Bovenstaande zal als resultaat de waarde 5 opleveren.
De dictionary werkt niet met indexen zoals we dat zagen bij de lijst en de tuple. De key is vergelijkbaar met de index.
Verwijderen van een key/value-pair
Om een key/value-pair te verwijderen uit een dictionary heb je de functie POP() nodig. Dit kan met de volgende code:
Delivery_year=computer_data.pop(“Year”
Print(delivery_year)
Bovenstaande zal als resultaat de waarde 2021 opleveren.
Na deze code bestaat de dictionary uit de volgende key/value-pairs:
| Key | Value |
| “Brand” | “Dell” |
| “Type” | “Alienware” |
| “Price” | 3788,43 |
| “Processor” | “IQ” |
Samenvattend:
De collecties die we hierboven hebben behandeld vormen slechts de basis en we hebben nopg maar een klein tipje van de sluier opgelicht. Dictionaries zij een krachtig instrument en we gaan dit instrument ook gebruiken voor een aantal scenario’s.
Elke collectie kan alle datatypen in haar collectie bewaren. Dat betekent dat ze ook zichzelf of een andere collectie kunnen bewaren. Je kan op deze manier zeer krachtige datastructuren maken die dicht op je eigen mentale structuur liggen.