Möchten Sie sich in die Welt der Python-Dictionaries vertiefen? Dieses Tutorial führt Sie durch die vielfältigen Methoden von Python-Dictionaries, die Ihnen das Lesen, Ändern und die Ausführung zahlreicher Operationen ermöglichen.
Zunächst werden wir die Grundlagen der Python-Dictionaries wiederholen. Anschließend erstellen wir ein Beispiel-Dictionary, das wir dann mithilfe der Python-Dictionary-Methoden bearbeiten werden.
Legen wir los…
Ein Blick auf Python-Dictionaries
Dictionaries, auch bekannt als Assoziativspeicher oder Abbildungstabellen, sind in Python integrierte Datenstrukturen. Sie speichern Elemente in Form von Schlüssel-Wert-Paaren, wodurch eine Beziehung oder Zuordnung zwischen Schlüsseln und Werten definiert wird.
Die Schlüssel in einem Dictionary müssen eindeutig und unveränderlich sein (also ‚hashable‘). Der Schlüssel ermöglicht es, den entsprechenden Wert abzurufen, oder Sie nutzen die eingebauten Methoden, die wir Ihnen im Folgenden vorstellen.
Beim Erstellen eines Python-Dictionaries haben Sie die Wahl: Sie können es entweder mit Schlüssel-Wert-Paaren initialisieren oder ein leeres Dictionary erstellen und die Paare nachträglich hinzufügen.
>>> dict1 = {'sprache':'Python','mag':True}
>>> type(dict1)
<class 'dict'>
# Alternativ:
>>> dict1 = {}
>>> dict1['sprache']='Python'
>>> dict1['mag']=True
Python-Dictionary-Methoden für typische Anwendungen
Hinweis: Für die Codebeispiele ist Python 3.7 oder eine neuere Version erforderlich.
Sie können den Code in einer Python-REPL (Read-Eval-Print-Loop) ausprobieren oder den Online-Python-Editor von wdzwdz nutzen.
>>> person = {'name':'Alice',
... 'stadt':'Portland',
... 'interesse':'Programmierung',
... 'beruf':'Entwicklerin'
... }
Nachdem wir unser Dictionary `person` initialisiert haben, werden wir uns nun den verschiedenen Dictionary-Methoden zuwenden.
Zugriff auf die Dictionary-Schlüssel mit `keys()`
Eine häufige Aufgabe ist der Zugriff auf alle Schlüssel, Werte oder Schlüssel-Wert-Paare eines Dictionaries. Mit der Methode `keys()` erhalten Sie eine Auflistung der Schlüssel:
>>> person.keys() dict_keys(['name', 'stadt', 'interesse', 'beruf'])
Zugriff auf die Dictionary-Werte mit `values()`
Die Methode `values()` gibt alle Werte des Dictionaries zurück. Dies ist nützlich, wenn Sie die Werte weiterverarbeiten möchten.
So greifen wir auf alle Werte des `person`-Dictionaries zu:
>>> person.values() dict_values(['Alice', 'Portland', 'Programmierung', 'Entwicklerin'])
Abrufen von Schlüssel-Wert-Paaren mit `items()`
Die Methode `items()` liefert eine Liste von Tupeln, die jeweils ein Schlüssel-Wert-Paar repräsentieren. Aufgerufen für das `person`-Dictionary, erhalten wir somit eine Liste von Tupeln:
>>> person.items()
dict_items([('name', 'Alice'), ('stadt', 'Portland'), ('interesse', 'Programmierung'),
('beruf', 'Entwicklerin')])
Erstellen einer flachen Kopie mit `copy()`
Die Methode `copy()` erstellt eine flache Kopie eines Python-Dictionaries.
>>> person_kopie = person.copy()
Hier ist `person_kopie` eine flache Kopie von `person`. Ändern wir diese Kopie, indem wir den Wert des Schlüssels ’name‘ zu ‚Bob‘ ändern.
>>> person_kopie['name'] = 'Bob' >>> person_kopie
Wenn wir nun den Inhalt von `person_kopie` prüfen, sehen wir, dass der ’name‘ auf ‚Bob‘ aktualisiert wurde.
{
'name': 'Bob',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin'
}
Das ursprüngliche `person`-Dictionary wurde aber nicht verändert:
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin'
}
Setzen von Standardwerten mit `setdefault()`
Häufig kommt es vor, dass bei der Arbeit mit Python-Dictionaries eine `KeyError`-Ausnahme auftritt, wenn ein Schlüssel nicht vorhanden ist. Hier ein Beispiel, wenn wir versuchen, auf den Schlüssel ‚alter‘ zuzugreifen:
>>> person['alter'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'alter'
Sie können solche Fehler vermeiden, indem Sie die Methoden `setdefault()` oder `get()` anstelle des direkten Zugriffs verwenden.
Die Methode `setdefault(key)` gibt `dict[key]` zurück, falls der Schlüssel im Dictionary existiert.
>>> person.setdefault('name')
'Alice'
Wenn der Schlüssel nicht existiert, wird er mit dem Standardwert `None` zum Dictionary hinzugefügt.
>>> person.setdefault('adresse')
>>> person
Hier existierte der Schlüssel ‚adresse‘ nicht im Dictionary `person`, wurde aber mit dem Standardwert `None` hinzugefügt.
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': None
}
Nun können wir den Wert von ‚adresse‘ setzen:
>>> person['adresse'] = "10, xyz Straße"
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße'
}
Sie können den Wert auch direkt im Methodenaufruf angeben:
>>> person.setdefault('land','USA')
'USA'
>>> person
Da der Schlüssel ‚land‘ ursprünglich nicht existierte, sehen wir, dass er mit dem Wert ‚USA‘ hinzugefügt wurde.
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße',
'land': 'USA'
}
Abrufen eines bestimmten Werts mit `get()`
Die Methode `get()` gibt den Wert des übergebenen Schlüssels zurück. Optional können Sie einen Standardwert angeben, der zurückgegeben wird, falls der Schlüssel nicht existiert.
Wenn wir den Wert des Schlüssels ’name‘ abfragen, erhalten wir ‚Alice‘, da der Schlüssel existiert:
>>> person.get('name')
'Alice'
Das Dictionary `person` hat keinen Schlüssel ‚gpa‘. Wenn wir versuchen, seinen Wert abzurufen, erhalten wir in der REPL nichts, aber `None`, wenn wir den Wert ausdrucken.
>>> person.get('gpa')
>>> print(person.get('gpa'))
None
Wenn wir jedoch einen Standardwert angeben, wird dieser anstelle von `None` zurückgegeben.
>>> person.get('gpa','nicht gefunden')
'nicht gefunden'
Die `get()`-Methode fügt jedoch den Schlüssel ‚gpa‘ nicht zum Dictionary hinzu.
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße',
'land': 'USA'
}
`setdefault()` vs. `get()`: Die Unterschiede
Obwohl sowohl `setdefault()` als auch `get()` zur Behandlung von `KeyError` genutzt werden können, hier noch einmal die Unterschiede:
- `dict.setdefault(key,val)` fügt den Schlüssel mit `val` als Standardwert hinzu. Wenn `val` fehlt, wird der Schlüssel mit dem Standardwert `None` hinzugefügt.
- `dict.get(key,val)` gibt den zum Schlüssel gehörigen Wert zurück. Falls der Schlüssel fehlt, wird `val` (wenn angegeben) oder `None` zurückgegeben. Der Schlüssel wird nicht hinzugefügt.
Sie können auch `defaultdict` in Python nutzen, um `KeyError` effizienter zu behandeln.
Aktualisieren von Dictionary-Inhalten mit `update()`
Mit der Methode `update()` können Sie ein bestehendes Dictionary mit Schlüssel-Wert-Paaren aus einem anderen Dictionary oder iterierbaren Elementen aktualisieren.
Definieren wir ein Dictionary `mehr_details` und aktualisieren damit das `person`-Dictionary:
>>> mehr_details = {'hobby':'singen', 'mag':'süßigkeiten'}
>>> person.update(mehr_details)
Wie die Ausgabe zeigt, wurden die Schlüssel ‚hobby‘ und ‚mag‘ zum `person`-Dictionary hinzugefügt.
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße',
'land': 'USA',
'hobby': 'singen',
'mag': 'süßigkeiten'
}
Entfernen des zuletzt hinzugefügten Elements mit `popitem()`
Die Methode `popitem()` entfernt und gibt das zuletzt hinzugefügte Schlüssel-Wert-Paar zurück.
>>> person.popitem()
('mag', 'süßigkeiten')
Der Aufruf von `popitem()` auf dem `person`-Dictionary gibt das Schlüssel-Wert-Paar (‚mag‘, ’süßigkeiten‘) zurück, das zuletzt hinzugefügt wurde.
Zusätzlich wird dieses Paar aus dem Dictionary entfernt. Dies können wir durch Überprüfung des Dictionary-Inhalts bestätigen:
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße',
'land': 'USA',
'hobby': 'singen'
}
Entfernen eines Dictionary-Elements mit `pop()`
Die Methode `popitem()` entfernt das letzte Schlüssel-Wert-Paar, aber was, wenn wir ein anderes Element entfernen möchten?
Hier kommt die Methode `pop()` ins Spiel: `dict.pop(key)` gibt den Wert des entsprechenden Schlüssels zurück und entfernt gleichzeitig das Schlüssel-Wert-Paar aus dem Dictionary.
Ein Beispiel:
>>> person.pop('hobby')
'singen'
Nachdem wir das Element mit dem Schlüssel ‚hobby‘ entfernt haben, sehen wir, dass es nicht mehr im Dictionary existiert.
>>> person
{
'name': 'Alice',
'stadt': 'Portland',
'interesse': 'Programmierung',
'beruf': 'Entwicklerin',
'adresse': '10, xyz Straße',
'land': 'USA'
}
Wenn wir einen nicht existierenden Schlüssel übergeben, erhalten wir eine `KeyError`-Ausnahme:
>>> person.pop('alter')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'alter'
Die Ausnahme tritt auf, weil der Schlüssel ‚alter‘ nicht existiert.
Anders als die `list.pop()`-Methode, die standardmäßig das letzte Element entfernt, benötigt `dict.pop()` immer einen Schlüssel. Ein Aufruf ohne Schlüssel verursacht einen Fehler:
>>> person.pop() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: pop expected at least 1 argument, got 0
Löschen aller Elemente mit `clear()`
Die Methoden `pop()` und `popitem()` entfernen jeweils nur ein Schlüssel-Wert-Paar. Wenn Sie alle Elemente löschen möchten, können Sie die Methode `clear()` verwenden.
>>> person.clear()
>>> person
{}
Wie wir sehen, entfernt `clear()` alle Schlüssel-Wert-Paare und das `person`-Dictionary ist nun leer.
Zusammenfassung der Python-Dictionary-Methoden
Hier eine kurze Zusammenfassung der behandelten Methoden:
| Methode | Syntax | Beschreibung |
| keys() | dict1.keys() | Gibt die Schlüssel von `dict1` zurück |
| values() | dict1.values() | Gibt die Werte von `dict1` zurück |
| items() | dict1.items() | Gibt eine Liste aller Schlüssel-Wert-Paare in `dict1` zurück |
| copy() | dict1.copy() | Gibt eine flache Kopie von `dict1` zurück |
| setdefault() | dict1.setdefault(key, default_value) | – Fügt den Schlüssel mit dem optionalen `default_value` zu `dict1` hinzu (Standard ist `None`). – Gibt `dict1[key]` zurück, falls der Schlüssel existiert. |
| get() | dict1.get(key,default_value) | – Gibt `dict1[key]` zurück, falls der Schlüssel existiert, sonst `default_value`. – Wenn der Schlüssel nicht existiert und `default_value` nicht angegeben ist, wird `None` zurückgegeben. |
| update() | dict1.update(iterable1) | Aktualisiert `dict1` mit Schlüssel-Wert-Paaren aus `iterable1` |
| popitem() | dict1.popitem() | Entfernt und gibt das letzte Schlüssel-Wert-Paar aus `dict1` zurück |
| pop() | dict1.pop(key) | – Entfernt und gibt den Wert des Schlüssels `dict1[key]` zurück. – Löst eine `KeyError` aus, falls der Schlüssel nicht existiert. |
| clear() | dict1.clear() | Entfernt alle Elemente aus `dict1` |
Fazit
Sie haben die gebräuchlichsten Methoden kennengelernt, um Lese-, Aktualisierungs- und Löschoperationen in Python-Dictionaries durchzuführen. Zudem haben Sie gesehen, wie `get()` und `setdefault()` genutzt werden können, um `KeyError`-Ausnahmen zu behandeln, indem entweder ein Standardwert zurückgegeben oder ein Eintrag mit einem Standardwert hinzugefügt wird. Sie können ein Python-Dictionary auch nach Schlüssel oder Wert sortieren.
Als Nächstes sollten Sie sich die Methoden der Python-Listen ansehen. Viel Spaß beim Programmieren!