Vorlesungsskript 14

Dictionary-Operationen

Wie Listen sind Dictionarys ein Sammeldatentyp und veränderlich. Während die Elemente einer Liste mit 0, 1, 2 usw. durchnummeriert sind (den Indizes), sind die Objekte in einem Dictionary mit Schlüsseln (engl. keys) verknüpft. Das können, müssen aber nicht Zahlen sein. Es können z.B. auch Strings sein. Die Schlüssel müssen auch nicht in einer lückenlosen Folge auftreten wie Listen-Indizes, und das Dictionary enthält sie in keiner bestimmten Reihenfolge.

Genau gesagt: Schlüssel können beliebige unveränderliche Objekte sein. Listen sind also zum Beispiel nicht erlaubt. Schlüssel sind innerhalb eines Dictionary einmalig; ein Dictionary kann nicht den gleichen Schlüssel zweimal enthalten. Mit jedem Schlüssel ist ein Objekt verknüpft, der Wert (engl. value). Werte können beliebige Objekte sein, hier sind auch veränderliche Objekte erlaubt. Auch kann derselbe Wert beliebig oft in einem Dictionary vorkommen, also beliebig vielen verschiedenen Keys zugeordnet sein.

Hier ist zum Beispiel ein Dictionary, das einigen Wörtern aus Pride and Prejudice ihre Häufigkeit zuordnet. Die Wörter sind die Schlüssel und die Häufigkeiten die Werte:

freq = { 'the': 4421, 'elizabeth': 635, 'friendship': 9, 'hastily': 9 }

Vergleichsoperatoren für Dictionarys

Wie alle bisher besprochenen Datentypen können auch Dictionarys mit den Operatoren == und != auf Gleichheit überprüft werden. Zwei Dictionarys sind gleich, wenn sie die gleichen Schlüssel haben und jedem Schlüssel in beiden Dictionarys gleiche Objekte als Wert zugeordnet sind. Die übrigen Vergleichsoperatoren sind nicht auf Dictionarys anwendbar, da Python für Dictionarys keine Standard-Sortierreihenfolge kennt:

>>> { 'a': 1, 'b': 2 } == { 'b': 2, 'a': 1 }
True
>>> { 'a': 1, 'b': 2 } != { 'b': 2, 'a': 1 }
False
>>> { 'a': 1, 'b': 2 } == { 'a': 2, 'b': 1 }
False
>>> { 'a': 1, 'b': 2 } < { 'a': 2, 'b': 1 }
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: dict() < dict()

Nichtdestruktive Dictionary-Operationen

Hier sind einige der wichtigsten nichtdestruktiven Operationen auf Dictionarys:

Ausdruck	Gibt zurück
`len(d)`	Anzahl der Schlüssel-Wert-Paare im Dictionary `d`
`d[k]`	den Wert, der in dem Dictionary `d` dem Schlüssel `k` zugeordnet ist (enthält das Dictionary den Schlüssel nicht, tritt ein Fehler auf)
`d.get(k)`	den Wert, der in dem Dictionary `d` dem Schlüssel `k` zugeordnet ist (enthält das Dictionary den Schlüssel nicht, wird `None` zurückgegeben)
`d.get(k, default)`	den Wert, der in dem Dictionary `d` dem Schlüssel `k` zugeordnet ist (enthält das Dictionary den Schlüssel nicht, wird der angegebene `default`-Wert zurückgegeben)
`k in d`	`True`, wenn das Dictionary `d` den Schlüssel `k` enthält, sonst `False`
`k not in d`	`True`, wenn das Dictionary `d` den Schlüssel `k` nicht enthält, sonst `False`
`d.copy()`	ein neues Dictionary mit denselben Schlüsseln und Werten wie das Dictionary `d`
`d.keys()`	ein Iterable aller Schlüssel in dem Dictionary `d` (in willkürlicher Reihenfolge)
`list(d.keys())`	eine Liste aller Schlüssel in dem Dictionary `d` (in willkürlicher Reihenfolge)
`d.values()`	ein Iterable aller Werte in dem Dictionary `d` (in willkürlicher Reihenfolge)
`list(d.values())`	eine Liste aller Werte in dem Dictionary `d` (in willkürlicher Reihenfolge)

Zum Beispiel:

>>> d = {'a': 1, 'b': 2}
>>> len(d)
2
>>> d['a']
1
>>> d['b']
2
>>> d['c']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
>>> d.get('a')
1
>>> d.get('b')
2
>>> d.get('c')
>>> d.get('c', 0)
0
>>> d
{'a': 1, 'b': 2}
>>> 'a' in d
True
>>> 'c' in d
False
>>> 1 in d
False
>>> e = d.copy()
>>> e
{'a': 1, 'b': 2}
>>> list(d.keys())
['a', 'b']
>>> list(d.values())
[1, 2]

Destruktive Dictionary-Operationen

Hier sind einige der wichtigsten destruktiven Operationen auf Dictionarys:

Anweisung	Wirkung
`d[k] = x`	Verknüpft in dem Dictionary `d` den Schlüssel `k` mit dem Wert `x` (falls der Schlüssel schon vorher in dem Dictionary vorhanden war, wird die Verknüpfung mit dem alten Wert aufgehoben).
`del d[k]`	Entfernt den Schlüssel `k` aus dem Dictionary `d`.
`d.pop(k)`	Entfernt den Schlüssel `k` aus dem Dictionary `d` und gibt den damit verknüpften Wert zurück. Ist der Schlüssel nicht vorhanden, tritt ein Fehler auf.
`d.pop(k, default)`	Entfernt den Schlüssel `k` aus dem Dictionary `d` und gibt den damit verknüpften Wert zurück. Ist der Schlüssel nicht vorhanden, wird stattdessen der angegebene `default`-Wert zurückgegeben.
`d.setdefault(k, default)`	Falls noch nicht vorhanden, wird der Schlüssel `k` in das Dictionary `d` eingefügt und mit dem Wert `default` verknüpft. Falls bereits vorhanden, wird der bestehende Wert erhalten. (In beiden Fällen wird der nun mit `k` verknüpfte Wert zurückgegeben.)
`d.update(e)`	Fügt die Schlüssel und damit verknüpften Werte aus dem Dictionary `e` zu dem Dictionary `d` hinzu. In `d` bestehende Verknüpfungen werden ersetzt.
`d.clear()`	Entfernt alle Schlüssel aus dem Dictionary `d`.

Zum Beispiel:

>>> d['c'] = 3
>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> del d['c']
>>> d
{'a': 1, 'b': 2}
>>> d.pop('b')
2
>>> d
{'a': 1}
>>> d.pop('c')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
>>> d.pop('c', 0)
0
>>> d
{'a': 1}
>>> d.setdefault('a', 0)
1
>>> d.setdefault('b', 0)
0
>>> d.setdefault('c', 0)
0
>>> d
{'a': 1, 'b': 0, 'c': 0}
>>> d.update({'c': 3, 'd': 4, 'e': 5})
>>> d
{'a': 1, 'b': 0, 'c': 3, 'd': 4, 'e': 5}
>>> d.clear()
>>> d
{}
>>> e
{'a': 1, 'b': 2}

Über Dictionarys iterieren

Auch über Dictionaries kann man mit for-Schleifen iterieren. Standardmäßig wird dabei über die Schlüssel iteriert. Auf die Werte kann man innerhalb des Schleifenkörpers dann mit Hilfe von Indexing-Ausdrücken zugreifen. Zum Beispiel:

freq = { 'the': 4421, 'elizabeth': 635, 'friendship': 9, 'hastily': 9 }
for word in freq:
    print('"{}" kommt {}-mal vor.'.format(word, freq[word]))

Obiges Programm gibt aus (möglicherweise in einer anderen Reihenfolge):

"the" kommt 4421-mal vor.
"elizabeth" kommt 635-mal vor.
"friendship" kommt 9-mal vor.
"hastily" kommt 9-mal vor.

Möchte man über die Werte iterieren, kann man die values-Methode benutzen:

freq = { 'the': 4421, 'elizabeth': 635, 'friendship': 9, 'hastily': 9 }
for f in freq.values():
    print(f)

Obiges Programm gibt aus (möglicherweise in einer anderen Reihenfolge):