14    Zuordnungen 

Die Kategorie Mappings (dt. »Zuordnungen«) enthält Datentypen, die eine Zuordnung zwischen verschiedenen Objekten herstellen. Der einzige Datentyp, der in diese Kategorie fällt, ist das Dictionary (dt. Wörterbuch).

 

14.1    Dictionary – dict 

Der Name des Datentyps dict gibt bereits einen guten Hinweis darauf, was sich dahinter verbirgt: Ein Dictionary enthält beliebig viele Schlüssel-Wert-Paare (engl. key/value pairs), wobei der Schlüssel nicht unbedingt wie bei einer Liste eine ganze Zahl sein muss. Vielleicht ist Ihnen dieser Datentyp schon von einer anderen Programmiersprache her bekannt, wo er als assoziatives Array (u. a. in PHP), Map (u. a. in C++) oder Hash (u. a. in Perl) bezeichnet wird. Der Datentyp dict ist mutabel, also veränderlich.

Im folgenden Beispiel wird erklärt, wie ein dict mit mehreren Schlüssel-Wert-Paaren innerhalb geschweifter Klammern erzeugt wird. Außerdem wird die Assoziation mit einem Wörterbuch ersichtlich:

woerterbuch = {"Germany" : "Deutschland", "Spain" : "Spanien"}

In diesem Fall wird ein dict mit zwei Einträgen angelegt, die durch ein Komma getrennt werden. Beim ersten Eintrag wird dem Schlüssel "Germany" der Wert "Deutschland" zugewiesen. Schlüssel und Wert sind durch einen Doppelpunkt voneinander getrennt. Es müssen nicht notwendigerweise alle Paare in eine Zeile geschrieben werden. Innerhalb der geschweiften Klammern kann der Quellcode beliebig formatiert werden:

woerterbuch = {
              "Germany" : "Deutschland",
              "Spain" : "Spanien",
              "France" : "Frankreich"
              }

Hinter dem letzten Schlüssel-Wert-Paar kann ein weiteres Komma stehen, es wird aber nicht benötigt. Jeder Schlüssel muss im Dictionary eindeutig sein, es darf also kein zweiter Schlüssel mit demselben Namen existieren. Formal ist Folgendes zwar möglich, es wird aber nur das zweite Schlüssel-Wert-Paar ins Dictionary übernommen:

d = {
    "Germany" : "Deutschland",
    "Germany" : "Pusemuckel"
    }

Im Gegensatz dazu brauchen die Werte eines Dictionarys nicht eindeutig zu sein, dürfen also mehrfach vorkommen:

d = {
    "Germany" : "Deutschland",
    "Allemagne" : "Deutschland"
    }

In den bisherigen Beispielen waren bei allen Paaren sowohl der Schlüssel als auch der Wert ein String. Das muss nicht unbedingt so sein:

mapping = {
          0 : 1, 
          "abc" : 0.5, 
          1.2e22 : [1,2,3,4], 
          (1,3,3,7) : "def"
          }

>>> {i: i*i for i in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

>>> {"a": 1, **{"b": 2, "c": 3}}
{'a': 1, 'b': 2, 'c': 3}

In einem Dictionary können beliebige Instanzen, seien sie mutabel oder immutabel, als Werte verwendet werden. Beim Schlüssel dürfen jedoch nur Instanzen unveränderlicher (immutabler) Datentypen verwendet werden. Dabei handelt es sich um alle bisher besprochenen Datentypen – mit Ausnahme der Listen und der Dictionarys selbst. Versuchen Sie beispielsweise, ein Dictionary zu erstellen, in dem eine Liste als Schlüssel verwendet wird, meldet sich der Interpreter mit einem entsprechenden Fehler:

>>> d = {[1,2,3] : "abc"}
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Diese Beschränkung ergibt sich daraus, dass die Schlüssel eines Dictionarys anhand eines aus ihrem Wert errechneten Hash-Wertes verwaltet werden. Prinzipiell lässt sich aus jedem Objekt ein Hash-Wert berechnen; bei veränderlichen Objekten ist dies jedoch wenig sinnvoll, da sich der Hash-Wert bei Veränderung des Objekts ebenfalls ändern würde. Eine solche Veränderung würde beispielsweise die Schlüsselverwaltung eines Dictionarys zerstören. Aus diesem Grund sind veränderliche Objekte »unhashable«, wie die oben dargestellte Fehlermeldung besagt.[ 55 ](In Abschnitt 21.7.1, »Allgemeine Magic Methods«, erfahren Sie, wie Sie die Hash-Berechnung für eigene Datentypen implementieren können. )

Bei einem Dictionary handelt es sich um ein iterierbares Objekt. Es ist daher möglich, ein Dictionary in einer for-Schleife zu durchlaufen. Dabei wird nicht über das komplette Dictionary iteriert, sondern nur über alle Schlüssel. Im folgenden Beispiel durchlaufen wir alle Schlüssel unseres Wörterbuchs und geben sie mit print aus:

for key in woerterbuch: 
    print(key)

Die Ausgabe des Codes sieht erwartungsgemäß folgendermaßen aus:

Germany
Spain
France

Selbstverständlich kann in einer Schleife auch auf die Werte des Dictionarys zugegriffen werden. Dazu bedient man sich des Zugriffsoperators, den wir im Folgenden behandeln werden. Beachten Sie, dass Sie die Größe des Dictionarys nicht verändern dürfen, während es in einer Schleife durchlaufen wird. Die Größe des Dictionarys würde zum Beispiel durch das Hinzufügen oder Löschen eines Schlüssel-Wert-Paares beeinflusst. Sollten Sie es dennoch versuchen, bekommen Sie folgende Fehlermeldung angezeigt:

Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
RuntimeError: dictionary changed size during iteration

Diese Beschränkung gilt ausschließlich für Operationen, die die Größe des Dictionarys beeinflussen, also beispielsweise das Hinzufügen und Entfernen von Einträgen. Sollten Sie in einer Schleife lediglich den zugehörigen Wert eines Schlüssels ändern, tritt kein Fehler auf.

 

14.1.1    Operatoren 

Bisher haben Sie gelernt, was ein Dictionary ist und wie es erzeugt wird. Außerdem sind wir auf einige Besonderheiten eingegangen. Jetzt besprechen wir die für Dictionarys verfügbaren Operatoren.

Tabelle 14.1    Operatoren eines Dictionarys

Im Folgenden werden die Operatoren eines Dictionarys im Detail besprochen. Die meisten der Operatoren werden anhand des Dictionarys woerterbuch erklärt, das folgendermaßen definiert ist:

woerterbuch = {
              "Germany" : "Deutschland",
              "Spain" : "Spanien",
              "France" : "Frankreich"
              }

Länge eines Dictionarys

Um die Länge eines Dictionarys zu bestimmen, wird die eingebaute Funktion len verwendet. Die Länge entspricht dabei der Anzahl von Schlüssel-Wert-Paaren:

>>> len(woerterbuch) 
3 

Zugriff auf einen Wert

Mithilfe des Zugriffsoperators kann auf einen Wert eines Dictionarys zugegriffen werden. Dazu schreiben Sie den entsprechenden Schlüssel in eckigen Klammern hinter den Namen des Dictionarys. Bei dem Beispiel-Wörterbuch könnte ein solcher Zugriff folgendermaßen aussehen:

>>> woerterbuch["Germany"]
'Deutschland'

Dabei erfolgt der Zugriff, indem Werte miteinander verglichen werden und nicht Identitäten. Das liegt daran, dass die Schlüssel eines Dictionarys intern durch ihren Hash-Wert repräsentiert werden, der ausschließlich anhand des Wertes einer Instanz gebildet wird. In der Praxis bedeutet dies, dass beispielsweise die Zugriffe d[1] und d[1.0] äquivalent sind.

Zu guter Letzt werfen wir noch einen Blick darauf, was passiert, wenn auf einen Wert zugegriffen werden soll, der nicht existiert. Der Interpreter antwortet mit einer Fehlermeldung:

>>> d = {}
>>> d[100] 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
KeyError: 100

Löschen eines Schlüssel-Wert-Paares

Um in einem Dictionary einen Eintrag zu löschen, kann das Schlüsselwort del in Kombination mit dem Zugriffsoperator verwendet werden. Im folgenden Beispiel wird der Eintrag "Germany" : "Deutschland" aus dem Dictionary entfernt.

del woerterbuch["Germany"]

Das Dictionary selbst existiert auch dann noch, wenn es durch Löschen des letzten Eintrags leer geworden ist.

Auf bestimmte Schlüssel testen

Ähnlich wie bei den Listen existieren für Dictionarys die Operatoren in und not in, die verwendet werden, um zu testen, ob ein Schlüssel in einem Dictionary vorhanden ist oder nicht. Sie geben das entsprechende Ergebnis als Wahrheitswert zurück:

>>> "France" in woerterbuch
True
>>> "Spain" not in woerterbuch
False

 

14.1.2    Methoden 

Neben den Operatoren sind einige Methoden definiert, die die Arbeit mit Dictionarys erleichtern.

Tabelle 14.2    Methoden eines Dictionarys

Abgesehen von diesen Methoden stellt der Datentyp dict noch eine statische Methode bereit. Das ist eine Methode, die auch ohne konkrete Dictionary-Instanz aufgerufen werden kann.

Tabelle 14.3    Statische Methoden eines Dictionarys

Jetzt werden wir die angesprochenen Methoden noch einmal detailliert und jeweils mit einem kurzen Beispiel im interaktiven Modus erläutern. Alle Beispiele verstehen sich dabei in folgendem Kontext:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Es ist also in jedem Beispiel ein Dictionary d mit drei Schlüssel-Wert-Paaren vorhanden. In den Beispielen werden wir das Dictionary verändern und uns vom Interpreter seinen Wert ausgeben lassen.

d.clear()

Die Methode clear löscht alle Schlüssel-Wert-Paare von d. Sie hat dabei nicht den gleichen Effekt wie del d, da das Dictionary selbst nicht gelöscht, sondern nur geleert wird:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.clear()
>>> d
{}

d.copy()

Die Methode copy erzeugt eine Kopie des Dictionarys d.

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> e = d.copy()
>>> e
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Beachten Sie, dass zwar das Dictionary selbst kopiert wird, es sich bei den Werten aber nach wie vor um Referenzen auf dieselben Objekte handelt. Dies wird durch das folgende Beispiel verdeutlicht.

>>> d1 = {"key" : [1,2,3]}
>>> d2 = d1.copy()
>>> d2["key"].append(4)
>>> d2
{'key': [1, 2, 3, 4]}
>>> d1
{'key': [1, 2, 3, 4]} 

Es wird ein Dictionary d1 angelegt, das ein einziges Schlüssel-Wert-Paar mit einer Liste als Wert enthält. Das Dictionary d1 wird durch einen Aufruf der Methode copy kopiert und anschließend die in der Kopie d2 als Wert referenzierte Liste um ein Element erweitert. Da die Methode copy nur eine oberflächliche Kopie durchführt, enthalten die beiden Dictionarys d1 und d2 eine Referenz auf dieselbe Liste:

>>> d1["key"] is d2["key"]
True 

Die Veränderung dieser Liste führt zu einer Veränderung beider Dictionarys. Eine vollständige Kopie, die die Werte eines Dictionarys mit einbezieht, kann mit dem Modul copy der Standardbibliothek erzeugt werden.

d.get(k, [x])

Die Methode get ermöglicht den Zugriff auf einen Wert des Dictionarys. Im Gegensatz zum Zugriffsoperator wird aber keine Exception erzeugt, wenn der Schlüssel nicht vorhanden ist. Stattdessen wird in diesem Fall der optionale Parameter x zurückgegeben. Sollte x nicht angegeben worden sein, wird er als None angenommen. Die Zeile

wert = d.get(k,x)

kann also als Ersatz für folgenden Code gesehen werden:

if k in d: 
    wert = d[k] 
else: 
    wert = x

Die Methode get kann folgendermaßen verwendet werden:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.get("k2", 1337) 
'v2'
>>> d.get("k5", 1337) 
1337

d.items()

Die Methode items gibt ein iterierbares Objekt über alle Schlüssel-Wert-Paare des Dictionarys zurück. Dieses kann folgendermaßen mit einer for-Schleife durchlaufen werden:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> for paar in d.items():
...     print(paar)
('k1', 'v1')
('k2', 'v2')
('k3', 'v3')

In jedem Schleifendurchlauf enthält die Variable paar das jeweilige Schlüssel-Wert-Paar als Tupel.

d.keys()

Die Methode keys gibt ein iterierbares Objekt über alle Schlüssel des Dictionarys zurück. Im folgenden Beispiel werden alle im Dictionary d vorhandenen Schlüssel mit print ausgegeben:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> for key in d.keys():
...     print(key)
k1
k2
k3

Wir haben eingangs gesagt, dass es keiner speziellen Methode bedarf, um alle Schlüssel eines Dictionarys zu durchlaufen. Die Methode keys kann durch folgenden Code umgangen werden:

>>> for key in d: 
...     print(key)
k1
k2
k3

Dennoch hat die Methode keys ihre Berechtigung, beispielsweise um die Schlüssel eines Dictionarys in eine Liste zu schreiben:

>>> list(d.keys())
['k1', 'k2', 'k3'] 

d.pop(k)

Die Methode pop löscht das Schlüssel-Wert-Paar mit dem Schlüssel k aus dem Dictionary und gibt den Wert dieses Paares zurück:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.pop("k1")
'v1'
>>> d.pop("k3")
'v3'
>>> d
{'k2': 'v2'}

d.popitem()

Die Methode popitem gibt ein willkürliches Schlüssel-Wert-Paar als Tupel zurück und entfernt es aus dem Dictionary. Beachten Sie, dass das zurückgegebene Paar zwar willkürlich, aber nicht zufällig ist:[ 56 ](Das bedeutet, dass die Schlüssel-Wert-Paare in einer von der Implementierung abhängigen Reihenfolge von der Methode popitem zurückgegeben werden. Diese Reihenfolge ist aber nicht zufällig, es könnte beispielsweise stets das zuletzt eingefügte Schlüssel-Wert-Paar zurückgegeben werden. )

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.popitem()
('k3', 'v3') 
>>> d
{'k1': 'v1', 'k2': 'v2'}

Sollte d leer sein, wird eine entsprechende Exception erzeugt:

Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

d.setdefault(k, [x])

Die Methode setdefault fügt das Schlüssel-Wert-Paar {k : x} zum Dictionary d hinzu, sollte der Schlüssel k nicht vorhanden sein. Der Parameter x ist optional und mit None vorbelegt.

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.setdefault("k2", 1337) 
'v2'
>>> d.setdefault("k5", 1337) 
1337
>>> d
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k5': 1337}

Unabhängig davon, ob das Schlüssel-Wert-Paar ins Dictionary übernommen wurde oder nicht, gibt die Methode setdefault den Wert d[k] zurück.

d.update(d2)

Die Methode update erweitert das Dictionary d um die Schlüssel und Werte des Dictionarys d2, das der Methode als Parameter übergeben wird:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> d.update({"k4" : "v4"})
>>> d
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

Sollten beide Dictionarys über einen gleichen Schlüssel verfügen, wird der mit diesem Schlüssel verbundene Wert in d mit dem aus d2 überschrieben:

>>> d.update({"k1" : "python rulez"})
>>> d
{'k1': 'python rulez', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

d.values()

Die Methode values verhält sich ähnlich wie keys – mit dem Unterschied, dass alle Werte durchlaufen werden:

>>> d = {"k1" : "v1", "k2": "v2", "k3": "v3"}
>>> for value in d.values():
...     print(value)
v1
v2
v3

dict.fromkeys(seq, [value])

Die statische Methode fromkeys erzeugt ein neues Dictionary und verwendet dabei die Einträge des iterierbaren Objekts seq als Schlüssel. Der Parameter value ist optional. Sollte er jedoch angegeben werden, wird er als Wert eines jeden Schlüssel-Wert-Paares verwendet:

>>> dict.fromkeys([1,2,3], "python")
{1: 'python', 2: 'python', 3: 'python'}

Wird der Parameter value ausgelassen, wird stets None als Wert eingetragen:

>>> dict.fromkeys([1,2,3]) 
{1: None, 2: None, 3: None}