Programmeren in Python/Arrays
Arrays staan het gebruik van meerdere variabelen op een georganiseerde manier toe. Er zijn vier types arrays in Python: Lists (lijsten), Tuples (tupels), Dictionaries (woordenboeken) en Sets (verzamelingen). Eigenlijk zijn er meerdere, maar dit zijn de meest gebruikte types. Ook maken we in het vervolg afwisselend gebruik van de Engelse en Nederlandstalige benamingen (typisch de Engelse wanneer het om het datatype gaat, en de Nederlandse wanneer het om het concept gaat).
Lists
[bewerken]
Een list aanmaken
[bewerken]Een list is net wat het woord zegt: een lijst van variabelen, met een bepaalde volgorde. Een list wordt aangemaakt door middel van vierkante haakjes en de individuele waarden zijn gescheiden door komma's. Bijvoorbeeld:
Python-code: Lijst met strings
# lijst van namen
names = ['Piet', 'Jan', 'Klaas']
Lijsten kunnen objecten van verschillende types bevatten. In het vorige voorbeeld bevat het alleen stringobjecten, maar het kan ook andere bevatten zoals getallen.
Python-code: Lijst met nummers
numbers = [42, 4.2]
Maar ook andere types, alle mogelijke combinaties van types of zelfs andere lijsten.
Python-code: Andere types, combinaties, lijsten in een lijst
# lijst met verschillende datatypes
names_and_numbers_and_others = ['Piet', 42, 'Jan', 4.2, 'Klaas', False]
# lijsten in een lijst
lists_in_a_list = [['Piet', 'Jan', 'Klaas'], [42, 4.2]]
Elementen oproepen
[bewerken]Individuele elementen van een lijst kunnen worden opgeroepen door hun index in vierkante haken achter de variabelenaam te zetten. De index begint bij 0. Bijvoorbeeld:
Python-code: Index
# lijst met verschillende datatypes
names_and_numbers_and_others = ['Piet', 42, 'Jan', 4.2, 'Klaas', False]
print(names_and_numbers_and_others[0])
print(names_and_numbers_and_others[1])
print(names_and_numbers_and_others[2])
print(names_and_numbers_and_others[3])
print(names_and_numbers_and_others[4])
print(names_and_numbers_and_others[5])
Output:
Piet 42 Jan 4.2 Klaas False
Een negatieve index kan ook, dan begint de lijst achteraan:
Python-code: Index
# lijst met verschillende datatypes
names_and_numbers_and_others = ['Piet', 42, 'Jan', 4.2, 'Klaas', False]
print(names_and_numbers_and_others[-1])
print(names_and_numbers_and_others[-2])
print(names_and_numbers_and_others[-3])
print(names_and_numbers_and_others[-4])
print(names_and_numbers_and_others[-5])
print(names_and_numbers_and_others[-6])
Output:
False Klaas 4.2 Jan 42 Piet
De functie len() werkt eveneens bij arrays, dit geeft het aantal items in de array terug:
Python-code: len()
# lijst van namen.
names = ['Piet', 'Jan', 'Klaas']
print(len(names))
Output:
3
Merk op dat de len() functie het aantal elementen telt, dus in deze lijst kan men het laatste element (de string 'Klaas') vinden op index (len(names) -1).
Net zoals een variabele kunnen de items in een lijst ook veranderd worden:
Python-code:
# Lijst van namen.
names = ['Piet', 'Jan', 'Klaas']
# De naam op index 1 veranderen naar Geert.
names[1] = "Geert"
# Printen van het resultaat.
print(names)
Output:
['Piet', 'Geert', 'Klaas']
Elementen toevoegen
[bewerken]Het is ook mogelijk om objecten toe te voegen aan een lijst. Er zijn een aantal mogelijkheden maar de eenvoudigste is met behulp van de append() methode:
Python-code: append()
# Lijst van namen.
names = ['Piet', 'Jan', 'Klaas']
# De naam "Geert" toevoegen met de methode append()
names.append("Geert")
# Printen van het resultaat.
print(names)
Output:
['Piet', 'Jan', 'Klaas', 'Geert']
append() voegt elementen aan het einde van de lijst toe. Om elementen binnen in een lijst ergens tussen te schuiven ter hoogte van een bepaalde index kan men gebruik maken van insert(). Bijvoorbeeld:
Python-code: insert()
# Een lijst met namen.
names = ['Piet', 'Jan', 'Klaas']
# Voorbeeld van het gebruik van insert().
names.insert(2, "Geert")
# Uitprinten van de namen.
print(names)
Output:
['Piet', 'Jan', 'Geert', 'Klaas']
Het eerste argument dat wordt meegegeven is de index positie waar het element in moet komen. Het tweede argument is het in te voegen element. Het spreekt voor zich dat de element die voordien op die positie stond een plaats opschuift, net zoals al de elementen die daarop volgen.
Elementen verwijderen
[bewerken]Door middel van het sleutelwoord del kan men elementen verwijderen:
Python-code: del
# Een lijst met namen.
names = ['Piet', 'Jan', 'Klaas']
# Voorbeeld van het gebruik van del.
del names[1]
# Uitprinten van de namen.
print(names)
Output:
['Piet', 'Klaas']
del moet gevolgd worden door de lijst met de index van het element die je uit de lijst wilt verwijderen. Als je vergeet een index te vermelden en enkel de lijst vermeld verdwijnt de hele lijst en kunnen er fouten ontstaan. Bijvoorbeeld:
Python-code: del
# Een lijst met namen.
names = ['Piet', 'Jan', 'Klaas']
# Voorbeeld van het gebruik van del.
del names
# Uitprinten van de namen.
print(names)
Output:
Traceback (most recent call last):
File "k.py", line 8, in <module>
print(names)
NameError: name 'names' is not defined
Tuples
[bewerken]Een tuple aanmaken
[bewerken]Tuples zijn bijna hetzelfde als lijsten, het grote verschil is dat tupels onveranderlijk zijn. Zodra een tuple aangemaakt is, is er geen mogelijkheid om een wijziging aan te brengen: het is onmogelijk om iets toe te voegen of te verwijderen. Los hiervan werken tupels op dezelfde manier als lijsten, tupels kunnen, net als lijsten, een zelfde object meerdere malen bevatten.
Om een tupel te declareren maakt men gebruik van komma's:
Python-code: Tuple met strings
# Een tuple met namen.
names = 'Piet', 'Jan', 'Klaas'
Je kunt eventueel ook haakjes gebruiken rond de elementen om ze af te bakenen.
Python-code: Tuple met strings
# Een tuple met namen.
names = ('Piet', 'Jan', 'Klaas')
Beiden zullen hetzelfde resultaat geven, als je de tuple zou printen:
('Piet', 'Jan', 'Klaas')
Tuples kunnen, zoals lists, natuurlijk naast strings ook alle andere datatypes bevatten zoals getallen, maar ook andere tuples.
Python-code: Andere types, combinaties, tuples in een tuple
# Tuple met verschillende datatypes.
names_and_numbers_and_others = ('Piet', 42, 'Jan', 4.2, 'Klaas', False)
# Tuples in een tuple.
tuples_in_a_tuple = (('Piet', 'Jan', 'Klaas'), (42, 4.2))
Elementen oproepen
[bewerken]Dictionaries
[bewerken]Een dictionary aanmaken
[bewerken]Dictionaries zijn ook gelijkwaardig aan lijsten, en ze zijn tevens veranderlijk. Dit wil zeggen dat je net zoals bij een lijst elementen uit een dictionary kan toevoegen, wijzigen en verwijderen. Het grote verschil is dat elementen niet gekoppeld zijn aan een index zoals het geval is bij een lijst. Elk element in een woordenboek heeft twee delen: een sleutel (key), en een waarde. Een bepaalde sleutel opzoeken in een woordenboek geeft de waarde gekoppeld aan deze sleutel terug. Eigenlijk kan men een lijst beschouwen als een special geval van een woordenboek, d.w.z. een woordenboek waarbij de sleutels uit oplopende natuurlijke getallen bestaan.
Woordenboeken worden gedeclareerd met accolades, elk element is het eerste gedeclareerd door zijn sleutel, vervolgens een dubbelpunt en tenslotte de waarde. Bijvoorbeeld:
Python-code: Dictionary met landen
# Dictionary met landcodes als sleutels en landnamen als waarden
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
In dit voorbeeld, hebben we een dictionary aangemaakt met landcodes als de sleutels en de landnamen als de bijhorende waardes. Het is mogelijk om dezelfde sleutel te gebruiken tijdens het declareren van een dictionary, als je dit doet zal echter de vorige waarde dat die sleutel had, worden overschreven met de nieuwe waarde.
Python-code: Dictionary met landen
# Dictionary met landcodes als sleutels en landnamen als waarden
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland", "BE": "Belgium"}
print(country_codes)
Output:
{'NL': 'Nederland', 'BE': 'Belgium', 'LU': 'Luxemburg'}
Zoals je in dit voorbeeld ziet, hebben we voor de sleutel "BE" de waarde "België" gegeven en daarna aan dezelfde sleutel de waarde "Belgium" gegeven. Als je de dictionary uitprint zie je dat "België" overschreven werd door "Belgium".
Elementen oproepen
[bewerken]Individuele elementen van een dictionary kunnen worden opgeroepen door hun sleutel in vierkante haken achter de variabelenaam te zetten. Bijvoorbeeld:
Python-code: Index
# Dictionary met landcodes als sleutels en landnamen als waarden
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
print(country_codes["LU"])
Output:
Luxemburg
Let wel, als er een sleutel wordt opgegeven die niet bestaat in de dictionary krijgt u een foutmelding, namelijk een KeyError. In het volgende voorbeeld hebben we als sleutel "DE" opgegeven.
Traceback (most recent call last):
File "k.py", line 4, in <module>
print(country_codes["DE"])
KeyError: 'DE'
Als je niet wil dat jouw programma stopt, kan je gebruik maken van de functie .get
Python-code: Index
# Opzoeking onbestaande sleutel in dictionary
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
print(country_codes.get('DE'))
Output:
None
Zo kan jouw programma gewoon verder lopen, en kan je eventueel deze fout met een if-statement afhandelen.
Elementen toevoegen
[bewerken]Een waarde toevoegen is eveneens simpel, het is bijna hetzelfde als het declararen van een variabele:
Python-code: Element toevoegen in een dictionary
# Dictionary met landcodes als sleutels en landnamen als waarden
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
# Een element toevoegen in een dictionary
country_codes["DE"] = "Duitsland"
print(country_codes)
Output::
{'DE': 'Duitsland', 'LU': 'Luxemburg', 'BE': 'België', 'NL': 'Nederland'}
Als je een element toevoegd met een sleutel die al bestond in de lijst, wordt het oorspronkelijke element simpelweg vervangen. Je zult dus geen foutmeldingen krijgen. bijvoorbeeld:
Python-code: Element vervangen in een dictionary
# Dictionary met landcodes als sleutels en landnamen als waarden
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
# Een element vervangen in een dictionary
country_codes["BE"] = "Belgium"
print(country_codes)
Output:
{'NL': 'Nederland', 'BE': 'Belgium', 'LU': 'Luxemburg'}
Elementen verwijderen
[bewerken]Net zoals bij een list kan door middel van het sleutelwoord del men elementen verwijderen:
Python-code: del
# Dictionary met landcodes als sleutels en landnamen als waarden.
country_codes = {"BE": "België", "LU": "Luxemburg" ,"NL": "Nederland"}
# Voorbeeld van het gebruik van del.
del country_codes["BE"]
# Uitprinten van de dictionary.
print(country_codes)
Output:
{'LU': 'Luxemburg', 'NL': 'Nederland'}
del moet gevolgd worden door de dictionary met de sleutel van het element die je wilt verwijderen.
Sets
[bewerken]Een set aanmaken
[bewerken]Een set is ook vergelijkbaar met een lijst. Het verschil is dat een set geen volgorde kent en dat dubbele objecten niet toegestaan zijn. Objecten zijn niet gekoppeld aan een nummer (zoals bij een lijst of een tupel), maar evenmin aan een sleutel (zoals bij een woordenboek). De reden om een set te gebruiken is omdat een set veel sneller is (O(lg n)) dan een lijst of tupel (O(n)), zeker voor een groot aantal elementen. Sets zijn ook efficiënter voor het toevoegen en verwijderen van data en testen of een waarde tot de set behoort.
Python-code: Sets
#Set met verschillende soorten waardes.
names_and_numbers_and_others = {'Piet', 42, 'Jan', 4.2, 'Klaas', False}
print(names_and_numbers_and_others)
{False, 4.2, 'Piet', 'Jan', 42, 'Klaas'}
Sets hebben geen volgorde. Toegevoegde waarden worden in een niet gedefinieerde positie geplaatst en de positie kan wijzigen.
>>> mind.add('duplicate value')
>>> mind.add('duplicate value')
>>> mind
set([0, 'a string', 40, 42, 'hello', 'duplicate value'])
Een set kan een waarde slechts eenmaal bevatten, dit in tegenstelling tot lijsten, tupels en woordenboeken. Ook kan een set niet alle soorten objecten bevatten. Een set kan enkel onveranderlijke maar hashbare (d.w.z. kan er een hash waarde van berekend worden) objecten bevatten. Zo zijn integers, strings en tupels hashbaar; lijsten, woordenboeken en andere sets (behalve frozensets) zijn dat niet en kunnen dus niet in een set opgenomen worden. Voorbeeld van een hashwaarde; er zijn 2 kippen, 3 koeien en 2 paarden. Samen geven ze een hashwaarde van 7 (dieren).
Frozenset
[bewerken]Een frozenset is een 'bevroren' versie van een set (zoals een tupel een 'bevroren' lijst is).
>>> frozen=frozenset(['life','universe','everything'])
>>> frozen
frozenset(['universe', 'life', 'everything'])