Ein Wörterbuch (dict) in Python ist eine Datenstruktur, die hashbare Schlüssel mit Werten verknüpft und in anderen Programmiersprachen als größenveränderbare Hashtabelle, Hashmap oder assoziatives Array bekannt ist.
Wörterbücher sind der einzige eingebaute Mapping-Typ in Python.
Keys müssen hashbar und innerhalb des Wörterbuchs eindeutig sein.
Schlüsseltypen können numbers, str oder tuples (aus unveränderlichen Werten) sein.
Sie können keine veränderbaren Datenstrukturen wie lists, dicts oder sets enthalten.
Seit Python 3.7 ist garantiert, dass die Schlüsselreihenfolge eines dict der Reihenfolge entspricht, in der die Einträge eingefügt werden.
values können jeden Datentyp oder jede Datenstruktur haben.
Werte können auch beliebig verschachtelt sein, sie können also Listen von Listen, Unterwörterbücher und andere benutzerdefinierte oder zusammengesetzte Datenstrukturen enthalten.
Wenn ein key gegeben ist, können Wörterbücher einen value in (durchschnittlich) konstanter Zeit abrufen (unabhängig von der Anzahl der Einträge).
Im Vergleich zur Suche nach einem Wert in einer list oder einem array (ohne die index-Position zu kennen) verbraucht ein dict deutlich mehr Speicher, bietet aber einen sehr schnellen Zugriff.
Wörterbücher sind besonders nützlich in Szenarien, in denen die Sammlung von Elementen groß ist und häufig darauf zugegriffen und sie aktualisiert werden muss.
Wörterbücher lassen sich auf viele Arten erstellen.
Die beiden einfachsten bestehen darin, den dict()-Konstruktor zu verwenden oder ein dict-Literal zu deklarieren.
dict()
dict() (der Konstruktor für die Wörterbuchklasse) kann mit jedem Iterable von key, value-Paaren oder mit einer Reihe von <name>=<value>-Argumenten verwendet 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}
Ein dict kannst du auch direkt als Wörterbuch-Literal eingeben, indem du geschweifte Klammern ({}) verwendest, die key : value-Paare einschließen:
>>> whale = {"name": "Blue Whale", "speed": 35, "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}
Du kannst auf einen Eintrag in einem Wörterbuch über einen Schlüssel in eckigen ([]) Klammern zugreifen.
Wenn ein key im dict nicht existiert, wird ein KeyError ausgelöst:
>>> bear["speed"]
40
>>> bear["color"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'color'
Wenn du über die Methode .get(<key>, <default value>) auf einen Eintrag zugreifst, kannst du den KeyError vermeiden:
>>> bear.get("color", 'not found')
'not found'
Du kannst den value eines Eintrags ändern, indem du seinem Schlüssel etwas 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 kannst du auf dieselbe Weise hinzufügen:
# 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}
Mit der Methode .pop(<key>) kannst du einen Eintrag aus einem Wörterbuch löschen.
.pop() entfernt das (key, value)-Paar und gibt den value zurück, damit du ihn weiterverwenden kannst.
Wie .get() akzeptiert .pop(<key>) ein zweites Argument (dict.pop(<key>, <default value>)), das zurückgegeben wird, wenn der key nicht gefunden wird.
So 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'
Wenn du mit for item in dict oder while item durch ein Wörterbuch schleifst, werden standardmäßig nur die Schlüssel durchlaufen.
Auf die Werte kannst du innerhalb derselben Schleife über eckige Klammern zugreifen:
>>> for key in bear:
>>> print((key, bear[key])) #this forms a tuple of (key, value) and prints it.
('name', 'Black Bear')
('speed', 40)
('land_animal', True)
Du kannst auch die Methode .items() verwenden, die automatisch (key, value)-Tupel 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 die Methode .keys() die keys zurück und die Methode .values() die values.
In dieser Übung verwaltest du ein Inventarsystem.
Das Inventar sollte nach dem Namen der Gegenstände organisiert sein und die Anzahl der verfügbaren Gegenstände im Blick behalten.
Du musst dich um das Hinzufügen von Gegenständen zu einem Inventar kümmern.
Jedes Mal, wenn ein Gegenstand in einer gegebenen Liste auftaucht, sollte seine Menge im Inventar um 1 erhöht werden.
Außerdem musst du das Löschen von Gegenständen aus einem Inventar handhaben, indem du die Mengen auf Anfrage um 1 verringerst.
Schließlich implementierst du eine Funktion, die alle Schlüssel-Wert-Paare eines gegebenen Inventars als list von tuples zurückgibt.
Implementiere die Funktion create_inventory(<input list>), die aus einer Eingabeliste von Gegenständen ein „Inventar“ erstellt.
Sie sollte ein dict zurückgeben, das jeden Gegenstandsnamen mit der jeweiligen Menge paart.
>>> create_inventory(["coal", "wood", "wood", "diamond", "diamond", "diamond"])
{"coal":1, "wood":2, "diamond":3}
Implementiere die Funktion add_items(<inventory dict>, <item list>), die eine Liste von Gegenständen zum übergebenen Inventar hinzufügt:
>>> add_items({"coal":1}, ["wood", "iron", "coal", "wood"])
{"coal":2, "wood":2, "iron":1}
Implementiere die Funktion decrement_items(<inventory dict>, <items list>), die eine list von Gegenständen entgegennimmt.
Deine Funktion sollte 1 von der Anzahl eines Gegenstands für jedes Mal abziehen, wenn dieser Gegenstand in der list auftaucht:
>>> decrement_items({"coal":3, "diamond":1, "iron":5}, ["diamond", "coal", "iron", "iron"])
{"coal":2, "diamond":0, "iron":3}
Die Anzahl der Gegenstände im Inventar darf nicht unter 0 fallen.
Wenn die Anzahl, mit der ein Gegenstand in der Eingabe-list auftaucht, die verfügbare Menge übersteigt, sollte die für diesen Gegenstand angegebene Menge bei 0 bleiben.
Weitere Anfragen zum Verringern der Anzahl sollten ignoriert werden, sobald die Anzahl auf null fällt.
>>> decrement_items({"coal":2, "wood":1, "diamond":2}, ["coal", "coal", "wood", "wood", "diamond"])
{"coal":0, "wood":0, "diamond":1}
Implementiere die Funktion remove_item(<inventory dict>, <item>), die einen Gegenstand und seine Anzahl vollständig aus einem Inventar entfernt:
>>> remove_item({"coal":2, "wood":1, "diamond":2}, "coal")
{"wood":1, "diamond":2}
Wenn der Gegenstand im Inventar nicht gefunden wird, sollte die Funktion das ursprüngliche Inventar unverändert zurückgeben.
>>> remove_item({"coal":2, "wood":1, "diamond":2}, "gold")
{"coal":2, "wood":1, "diamond":2}
Implementiere die Funktion list_inventory(<inventory dict>), die ein Inventar entgegennimmt und eine Liste mit (item, quantity)-Tupeln zurückgibt.
Die Liste sollte nur die verfügbaren Gegenstände enthalten (mit einer Menge größer als null):
>>> list_inventory({"coal":7, "wood":11, "diamond":2, "iron":7, "silver":0})
[('coal', 7), ('diamond', 2), ('iron', 7), ('wood', 11)]
Melde dich bei Exercism an, um Python mit 17 Konzepte146 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.