Python Dictionaries

Op deze pagina:

Dictionaries zijn lijsten die twee waarden met elkaar verbinden. In andere programmeertalen worden dit hashes, associative arrays en associative lists genoemd. Het zijn Lists, maar dan met op maat gemaakte indexen. De index is nu niet zomaar een nummer, maar heeft in een Dictionary echt een betekenis. Het maken van een Dictionary gaat op gelijke wijze als het maken van een List, maar dan met gekrulde haken {} in plaats van vierkante haken.

Dictionaries zijn 'ordered', wat inhoudt dat de volgorde van de elementen vast staat.

De sleutels in een dictionary moeten uniek zijn, je kunt geen twee sleuetels met dezelfde waarde hebben in een dictionary. De waarden in een dictionary mogen aangepast worden, ze zijn mutable.

Een nieuwe Dictionary mag ook leeg aangemaakt worden.

nieuwe_dictionary = {}

Een Dictionary kan ook gevuld worden tijdens het aanmaken.

fruit_kleur = {'Appels': 'geel',
               'Bananen': 'geel',
               'Peren': 'groen', 
               'Druiven': 'wit', 
               'Aardbeien': 'rood', 
               'Bessen': 'blauw', 
               'Citroenen': 'geel'}

De Dictionary zelf staat tussen gekrulde haken, de indexen en waarden worden van elkaar gescheiden door dubbele punten en de index-waarde combinaties worden van elkaar gescheiden door komma's. Voor de duidelijkheid kan dit over meerdere regels verdeeld worden, de interne structuur van de Dictionary heeft andere regels voor spaties als Python.

Elementen in een Dictionary benaderen

Het benaderen van elementen in een Dictionary lijkt op het benaderen van elementen in een list, maar nu is de index een specifieke waarde in plaats van een nummer. Het benaderen van elementen in een Dictionary via het nummer werkt niet, je moet dus weten welke waarden er in de dictionary staan.

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
print(fruit_kleur['Citroenen']) 

Elementen toevoegen aan een Dictionary

Dictionaries hebben geen genummerde index, dus het maakt niet uit in welke volgorde nieuwe elementen worden toegevoegd. Het toevoegen van een element aan een Dictionary lijkt op het maken van een nieuwe variabele.

fruit_kleur = {}
fruit_kleur['Appels'] = 'geel'

In een Dictionary kunnen niet alleen Strings gebruikt worden als index of waarde, maar ook andere datatypes kunnen hiervoor gebruikt worden. Dit maakt Dictionaries erg veelzijdig.

test_dict = {}
test_dict[3] = "Hond"
test_dict['Groen'] = 42
test_dict['een list'] = [2, 4, 6, 8, 10]
andere_dict = {'a': 1, 'b': 2, 'c': 3}
test_dict['een dict'] = andere_dict

print(test_dict)
# resultaat:
{3: 'Hond', 'Groen': 42, 'een list': [2, 4, 6, 8, 10], 'een dict': {'a': 1, 'b': 2, 'c': 3}}

print(test_dict['een dict'])
# resultaat:
{'a': 1, 'b': 2, 'c': 3}

print(test_dict['een list'][1])
# resultaat:
4

# 'lengte' opvragen met 'len'
print(len(test_dict))
# resultaat:
4

Elementen verwijderen uit een Dictionary

Elementen verwijderen kan met del. Je moet dan wel de index weten van het element dat je wilt verwijderen.

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
del fruit_kleur['Bananen']
print(fruit_kleur) 

Het resultaat:

{'Bessen': 'blauw', 'Aardbeien': 'rood', 'Peren': 'groen', 'Appels': 'geel', 'Citroenen': 'geel', 'Druiven': 'wit'}

De indexen van een Dictionary in een List plaatsen

De methode keys() kan gebruikt worden om de indexen van een Dictionary in een List te plaatsen.

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
fruit_kleuren = fruit_kleur.keys()

for naam in fruit_kleuren:
        print(naam)

Het resultaat:

Citroenen
Appels
Bessen
Peren
Bananen
Druiven
Aardbeien

De waarden in een Dictionary in een List plaatsen

De methode values() kan gebruikt worden om de waarden van een Dictionary in een List te plaatsen.

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
fruit_kleuren = fruit_kleur.values()

for kleuren in fruit_kleuren:
        print(kleuren)

Het resultaat:

rood
geel
geel
blauw
geel
wit
groen

Waarden uit een Dictionary in een String plaatsen

Met de % operator worden waarden via sleutels uit een Dictionary gehaald.

boek_info = { 'titel': 'Python is leuk',
               'paginas': 456,
               'pub_datum': 'December 2016',
               'hoofdstukken': 21,
}
print("het boek heet %(titel)s en werd gepubliceerd in %(pub_datum)s. Het is %(paginas)d paginas dik en heeft %(hoofdstukken)d hoofdstukken." % boek_info)

Het resultaat:

het boek heet Python is leuk en werd gepubliceerd in December 2016. Het is 456 paginas dik en heeft 21 hoofdstukken.

Dictionaries doorlopen

Het doorlopen van Dictionaries vergt wat extra aandacht omdat we hier te maken hebben met gegevensparen, namelijk de index met de bijbehorende waarde.

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
for kleur in fruit_kleur:
        print(kleur)

Je krijgt nu alle indexen, zonder de bijbehorende waarden.De waarden er wel bij kan via:

fruit_kleur = {'Appels': 'geel',
                 'Bananen': 'geel',
                 'Peren': 'groen',
                 'Druiven': 'wit',
                 'Aardbeien': 'rood',
                 'Bessen': 'blauw',
                 'Citroenen': 'geel'
}
for naam, kleur in fruit_kleur.items():
        print("Het fruit is %s en de kleur is %s." % (naam, kleur))

# resultaat:

Het fruit is Appels en de kleur is geel.
Het fruit is Bananen en de kleur is geel.
Het fruit is Peren en de kleur is groen.
Het fruit is Druiven en de kleur is wit.
Het fruit is Aardbeien en de kleur is rood.
Het fruit is Bessen en de kleur is blauw.
Het fruit is Citroenen en de kleur is geel.

Twee dictionaries samenvoegen

De indexen in een dictionary zijn uniek, als je twee dictionaries samenvoegt waar gelijke indexen in voor komen, dan komt die index slechts eenmaal in de samengevoegde dictionary met de laatst toevoegde waarde.

fruit1 = {'Appels': 'geel', 'Bananen': 'groen'}
fruit2 = {'Bananen': 'geel, 'Citroenen': 'geel'}
samen = {**fruit1, **fruit2}

Het resulterende 'samen':

{'Appels': 'geel', 'Bananen': 'geel', 'Citroenen': 'geel'}

In 'fruit1' waren de bananen groen, in 'fruit2' zijn de bananen geel, in de samengeveogde dictionary zijn de bananen nu ook geel.

Een functie maken om twee dictionaries samen te voegen

Je kunt ook een functie maken die twee dictionaries samenvoegt:

def merge_dictionaries(dict1, dict2):
    nwdict = {**dict1, **dict2}
    return nwdict

Een dictionary mooi afdrukken

de standaard string repr voor dictionaries is soms moeilijk te lezen:

fruit = {'Appels': 'geel', 'Bananen': 'geel', 'Citroenen': 'geel'}
print(fruit)

# resultaat:
{'Appels': 'geel', 'Bananen': 'geel', 'Citroenen': 'geel'}

Met de json module kan dit mooier:

import json
print(json.dumps(fruit, indent=4, sort_keys=True))

# resultaat:
{
    "Appels": "geel",
    "Bananen": "geel",
    "Citroenen": "geel"
}

Dit werkt alleen met dictionaries met primare types zoals strings

Het geheugengebruik van dictionaries

Om te zien hoeveel geheugen een dictionary gebruikt kun je sys.getsizeof() gebruiken.

import sys

dict = {}
print(sys.getsizeof(dict))

# lege dictionary geeft:
64

dict['a'] = 1
print(sys.getsizeof(dict))

# dictionary met 1 element geeft:
232

dict['a'] = 'a' * 100000
print(sys.getsizeof(dict))

# dictionary met een element met 100000 karakters geeft:
232

# dictionary maken met 26 elementen:
for letter in 'abcdefghijklmnopqrstuvwxyz':
    dict[letter] = letter
    print(f'{len(dict)} grootte: {sys.getsizeof(dict)}')

# resultaat:
1 grootte: 232
2 grootte: 232
3 grootte: 232
4 grootte: 232
5 grootte: 232
6 grootte: 360
7 grootte: 360
8 grootte: 360
9 grootte: 360
10 grootte: 360
11 grootte: 640
12 grootte: 640
13 grootte: 640
14 grootte: 640
15 grootte: 640
16 grootte: 640
17 grootte: 640
18 grootte: 640
19 grootte: 640
20 grootte: 640
21 grootte: 640
22 grootte: 1176
23 grootte: 1176
24 grootte: 1176
25 grootte: 1176
26 grootte: 1176

Voor een dictionary wordt geheugenruimte gereserveerd in stappen, steeds als er een bepaald aantal meer elementen zijn wordt er extra ruimte gereserveerd.

Bij het leegmaken van een dictionary wordt er niet meteen ruimte vrijgegeven:

for key in list(dict.keys()):
    dict.pop(key)
print(len(dict))
print(sys.getsizeof(dict))

# resultaat:
0 
1176

# dictionary helemaal leegmaken met clear:
dict.clear()
print(sys.getsizeof(dict))

# resultaat:
64

Verwante artikelen