Python Wörterbuch Verstehen Tutorial

Python-Wörterbuch

Ein Wörterbuch in Python ist eine Sammlung von Elementen, auf die über einen bestimmten Schlüssel und nicht über einen Index zugegriffen wird. Was bedeutet das?

Stell dir ein Wörterbuch in der realen Welt vor... wenn du die Bedeutung eines Wortes nachschlagen musst, versuchst du, die Bedeutung anhand des Wortes selbst zu finden und nicht anhand des möglichen Index des Wortes. Python-Wörterbücher funktionieren nach demselben Konzept: Das Wort, dessen Bedeutung du suchst, ist der Schlüssel und die Bedeutung des Wortes ist der Wert; du musst den Index des Wortes in einem Wörterbuch nicht kennen, um seine Bedeutung zu finden.

Initialisierung eines Wörterbuchs in Python

Du kannst ein Wörterbuch in Python auf diese Weise initialisieren:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])

fruit

print(a[0])

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

Zunächst erstellen wir ein Wörterbuch mit dem Namen a, das drei Schlüssel-Wert-Paare enthält: "Apfel": "Obst", "Rote Bete": "Gemüse" und "Kuchen": "Dessert". Die Schlüssel sind Strings, die die Namen der Artikel darstellen, und die Werte sind Strings, die den Typ oder die Kategorie des Artikels darstellen.

Als Nächstes fügen wir dem Wörterbuch a ein neues Schlüssel-Wert-Paar hinzu, indem wir die Syntax a['doughnut'] = 'snack' verwenden. Dies fügt dem Wörterbuch den Schlüssel "doughnut" mit dem entsprechenden Wert "snack" hinzu.

Die dritte Zeile des Codes gibt den Wert aus, der dem Schlüssel "apple" im Wörterbuch a zugeordnet ist. Da "Apfel" ein Schlüssel im Wörterbuch ist, gibt der Code den Wert "Obst" aus.

Die vierte Zeile des Codes versucht, den Wert des Schlüssels 0 im Wörterbuch a zu drucken, der kein gültiger Schlüssel im Wörterbuch ist. Dies führt zu einem KeyError, der ausgelöst wird, wenn du versuchst, auf einen Schlüssel zuzugreifen, der nicht in einem Wörterbuch vorhanden ist.

Python-Wörterbuch-Datentypen

Die Elemente in einem Wörterbuch können jeden Datentyp haben. Schau dir unten noch ein paar Beispiele für ein Wörterbuch an, damit du den Dreh raus hast:

Erstelle ein Wörterbuch a mit vier Schlüssel-Werte-Paaren:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1}

Aktualisiere den Wert des Schlüssels "eins" im Wörterbuch a auf 1,0.

# Update a dictionary
a['one'] = 1.0 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}

Lösche das Schlüssel-Wert-Paar, das mit dem Schlüssel "eins" verbunden ist, aus dem Wörterbuch a.

# Delete a single element
del a['one'] 
print(a)

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}

Entferne alle Schlüssel-Wert-Paare aus dem Wörterbuch a mit der Methode clear().

# Delete all elements in the dictionary
a.clear()
print(a)

{}

Lösche das Wörterbuch a mit dem Schlüsselwort del.

# Delete the dictionary
del a 
print(a)

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined

Es ist wichtig, daran zu denken, dass ein Schlüssel in einem Wörterbuch eindeutig sein muss; es sind keine Duplikate erlaubt. Bei doppelten Schlüsseln gibt Python jedoch keine Fehlermeldung aus, sondern nimmt die letzte Instanz des Schlüssels als gültig an und ignoriert das erste Schlüssel-Wert-Paar einfach. Sieh es dir selbst an:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])

icecream

Python Wörterbuch Verstehen

Das Verstehen von Wörterbüchern ist eine Methode, um ein Wörterbuch in ein anderes Wörterbuch umzuwandeln. Bei dieser Umwandlung können Elemente des ursprünglichen Wörterbuchs bedingt in das neue Wörterbuch aufgenommen werden, und jedes Element kann nach Bedarf umgewandelt werden.

Ein gutes Listenverständnis kann deinen Code ausdrucksstärker und damit leichter lesbar machen. Der Schlüssel zur Erstellung von Verständnissen liegt darin, sie nicht so komplex werden zu lassen, dass dir der Kopf schwirrt, wenn du versuchst zu entschlüsseln, was sie eigentlich tun. Die Idee der "leichten Lesbarkeit" am Leben erhalten.

Um ein Wörterbuch in Python zu verstehen, musst du auf die key Objekte und die value Objekte eines Wörterbuchs zugreifen können.

Wie kann man das machen?

Python hat dich im Griff! Du kannst dafür einfach die eingebauten Methoden verwenden:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()

dict_keys(['c', 'd', 'a', 'b'])

# Put all values saved in `dict1` in a list and returns the list
dict1.values()

dict_values([3, 4, 1, 2])

Der obige Code erstellt ein Python-Wörterbuch namens dict1 mit vier Schlüssel-Wert-Paaren. Die Methode keys() wird für das Wörterbuch aufgerufen und gibt ein View-Objekt zurück, das alle Schlüssel des Wörterbuchs enthält.

Die Methode values() wird auch für das Wörterbuch aufgerufen, das ein View-Objekt mit allen Werten im Wörterbuch zurückgibt.

Beide View-Objekte verhalten sich wie Sets und können verwendet werden, um Set-Operationen mit den Schlüsseln bzw. Werten durchzuführen.

Beachte, dass die Reihenfolge der Schlüssel und Werte in den View-Objekten nicht mit der Reihenfolge übereinstimmen muss, in der sie dem Wörterbuch hinzugefügt wurden.

Verwendung der Methode items()

Jetzt weißt du also, wie du auf alle Schlüssel und ihre Werte in einem Wörterbuch zugreifen kannst. Du kannst auch auf jedes Schlüssel-Wert-Paar innerhalb eines Wörterbuchs mit der Methode items() zugreifen:

dict1.items()

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])

Dies ist die allgemeine Vorlage, die du für das Verstehen von Wörterbüchern in Python verwenden kannst:

dict_variable = {key:value for (key,value) in dictonary.items()}

Dies kann als grundlegende und einfachste Vorlage dienen. Das kann immer komplexer werden, wenn du Bedingungen hinzufügst.

Beispiel für das Verstehen eines einfachen Python-Wörterbuchs

Beginnen wir mit einem einfachen Wörterbuchverständnis:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}

Im obigen Code zum Verstehen erstellen wir ein neues Wörterbuch double_dict1 aus einem Wörterbuch dict1, indem wir einfach jeden Wert darin verdoppeln.

Du kannst auch Änderungen an den Schlüsselwerten vornehmen. Erstellen wir zum Beispiel dasselbe Wörterbuch wie oben, ändern aber auch die Namen der Schlüssel.

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}

Warum Wörterbuchverstehen verwenden?

Dictionary Comprehension ist ein mächtiges Konzept und kann als Ersatz für for Schleifen und lambda Funktionen verwendet werden. Allerdings können nicht alle for-Schleifen als Wörterbuchverständnis geschrieben werden, aber alle Wörterbuchverständnisse können mit einer for-Schleife geschrieben werden.

Betrachte das folgende Problem: Du möchtest ein neues Wörterbuch erstellen, dessen Schlüssel eine durch 2 teilbare Zahl im Bereich von 0-10 ist und dessen Wert das Quadrat der Zahl ist.

Schauen wir uns an, wie du das gleiche Problem mit einer for-Schleife und Wörterbuchverständnis lösen kannst:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}

Alternative zu for Schleifen

For-Schleifen werden verwendet, um eine bestimmte Operation oder einen Block von Anweisungen in einem Programm eine bestimmte Anzahl von Malen zu wiederholen. Verschachtelte for-Schleifen (for-Schleife innerhalb einer anderen for-Schleife) können jedoch verwirrend und komplex werden. Dictionary Comprehensions sind in solchen Situationen besser und können die Lesbarkeit und dein Verständnis des Codes vereinfachen.

Tipp: Im DataCamp-Tutorial Schleifen in Python findest du weitere Informationen zu Schleifen in Python.

Alternative zu lambda Funktionen

Lambda-Funktionen sind eine Möglichkeit, kleine anonyme Funktionen zu erstellen. Sie sind Funktionen ohne Namen. Diese Funktionen sind Wegwerffunktionen, die nur dort gebraucht werden, wo sie erstellt worden sind. Lambda-Funktionen werden hauptsächlich in Kombination mit den Funktionen filter(), map() und reduce() verwendet.

Schauen wir uns die Lambda-Funktion zusammen mit der Funktion map() an:

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Beispiel für das Verstehen eines Python-Wörterbuchs

Betrachten wir eine andere Situation, in der du ein Wörterbuch mit Temperaturen von Fahrenheit in Celsius umwandeln möchtest.

Schauen wir uns den Code einmal genauer an: Zuerst musst du eine mathematische Formel definieren, die die Umrechnung von Fahrenheit in Celsius vornimmt.

Im Code wird das mit Hilfe der Lambda-Funktion gemacht. Diese Funktion übergibst du dann als Argument an die Funktion map(), die dann die Operation auf jedes Element in der Liste fahrenheit.values() anwendet.

Erinnerst du dich an die Funktion values()? Sie gibt eine Liste mit den im Wörterbuch gespeicherten Einträgen zurück.

Was du jetzt hast, ist eine Liste, die den Temperaturwert in Celsius enthält, aber für die Lösung muss es ein Wörterbuch sein.

Python hat eine eingebaute Funktion namens zip(), die über die Elemente von Iteratoren geht und sie aggregiert. Du kannst mehr über die Funktion zip() in diesem Python-Beispiel lesen.

In unserem obigen Beispiel fasst die Funktion zip das Element aus fahrenheit.keys() und der Liste celsius zusammen und ergibt so ein Schlüssel-Wert-Paar, das du mit der Funktion dict in einem Wörterbuch zusammenstellen kannst, was das gewünschte Ergebnis ist.

Versuchen wir nun, das gleiche Problem mit Hilfe des Wörterbuchverständnisses zu lösen:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}

Hier ist eine Aufschlüsselung dessen, was wir im obigen Code erstellt haben: 

1. Erstelle ein Wörterbuch mit dem Namen fahrenheit mit vier Schlüssel-Wert-Paaren, die Temperaturwerte in Fahrenheit darstellen.
2. Definiere ein neues Wörterbuch namens celsius.
3. Verwende ein Wörterbuchverständnis, um das fahrenheit Wörterbuch zu durchlaufen und die Fahrenheit-Temperaturwerte mit der Formel (5/9) * (F-32) in Celsius umzurechnen.
4. Für jedes Schlüssel-Wert-Paar in fahrenheit wird der Schlüssel der Variablen k und der Wert der Variablen v zugewiesen.
5. Der Wert der Celsius-Temperatur, der jeder Fahrenheit-Temperatur entspricht, wird anhand der oben genannten Formel berechnet und als Schlüssel-Wert-Paar zum celsius Wörterbuch hinzugefügt.
6. Das resultierende celsius Wörterbuch wird auf der Konsole ausgegeben.

Wie du siehst, kann das Problem mit einer einzigen Codezeile gelöst werden, wenn du das Wörterbuchverständnis verwendest, im Vergleich zum zweistufigen Verfahren und dem Verständnis der Funktionsweise von drei Funktionen (lambda, map() und zip()) für die erste Implementierung.

Außerdem ist die Lösung intuitiv und mit einem Wörterbuch leicht zu verstehen. Daher kann das Wörterbuchverständnis eine gute Alternative zu den Lambda-Funktionen sein.

Hinzufügen von Konditionalen zum Wörterbuchverstehen

Beim Lösen von Problemen musst du oft Bedingungen zu einer Lösung hinzufügen. Lass uns herausfinden, wie du Bedingungen in das Wörterbuchverständnis einbauen kannst, um es noch leistungsfähiger zu machen.

Wenn Bedingung

Angenommen, du musst ein neues Wörterbuch aus einem gegebenen Wörterbuch erstellen, aber mit Einträgen, die größer als 2 sind. Das bedeutet, dass du die ursprüngliche Vorlage, die du oben gesehen hast, um eine Bedingung ergänzen musst.

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)

{'e': 5, 'c': 3, 'd': 4}

Das ist gar nicht so schwer! Aber was ist, wenn du mehrere Krankheiten hast?

Mehrere Wenn-Bedingungen

Was ist, wenn du in der obigen Aufgabe nicht nur die Werte größer als 2 ermitteln musst, sondern auch prüfen musst, ob sie gleichzeitig ein Vielfaches von 2 sind?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)

{'d': 4}

Die Lösung für das Hinzufügen mehrerer Bedingungen ist so einfach wie das Hinzufügen der Bedingungen nacheinander in deinem Verständnis. Allerdings musst du darauf achten, was du mit dem Problem bezweckst. Denke daran, dass die aufeinanderfolgenden if-Anweisungen so funktionieren, als hätten sie and Klauseln zwischen sich.

Schauen wir uns ein weiteres Beispiel mit drei Bedingungen an:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)

{'f': 6}

In einer for-Schleife entspricht dies:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)

{'f': 6}

Wenn-Else-Bedingungen

Der Umgang mit einer if-else-Bedingung ist auch mit dem Wörterbuchverständnis einfach. Schau dir das folgende Beispiel an, um es selbst zu sehen:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}

Verschachteltes Wörterbuch Verstehen

Nesting ist ein Programmierkonzept, bei dem Daten in Schichten organisiert werden oder bei dem Objekte andere ähnliche Objekte enthalten. Du hast sicher schon oft eine verschachtelte "if"-Struktur gesehen, d.h. eine if-Bedingung innerhalb einer anderen if-Bedingung.

Auch Wörterbücher können verschachtelt werden, und somit auch ihre Verständnisse. Lass uns sehen, was das bedeutet:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)

{'first': {1.0}, 'second': {2.0}}

Dies ist ein Beispiel für ein verschachteltes Wörterbuch. Das nested_dict ist ein Wörterbuch mit den Schlüsseln: first und second, die Wörterbuchobjekte in ihren Werten enthalten. Der Code arbeitet mit den inneren Werten des Wörterbuchs und konvertiert sie in Float und kombiniert dann die äußeren Schlüssel mit den neuen inneren Float-Werten zu einem neuen Wörterbuch.

Der Code hat auch ein verschachteltes Wörterbuchverständnis, also ein Wörterbuchverständnis innerhalb eines anderen. Das Wörterbuchverständnis kann, wenn es verschachtelt ist, ziemlich schwer zu lesen und zu verstehen sein, was den Sinn der Verwendung von Verständnissen zunichte macht.

Je komplizierter die Struktur des Wörterbuchs wird, mit dem du arbeitest, desto komplizierter wird auch das Verständnis des Wörterbuchs. In solchen Situationen ist es vielleicht besser, wenn du keine komplizierten Comprehensions in deinem Code verwendest.

Beachte, dass du den obigen Code auch mit einer verschachtelten for-Schleife umschreiben kannst:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)

{'first': {'a': 1.0}, 'second': {'b': 2.0}}

Schlussgedanken

Hoffentlich hast du jetzt etwas über Wörterbücher in Python gelernt, über das Konzept des Verstehens und darüber, warum und wo das Verstehen von Wörterbüchern in Python nützlich sein kann. 

Übung macht dein Python besser! Sieh dir einige unserer besten Python-Tipps und -Tricks an, um deinen Code zu verbessern, oder nimm an unserem Python Skill Track teil, um mehr Grundlagen zu lernen.