Datentyp-Hierarchie (Wiederholung)
Zu Deiner besseren Orientierung zeige ich hier nochmals die Datentyp-Hierarchie von Python.
Dictionaries
Ein Dictionary (dict), auch assoziative Liste oder assoziatives Array genannt, ist einer Liste nicht unähnlich. Seine Elemente werden jedoch nicht über Indizes angesprochen. Es werden Schlüssel verwendet. Als Schlüssel sind ausschließlich unveränderliche Datentypen zulässig. Zeichenketten finden in der Praxis am häufigsten Anwendung. Ein Element eines Dictionaries besteht aus einem Schlüssel-Wert-Paar. Die Datentypen der Werte sind, wie schon bei der Liste beliebig.
person = {
"vorname": "Karsten",
"geburtsdatum": {
"tag": 31,
"monat": 10,
"jahr": 1996
},
"hobbies": ["Wassersport", "Informatik"]
}
person
Ein Dictionary wird literal in geschweiften Klammern notiert. Ein leeres Klammerpaar steht für ein leeres Dictionary. Der Zugriff erfolgt, wie bei der Liste, mit Hilfe des Slicing-Operators. Hier wird jedoch kein Index, sondern ein Schlüssel, eingetragen!
>>> person["vorname"]
'Karsten'
>>> person["geburtsdatum"]
{'tag': 31, 'monat': 10, 'jahr': 1996}
>>> person["geburtsdatum"]["jahr"]
1996
>>> person["hobbies"][1]
'Informatik'
Der Zugriff auf die Elemente ist also sehr ähnlich. Der Zugriff auf Dictionary-Elemente mit einem numerischen Schlüssel kann leicht mit dem Index-Zugriff auf eine Liste verwechselt werden.
>>> num_dict = {
1: "Erster Wert",
42: "Zweiter Wert",
"status": True
}
>>> num_dict
{1: 'Erster Wert', 42: 'Zweiter Wert', 'status': True}
>>> num_dict[1]
'Erster Wert'
>>> num_dict[42]
'Zweiter Wert'
>>> num_dict["status"]
True
Die erlaubten Datentypen von Schlüsseln können miteinander kombiniert werden.
Dictionaries können ineinander geschachtelt werden und sind iterierbar. Mittels des in-Operators kannst Du feststellen, ob ein Schlüssel, den Du suchst, in einem Dictionary enthalten ist.
Wichtig: Bei einem Dictionary handelt es sich um einen ungeordneten Datentypen. Das bedeutet, dass die Schlüssel bei einer Iteration nicht zwingend in der Reihenfolge durchlaufen werden, in welcher sie sie dem Dictionary hinzugefügt haben!
Hinweis: Analog zu List Comprehensions, kannst Du dieses dieses Prinzip auch auf Dictionaries anwenden.
Problematisch ist, bei Dictionary Comprehensions quasi auf numerische Schlüssel beschränkt zu sein. Wie es, in speziellen Fällen, dennoch geht, zeigt Dir das übernächste Beispiel. Zuerst aber ein Beispiel, welches die Analogie zu den List Comprehensions offensichtlich macht.
>>> # Dictionary mit den Quadratzahlen zu i
>>> d = {i: i**2 for i in range(1, 6)}
>>> d
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
as (fast) gleiche Beispiel, jedoch als Liste, haben wir oben besprochen.
Denken wir jetzt jedoch etwas komplexer. Nehmen wir an, Du hättest eine Tabelle mit Celsius-Werten, die von Relevanz wären, weil sie Grenz- oder Übergangswerte darstellen.
Du arbeitest mit Amerikanern zusammen, die Temperaturen lieber in Fahrenheit statt Celsius ausdrücken. Folglich möchtest Du diesen Kollegen ein Dictionary mit den korrespondierenden Temperaturangaben Ihrer Celsius-Werte in Fahrenheit zur Verfügung stellen.
>>> celsius = {
"t1": -10.0,
"t2": 0.0,
"t3": 20.0,
"t4": 42.0,
"t5": 100.5
}
>>> fahrenheit = {key:(c*5.0/9.0)+32 for (key,c) in celsius.items()}
>>> fahrenheit
{'t1': 26.444444444444443, 't2': 32.0, 't3': 43.111111111111114, 't4': 55.33333333333333, 't5': 87.83333333333334}
items() sind die Schlüssel-Wert-Paare, eine Sequenz von Tupeln. Der sonstige Aufbau dieser Comprehension sollte Dir (intuitiv) verständlich sein.
Vorhandene Dictionaries kannst Du auspacken (Unpacking), um deren Elemente in ein neues Dictionary zu übertragen. Achtung: Hier sind 2 Asterisk-Zeichen zu notieren.
>>> d1 = {"a": 1, "b":2, "c":3}
>>> d2 = {"z":100, **d1}
>>> d2
{'z': 100, 'a': 1, 'b': 2, 'c': 3}
Die Werte eines Dictionaries können veränderbar oder unveränderbar, von beliebigem Datentyp sein. Bezüglich der Schlüssel dürfen jedoch nur unveränderliche Typen verwendet werden. Die Einschränkung ergibt sich aus der Tatsache, dass die Schlüssel eines Dictionaries intern anhand eines, aus ihrem jeweiligen Wert errechneten, Hash-Werts verwaltet werden.
| Operation | Beschreibung |
|---|---|
len(d) |
Anzahl der Schlüssel-Wert-Paare in d |
d[k] |
Zugriff auf Wert bei Schlüssel k |
del d[k] |
Lösche Schlüssel-Wert-Paar mit Schlüsel k |
k in d |
Prüfung, ob Schlüssel k in d enthalten ist |
k not in d |
Prüfung, ob Schlüssel k nicht in d enthalten ist |
Das Hinzufügen eines Schlüssel-Wert-Paares bedarf keiner expliziten Operation. Definiere einfach ein neues Schlüssel-Wert-Paar und es ist hinzugefügt.
| Methode | Beschreibung |
|---|---|
d.clear() |
Leeren von Dictionary d |
d.copy() |
Kopie von d |
d.get(k[,x]) |
Wert bei Schlüssel k; alternativ Wert x |
d.items() |
iterierbares Objekt mit allen Schlüssel-Wert-Paaren |
d.keys() |
iterierbares Objekt mit allen Schlüsseln |
d.pop(k) |
Wert bei Schlüssel k; Schlüssel-Wert-Paar wird gelöscht |
d.popitem() |
zuletzt eingefügtes Item löschen; Wert wird geliefert. |
d.setdefault(k[,x]) |
Standardwert für den Wert bei Schlüssel k |
d.update(d1) |
d1 zu d hinzufügen; die Werte bei vorhandenden Schlüsseln werden überschreiben |
d.values() |
iterierbares Objekt mit allen Werten |
Vorsicht ist beim Kopieren eines Dictionaries mittels der Methode copy()| geboten. Die Methode fertigt lediglich eine flache Kopie des Dictionaries an, was bei Werten von veränderlichen Datentypen zu einer Aliasierung führt.
>>> d1={"k": [1, 2, 3, 4]}
>>> d2 = d1.copy()
>>> d1
{'k': [1, 2, 3, 4]}
>>> d2
{'k': [1, 2, 3, 4]}
>>> d2["k"][3]=4000
>>> d2
{'k': [1, 2, 3, 4000]}
>>> d1
{'k': [1, 2, 3, 4000]}