Dicts in

Über Dicts

Ein Dictionary (dict) in Python ist eine Datenstruktur, die hashbare Schlüssel mit Werten verknüpft und in anderen Programmiersprachen auch als größenveränderliche Hashtabelle, Hashmap oder assoziatives Array bekannt ist. Dictionaries sind der einzige in Python eingebaute Mapping-Typ.

keys müssen hashbar und innerhalb des Dictionaries eindeutig sein. Als Schlüsseltypen kommen numbers, strs oder tuples (aus unveränderlichen Werten) infrage. Sie dürfen keine veränderlichen Datenstrukturen wie lists, dicts oder sets enthalten. Seit Python 3.7 ist garantiert, dass die Reihenfolge der dict-Schlüssel der Reihenfolge entspricht, in der die Einträge eingefügt wurden.

values können von jedem Datentyp oder jeder Struktur sein. Werte können außerdem beliebig verschachtelt sein, sodass sie Listen von Listen, Unter-Dictionaries und andere benutzerdefinierte oder zusammengesetzte Datenstrukturen enthalten können.

Mit einem key kann ein Dictionary einen value in (durchschnittlich) konstanter Zeit abrufen (unabhängig von der Anzahl der Einträge). Verglichen mit der Suche nach einem Wert in einer list oder einem array (ohne die index-Position zu kennen), benötigt ein dict deutlich mehr Speicher, ermöglicht aber einen sehr schnellen Zugriff.

Dictionaries sind besonders nützlich, wenn die Sammlung von Elementen groß ist und häufig darauf zugegriffen und aktualisiert werden muss.

Dictionaries erstellen

Dictionaries lassen sich auf viele verschiedene Arten erstellen, zum Beispiel:

• Mit der Klassenmethode fromkeys().
• Mit Dictionary-Comprehensions.
• Zusammenführen zweier Dictionaries durch Entpacken (**).
• Zusammenführen von Dictionaries mit dem |-Operator (Aktualisierung).
• Mit einer Schleife, um einem zuvor erstellten leeren dict schrittweise Einträge hinzuzufügen.

Die beiden direktesten Methoden sind der Dictionary-Konstruktor und das Dictionary-Literal.

Der Dictionary-Konstruktor

dict() (der Konstruktor der dict-Klasse) kann mit jedem Iterable von key-value-Paaren verwendet werden. Es kann auch mit einer Reihe von <name>=<value>-Argumenten aufgerufen werden:

# Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),
...              ('speed', 23),
...              ('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Using key=value arguments.
>>> bear = dict(name="Black Bear",
...             speed=40,
...             land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}

Die Dokumentation zu dicts beschreibt weitere Varianten und Optionen bei der Verwendung des Konstruktors.

Dictionary-Literale

Ein Dictionary kann auch direkt als Dictionary-Literal geschrieben werden, wobei geschweifte Klammern ({}) die key : value-Paare umschließen. Die Einträge innerhalb der {} können auch in separaten Zeilen stehen:

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

Verschachtelte Dictionaries

Dictionaries können beliebig verschachtelt werden:

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

Auf Werte in einem dict zugreifen

Du kannst in einem Dictionary mit einem Schlüssel in eckigen Klammern auf einen value zugreifen. Wenn ein Schlüssel nicht im Dictionary vorhanden ist, wird ein KeyError ausgelöst:

>>> bear["speed"]
40

>>> bear["color"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'color'

Der Zugriff auf einen Eintrag über die Methode get(<key>, <default value>) kann den KeyError vermeiden:

>>> bear.get("color", 'not found')
'not found'

Auf verschachtelte Dictionary-Einträge zugreifen

Um auf Einträge in verschachtelten Dictionaries zuzugreifen, verwendest du aufeinanderfolgende Klammern. Wenn ein bestimmter Schlüssel fehlt, wird der übliche KeyError ausgelöst:

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

Um den KeyError zu vermeiden, kann .get() verwendet werden, aber die Aufrufe von .get() müssen verkettet werden:

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

Dictionary-Werte ändern oder hinzufügen

Du kannst den value eines Eintrags ändern, indem du seinem Schlüssel einen neuen Wert zuweist:

# Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}

>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}

Neue key:value-Paare können auf dieselbe Weise hinzugefügt werden:

# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}

>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}

Dictionary-Einträge entfernen (mit pop und del)

Mit der Methode <dict>.pop(<key>) kannst du einen Dictionary-Eintrag löschen. <dict>.pop() entfernt das Paar (key, value) und gibt den value zurück, damit du ihn weiterverwenden kannst. Wie <dict>.get() akzeptiert <dict>.pop(<key>) ein zweites Argument (<dict>.pop(<key>, <default value>)), das zurückgegeben wird, wenn der key nicht gefunden wird. Dadurch wird verhindert, dass ein KeyError ausgelöst wird:

# Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'


# The "name" key is now removed from the dictionary.
# Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'


# Using a default argument with .pop() will 
# prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'

Du kannst auch die del-Anweisung verwenden, um einen oder mehrere Einträge zu entfernen. Ein KeyError wird ausgelöst, wenn der zu entfernende Eintrag nicht im Dictionary gefunden wird:

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

Ein Dictionary durchlaufen/iterieren

Wenn du ein Dictionary mit for item in dict oder while item durchläufst, wird standardmäßig über die Schlüssel iteriert. Du kannst innerhalb derselben Schleife mit eckigen Klammern auf die Werte zugreifen:

>>> for key in bear:
...     print((key, bear[key])) # <--This prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

Du kannst auch die Methode .items() verwenden, die Tupel aus (key, value) zurückgibt:

# dict.items() forms (key, value tuples) that can be 
# unpacked and iterated over.
>>> for key, value in whale.items():
...     print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1

Ebenso gibt .keys() die keys und .values() die values zurück.

Für eine ausführliche Erklärung von Dictionaries in Python ist die offizielle Dokumentation ein hervorragender Ausgangspunkt, oder du siehst dir das Tutorial von W3-Schools an.

Dictionary-Funktionalität erweitern: das collections-Modul

Das Modul collections fügt den standardmäßigen sammlungsbasierten Datentypen von Python (dict, set, list, tuple) spezialisierte Funktionalität hinzu. Drei der nützlichsten Dictionary-basierten Klassen sind:

• Counter zählt Elemente automatisch und gibt sie in einem dict zurück, wobei die Elemente die Schlüssel und ihre Anzahlen die Werte sind.
• OrderedDict hat spezialisierte Methoden, um die Reihenfolge von Dictionary-Einträgen festzulegen.
• defaultdict verwendet eine Factory-Methode, um einen Standardwert festzulegen, wenn ein key beim Abrufen oder Zuweisen eines Dictionary-Eintrags nicht gefunden wird.