Python Dictionaries (Wörterbücher)

Einführung

In Python ist ein Dictionary (Wörterbuch) eine geordnete (seit Python 3.7) Sammlung von Schlüssel: Wert-Paaren. Dictionaries werden verwendet, um Datenwerte auf eine Weise zu speichern, die veränderbar (mutable), indiziert ist und keine doppelten Schlüssel zulässt. Die Hauptoperationen für ein Dictionary sind das Speichern eines Wertes mit einem Schlüssel und das Extrahieren des Wertes anhand des Schlüssels.

Zum Beispiel können Sie ein Dictionary erstellen, um Informationen über eine Katze zu speichern:

## Dictionary: Sammlung von Schlüssel-Wert-Paaren
my_cat = {
    'size': 'fat',          ## key: 'size', value: 'fat'
    'color': 'gray',        ## key: 'color', value: 'gray'
    'disposition': 'loud'   ## key: 'disposition', value: 'loud'
}

In diesem Lab lernen Sie, wie man Dictionaries erstellt, auf deren Daten zugreift und diese modifiziert, wie man über sie iteriert und welche verschiedenen Hilfsmethoden (Utility Methods) man effektiv nutzen kann, um mit ihnen zu arbeiten.

Zugriff auf und Modifikation von Dictionary-Daten

In diesem Schritt lernen Sie, wie man ein Dictionary erstellt, neue Schlüssel-Wert-Paare hinzufügt, bestehende aktualisiert und Werte mithilfe des Subskript-Operators [] abruft.

Sie können einen Dictionary-Eintrag hinzufügen oder aktualisieren, indem Sie dem Schlüssel mithilfe des []-Operators einen Wert zuweisen. Wenn der Schlüssel bereits existiert, wird sein Wert aktualisiert. Wenn der Schlüssel nicht existiert, wird ein neues Schlüssel-Wert-Paar hinzugefügt.

Hinweis: Wenn Sie mit der Verwendung von WebIDE (ähnlich VS Code) nicht vertraut sind, lernen Sie dies bitte zuerst in diesem Lab.

Beginnen wir mit der Erstellung einer Datei, in die wir unseren Code schreiben.

Öffnen Sie zuerst die Datei main.py im Verzeichnis ~/project über den Dateiexplorer auf der linken Seite.

Fügen Sie nun den folgenden Code zu main.py hinzu. Dieser Code definiert ein Dictionary und fügt ihm anschließend ein neues Schlüssel-Wert-Paar hinzu.

## Add or update dictionary entry using subscript operator
my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
my_cat['age_years'] = 2  ## Add new key-value pair
print(my_cat)

Um das Skript auszuführen, öffnen Sie ein Terminal und führen Sie den folgenden Befehl aus:

python3 main.py

Sie sollten das aktualisierte Dictionary auf der Konsole ausgegeben sehen:

{'size': 'fat', 'color': 'gray', 'disposition': 'loud', 'age_years': 2}

Sie können einen Wert auch abrufen, indem Sie den Schlüssel innerhalb des Subskript-Operators [] verwenden. Modifizieren wir die Datei main.py, um auf den Wert zuzugreifen, der dem Schlüssel 'size' zugeordnet ist, und diesen auszugeben.

Ersetzen Sie den Inhalt von main.py durch den folgenden Code:

my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
print(my_cat['size'])

Führen Sie das Skript erneut aus:

python3 main.py

Die Ausgabe wird der Wert des Schlüssels 'size' sein:

fat

Beachten Sie, dass Python einen KeyError auslöst, wenn Sie versuchen, auf einen Schlüssel zuzugreifen, der sich nicht im Dictionary befindet. Sehen wir uns dies in Aktion an. Ersetzen Sie den Code in main.py durch diesen:

my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
print(my_cat['eye_color'])

Führen Sie das Skript aus:

python3 main.py

Dies führt zu einem KeyError, da der Schlüssel 'eye_color' nicht im my_cat-Dictionary existiert.

Traceback (most recent call last):
  File "/home/labex/project/main.py", line 5, in <module>
    print(my_cat['eye_color'])
KeyError: 'eye_color'

Zur Verifizierung setzen Sie main.py bitte auf das erste Beispiel zurück, das einen neuen Schlüssel hinzufügt und das gesamte Dictionary ausgibt.

## Add or update dictionary entry using subscript operator
my_cat = {
 'size': 'fat',
 'color': 'gray',
 'disposition': 'loud',
}
my_cat['age_years'] = 2  ## Add new key-value pair
print(my_cat)

Iterieren über Dictionaries

In diesem Schritt erkunden Sie verschiedene Möglichkeiten, eine Schleife über ein Dictionary zu durchlaufen. Python bietet mehrere Methoden, um über die Schlüssel, die Werte oder beides eines Dictionaries zu iterieren.

Iteration über Werte mit values()

Die Methode values() gibt ein View-Objekt zurück, das eine Liste aller Werte im Dictionary anzeigt. Sie können über dieses Objekt iterieren, um auf jeden Wert zuzugreifen.

Löschen Sie den Inhalt der Datei main.py und fügen Sie den folgenden Code hinzu:

## Iterate over dictionary values using .values() method
pet = {'color': 'red', 'age': 42}
for value in pet.values():  ## Loop through all values
    print(value)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe zeigt jeden Wert in einer neuen Zeile an:

red
42

Iteration über Schlüssel mit keys()

Ähnlich gibt die Methode keys() ein View-Objekt zurück, das die Schlüssel des Dictionaries enthält. Obwohl Sie pet.keys() verwenden können, ist die direkte Iteration über das Dictionary selbst der gebräuchlichere und Python-typischere Weg, um über seine Schlüssel zu iterieren.

Aktualisieren Sie main.py mit dem folgenden Code:

## Iterating over dictionary directly loops through keys (default behavior)
pet = {'color': 'red', 'age': 42}
for key in pet:  ## Equivalent to for key in pet.keys()
    print(key)

Führen Sie das Skript aus:

python3 main.py

Sie sehen die Schlüssel ausgegeben:

color
age

Iteration über Schlüssel-Wert-Paare mit items()

Die Methode items() ist sehr nützlich, wenn Sie während der Iteration sowohl den Schlüssel als auch den Wert benötigen. Sie gibt ein View-Objekt zurück, bei dem jedes Element ein (Schlüssel, Wert)-Tupel ist.

Aktualisieren Sie main.py, um items() zu verwenden:

## Iterate over key-value pairs using .items() method
pet = {'color': 'red', 'age': 42}
for key, value in pet.items():  ## Unpack tuple into key and value
    print(f'Key: {key} Value: {value}')

Hier verwenden wir das Tupel-Unpacking (for key, value in ...), um das erste Element des Tupels in jeder Iteration key und das zweite value zuzuweisen.

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe sind formatierte Strings, die jedes Schlüssel-Wert-Paar anzeigen:

Key: color Value: red
Key: age Value: 42

Sicherer Zugriff und Hinzufügen von Elementen

In diesem Schritt lernen Sie, wie Sie Werte sicher abrufen können, ohne einen KeyError auszulösen, und wie Sie Elemente bedingt hinzufügen.

Sicherer Zugriff mit get()

Wie Sie in Schritt 1 gesehen haben, löst der Versuch, mit [] auf einen nicht existierenden Schlüssel zuzugreifen, einen KeyError aus. Die Methode get() bietet eine sicherere Möglichkeit, auf Schlüssel zuzugreifen. Sie gibt den Wert für einen Schlüssel zurück, wenn dieser existiert, gibt jedoch None zurück, anstatt einen Fehler auszulösen, falls er nicht existiert.

Löschen Sie main.py und fügen Sie den folgenden Code hinzu:

## .get() method: safely retrieve value, returns None if key doesn't exist
wife = {'name': 'Rose', 'age': 33}

print(f'My wife name is {wife.get("name")}')
print(f'She is deeply in love with {wife.get("husband")}')

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe zeigt, dass get() den Wert für 'name' und None für den fehlenden Schlüssel 'husband' zurückgegeben hat:

My wife name is Rose
She is deeply in love with None

Sie können get() auch einen Standardwert als zweites Argument übergeben. Dieser Wert wird zurückgegeben, falls der Schlüssel nicht gefunden wird.

Modifizieren Sie main.py, um einen Standardwert anzugeben:

wife = {'name': 'Rose', 'age': 33}

print(f'She is deeply in love with {wife.get("husband", "lover")}')

Führen Sie es erneut aus:

python3 main.py

Nun verwendet die Ausgabe Ihren benutzerdefinierten Standardwert:

She is deeply in love with lover

Bedingtes Hinzufügen mit setdefault()

Die Methode setdefault() bietet eine prägnante Möglichkeit, ein Schlüssel-Wert-Paar nur dann hinzuzufügen, wenn der Schlüssel noch nicht existiert. Sie prüft auf den Schlüssel; wenn er vorhanden ist, gibt sie den Wert des Schlüssels zurück. Wenn er nicht vorhanden ist, fügt sie den Schlüssel mit dem angegebenen Wert ein und gibt diesen Wert zurück.

Aktualisieren Sie main.py, um setdefault() zu verwenden:

wife = {'name': 'Rose', 'age': 33}
wife.setdefault('has_hair', True) ## 'has_hair' does not exist, so it's added.
wife.setdefault('name', 'Lily') ## 'name' exists, so the dictionary is not changed.
print(wife)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe zeigt, dass 'has_hair' hinzugefügt wurde, der Wert für 'name' jedoch nicht aktualisiert wurde:

{'name': 'Rose', 'age': 33, 'has_hair': True}

Entfernen von Elementen aus einem Dictionary

In diesem Schritt üben Sie verschiedene Methoden zum Entfernen von Elementen aus einem Dictionary.

Entfernen mit pop()

Die Methode pop() entfernt ein Element mit dem angegebenen Schlüssel und gibt dessen Wert zurück. Wenn der Schlüssel nicht gefunden wird, löst sie einen KeyError aus, es sei denn, es wird ein Standardwert angegeben.

Löschen Sie main.py und fügen Sie den folgenden Code hinzu, um pop() in Aktion zu sehen:

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_value = wife.pop('age')
print(f"Removed value: {removed_value}")
print(wife)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe zeigt den entfernten Wert und das Dictionary nach der Entfernung:

Removed value: 33
{'name': 'Rose', 'hair': 'brown'}

Entfernen mit popitem()

Die Methode popitem() entfernt das zuletzt eingefügte Element in einem Dictionary (in Python 3.7+). Sie gibt das entfernte Element als (Schlüssel, Wert)-Tupel zurück.

Modifizieren Sie main.py, um popitem() zu verwenden:

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_item = wife.popitem()
print(f"Removed item: {removed_item}")
print(wife)

Führen Sie das Skript aus:

python3 main.py

Das letzte Element, ('hair', 'brown'), wird entfernt und ausgegeben:

Removed item: ('hair', 'brown')
{'name': 'Rose', 'age': 33}

Entfernen mit dem Schlüsselwort del

Das Schlüsselwort del kann verwendet werden, um ein Element anhand seines Schlüssels zu entfernen. Es gibt den Wert des entfernten Elements nicht zurück.

Modifizieren Sie main.py, um del zu verwenden:

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
del wife['age']
print(wife)

Führen Sie das Skript aus:

python3 main.py

Das Dictionary wird ohne den Schlüssel 'age' ausgegeben:

{'name': 'Rose', 'hair': 'brown'}

Entfernen aller Elemente mit clear()

Die Methode clear() entfernt alle Elemente aus einem Dictionary und lässt es leer zurück.

Modifizieren Sie main.py, um clear() zu verwenden:

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.clear()
print(wife)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe ist ein leeres Dictionary:

{}

Zur Überprüfung stellen Sie bitte sicher, dass Ihr main.py pop() verwendet, um den Schlüssel 'age' zu entfernen, und das endgültige Dictionary ausgibt.

wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.pop('age')
print(wife)

Dictionary-Hilfsoperationen

In diesem Schritt entdecken Sie einige nützliche Dienstprogramme für Dictionaries, einschließlich der Überprüfung der Existenz von Schlüsseln und Werten, der formatierten Ausgabe (Pretty-Printing) und des Zusammenführens von Dictionaries.

Überprüfung auf Schlüssel und Werte mit in

Sie können den Operator in verwenden, um zu prüfen, ob ein Schlüssel in einem Dictionary existiert.

Löschen Sie main.py und fügen Sie diesen Code hinzu:

person = {'name': 'Rose', 'age': 33}

print(f"'name' in person: {'name' in person}")
print(f"'height' in person: {'height' in person}")

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe zeigt True für einen existierenden Schlüssel und False für einen nicht existierenden:

'name' in person: True
'height' in person: False

Sie können in auch zusammen mit der Methode values() verwenden, um zu prüfen, ob ein Wert im Dictionary vorhanden ist.

Modifizieren Sie main.py:

person = {'name': 'Rose', 'age': 33}

print(f"'Rose' in person.values(): {'Rose' in person.values()}")
print(f"33 in person.values(): {33 in person.values()}")
print(f"'John' in person.values(): {'John' in person.values()}")

Führen Sie es aus:

python3 main.py

Ausgabe:

'Rose' in person.values(): True
33 in person.values(): True
'John' in person.values(): False

Formatierte Ausgabe mit pprint

Wenn Dictionaries groß sind, kann das direkte Drucken zu einer langen, schwer lesbaren Zeile führen. Das Modul pprint bietet eine "Pretty-Print"-Funktionalität, um sie lesbarer zu formatieren.

Aktualisieren Sie main.py:

import pprint

wife = {'name': 'Rose', 'age': 33, 'has_hair': True, 'hair_color': 'brown', 'height': 1.6, 'eye_color': 'brown'}
pprint.pprint(wife)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe ist ordentlich formatiert, wobei die Schlüssel alphabetisch sortiert sind:

{'age': 33,
 'eye_color': 'brown',
 'hair_color': 'brown',
 'has_hair': True,
 'height': 1.6,
 'name': 'Rose'}

Zusammenführen von Dictionaries

Sie können zwei Dictionaries mithilfe des Dictionary Unpacking Operators ** (verfügbar in Python 3.5+) zusammenführen. Bei überlappenden Schlüsseln wird der Wert aus dem zweiten Dictionary verwendet.

Aktualisieren Sie main.py mit dem folgenden Code:

dict_a = {'a': 1, 'b': 2}
dict_b = {'b': 3, 'c': 4}
dict_c = {**dict_a, **dict_b}
print(dict_c)

Führen Sie das Skript aus:

python3 main.py

Die Ausgabe ist ein neues Dictionary, das alle Elemente aus beiden enthält. Beachten Sie, dass der Wert für den Schlüssel 'b' 3 ist, der von dict_b stammt.

{'a': 1, 'b': 3, 'c': 4}

Zusammenfassung

Herzlichen Glückwunsch zum Abschluss dieses Labs über Python Dictionaries!

In diesem Lab haben Sie die grundlegenden Operationen für die Arbeit mit einer der leistungsfähigsten Datenstrukturen von Python kennengelernt. Sie haben behandelt:

• Erstellen, Zugreifen und Modifizieren: Verwendung von {} zur Erstellung von Dictionaries und des Subskript-Operators [] zum Hinzufügen, Aktualisieren und Abrufen von Daten.
• Iteration: Durchlaufen von Schlüsseln, Werten und Schlüssel-Wert-Paaren mithilfe der Methoden keys(), values() und items().
• Sichere Operationen: Verwendung von get(), um KeyError zu vermeiden, und setdefault(), um Elemente bedingt hinzuzufügen.
• Entfernen von Elementen: Verwendung von pop(), popitem(), dem Schlüsselwort del und clear(), um Elemente zu entfernen.
• Nützliche Operationen: Überprüfung der Mitgliedschaft mit dem Operator in, Formatierung der Ausgabe mit pprint und Zusammenführen von Dictionaries mit dem Entpackungsoperator **.

Die Beherrschung von Dictionaries ist ein entscheidender Schritt, um ein versierter Python-Programmierer zu werden. Üben Sie diese Konzepte weiterhin, um komplexere und effizientere Anwendungen zu erstellen.