2.4    Dictionary

Ein Dictionary (dt. Wörterbuch) speichert Daten als Schlüssel-Wert-Paare. Erzeugt wird ein Dictionary, indem die Schlüssel-Wert-Paare in geschweifte Klammern eingeschlossen werden. Der Schlüssel (engl. key) wird durch einen Doppelpunkt von seinem Wert (engl. value) getrennt. Er wird entweder durch einen String oder ein Tupel repräsentiert. Der Wert kann einen beliebigen Typ haben. Mit den Methoden d.keys() und d.values() können Sie die Schlüssel bzw. die Werte des Dictionarys d ermitteln. Die Einträge von Dictionarys können auch Tupel, Sets, Listen oder Objekte aus selbst definierten Klassen als Keys und Values sein.

Der Konsolendialog zeigt, wie Sie ein Dictionary E für chemische Elemente mit den zugehörigen Ordnungszahlen erzeugen und wie Sie die Schlüssel und Werte ermitteln können:

>>> E={'C':6,'N':7,'O':8,'P':15}
>>> type(E)
<class 'dict'>
>>> E.keys()
dict_keys(['C', 'N', 'O', 'P'])
>>> E.values()
dict_values([6, 7, 8, 15])
>>> E.items()
dict_items([('C', 6), ('N', 7), ('O', 8), ('P', 15)])
>>> E['O']
8

Wichtige Methoden und Funktionen sind in Tabelle 2.6 aufgeschlüsselt.

Methode/Funktion

Beschreibung

d.keys()

Ermittelt alle Schlüssel des Dictionarys d.

d.values()

Ermittelt alle Werte des Dictionarys d.

d.items()

Gibt eine Liste mit Schlüssel-Wert-Paaren des Dictionarys d als Tupel zurück.

d.update({k:v})

Fügt in das Dictionary d ein neues Schlüssel-Wert-Paar ein oder überschreibt den Wert, falls der Schlüssel bereits existiert.

k in d

Überprüft, ob der Schlüssel k im Dictionary d enthalten ist.

del d[k]

Löscht das Schlüssel-Wert-Paar mit dem Schlüssel k aus dem Dictionary d.

Tabelle 2.6     Ausgewählte Methoden und Funktionen für Operationen auf Dictionarys

Als Anwendungsbeispiel soll ein Programm entwickelt werden, das die Ableitungen der mathematischen Funktionen aus Tabelle 2.7 mit einem Dictionary ermittelt.

ƒ(x)

sin(x)

cos(x)

ln(x)

sinh(x)

cosh(x)

ƒ'(x)

cos(x)

-sin(x)

1/x

cosh(x)

sinh(x)

Tabelle 2.7     Ableitungen einiger ausgewählter Funktionen

Listing 2.6 zeigt die Umsetzung. Das Dictionary wird aus zwei Listen f_x und f_1 mit der zip-Funktion erzeugt:

01  #06_dict1.py
02  f_x=['sin(x)', 'cos(x)', 'ln(x)','sinh(x)','cosh(x)']
03  f_1=['cos(x)', '-sin(x)', '1/x', 'cosh(x)','sinh(x)']
04  dicA=dict(zip(f_x,f_1))
05  print(dicA.keys())
06  print(dicA.values())
07  print(dicA)
08  print("Ableitungen")
09  print("1. Ableitung von sin(x):",dicA['sin(x)'])
10  print("1. Ableitung von cos(x):",dicA['cos(x)'])
11  print("1. Ableitung von ln(x):", dicA['ln(x)'])
12  print("1. Ableitung von sinh(x):",dicA['sinh(x)'])
13  print("1. Ableitung von cosh(x):",dicA['cosh(x)'])

Listing 2.6     Erzeugen eines Dictionarys aus zwei Listen

Ausgabe

dict_keys(['sin(x)', 'cos(x)', 'ln(x)', 'sinh(x)', 'cosh(x)'])
dict_values(['cos(x)', '-sin(x)', '1/x', 'cosh(x)', 'sinh(x)'])
{'sin(x)': 'cos(x)', 'cos(x)': '-sin(x)', 'ln(x)': '1/x', 'sinh(x)': 'cosh(x)', 'cosh(x)': 'sinh(x)'}
Ableitungen
1. Ableitung von sin(x): cos(x)
1. Ableitung von cos(x): -sin(x)
1. Ableitung von ln(x): 1/x
1. Ableitung von sinh(x): cosh(x)
1. Ableitung von cosh(x): sinh(x)

Analyse

In Zeile 02 wird die Liste f_x aus trigonometrischen Funktionen erzeugt.

In Zeile 03 steht die Liste f_1 mit den 1. Ableitungen dieser Funktionen.

In Zeile 04 verkettet die eingebaute Python-Funktion zip(f_x,f_1) beide Listen zu einer Liste aus Tupeln der trigonometrischen Funktionen und deren 1. Ableitungen.

Die eingebaute Python-Funktion dict(...) erzeugt daraus ein Dictionary.

Die eingebaute Python-Funktion print(...) gibt in Zeile 05 die Schlüssel keys() und in Zeile 06 die Werte values() des Dictionarys dictA aus.

In Zeile 07 werden alle Einträge des Dictionarys dictA ausgegeben.

Die Ausgabe der Werte (= 1. Ableitungen) von dictA erfolgt in den Zeilen 09 bis 13 über den Zugriff auf die Schlüssel (= trigonometrische Funktionen).

Listing 2.6 hat keinen praktischen Nutzen. Das Programm soll nun so ergänzt werden, dass der Benutzer in einem Dialog mit dem Programm überprüfen kann, ob er die Ableitungen von den mathematischen Funktionen, die das Programm auf dem Bildschirm ausgibt, kennt. Die Methode choice des Moduls random wählt nach dem Zufallsprinzip aus einem Dictionary eine mathematische Funktion aus und gibt sie als Eingabeaufforderung auf dem Bildschirm aus, also beispielsweise Ableitung von: sin(x)?. Der Benutzer tippt die Ableitungsfunktion in die Konsole. Wenn die Eingabe richtig ist, erscheint die Meldung: richtig!, ansonsten wird die Meldung falsch! mit der richtigen Lösung ausgegeben, also Ableitung von: sin(x) ist: cos(x). Nach jeder richtigen Antwort wird der Eintrag aus dem Dictionary gelöscht. Das Programm wird beendet, wenn alle Fragen richtig beantwortet wurden.

Das Programm besteht aus drei Teilen:

Funktions- und Schleifenkonstrukte wurden zwar noch nicht behandelt. Trotzdem soll an dieser Stelle ein Programm (siehe Listing 2.7) mit diesen Konstrukten besprochen werden, um deren möglichen Einsatz in der Praxis aufzuzeigen. Die Details zu Funktionsdefinitionen und Schleifenkonstrukten werden in Kapitel 3, »Programmstrukturen«, besprochen und erklärt.

01  #07_dict2.py
02  from random import choice
03  def frage(d):
04      a=choice(list(d.keys()))
05      print("Ableitung von:",a,"?")
06      aw=input("ist: ")
07      if aw != d[a]:
08          print("falsch!")
09          print("Ableitung von:",a,"ist: ",end="")
10          for ableitung in d[a]:
11              print(ableitung,end="")
12          print() #Zeilenumbruch
13      else:
14          print("richtig!")
15          del d[a]
16  #dictionary
17  dicA={'x':'1',
18     'sin(x)':'cos(x)',
19     'cos(x)':'-sin(x)',
20     'ln(x)':'1/x',
21     'exp(x)':'exp(x)',
22     'cosh(x)':'sinh(x)',
23     'sinh(x)':'cosh(x)',
24     'sin(a*x)':'a*cos(a*x)',
25     }
26  while dicA:
27      frage(dicA)
28  print("Sie beherrschen alle Ableitungen!")

Listing 2.7     Test zu Ableitungen ausgewählter mathematischer Funktionen

Ausgabe

Ableitung von: sinh(x) ?
ist: cosh(x)
richtig!
Ableitung von: cosh(x) ?
ist: sinh(x)
richtig!
...
Ableitung von: x ?
ist: 1
richtig!
Sie beherrschen alle Ableitungen!

Analyse

Die Kontrollstrukturen, die in Listing 2.7 vorkommen, werden erst im nächsten Kapitel beschrieben. Trotzdem soll der Quelltext besprochen werden, weil dieses Anwendungsbeispiel zeigt, wie ein Python-Programm grundsätzlich aufgebaut ist: Es besteht in der Regel aus selbst erstellten Python-Funktionen, Wiederhol- und Verzweigungsstrukturen.

Das Programm besteht aus vier Teilen: einer Importanweisung, einer selbst definierten Funktion, einer Definition für ein Dictionary und einer while-Schleife.

In Zeile 02 wird die Methode choice aus dem Modul random importiert. Mit dieser Methode wird nach dem Zufallsprinzip ein Schlüssel aus dem Dictionary dicA (Zeilen 17 bis 25) ausgewählt.

Der selbst definierten Python-Funktion frage(d) (Zeilen 03 bis 15) wird beim Aufruf (Zeile 27) das Dictionary dicA übergeben. In Zeile 04 wird ein zufällig ausgewählter Schlüssel dem Objekt a zugewiesen. Dieser Schlüssel wird in den Zeilen 05 und 06 als Eingabeaufforderung "Ableitung von:", ƒ(x), "ist:" auf dem Monitor ausgegeben.

Die eingebaute Python-Funktion input() erwartet eine Eingabe als String. Dessen Wert wird in das Objekt aw gespeichert. Wenn aw ungleich d[a] ist (Zeile 07), dann wird die Meldung falsch ausgegeben (Zeile 08), und innerhalb der for-Schleife wird die richtige Antwort gesucht und anschließend auf dem Bildschirm angezeigt (Zeile 09). Wenn die Antwort richtig war, wird der entsprechende Schlüssel in Zeile 15 aus dem Dictionary entfernt.

In den Zeilen 17 bis 25 wird das Dictionary dicA={'key':'value'} definiert. Der Schlüssel (key) ist die mathematische Funktion ƒ(x), und die 1. Ableitung ƒ'(x) ist der Wert (value) des Dictionarys.

Die while-Schleife (Zeilen 26 bis 27) wird so lange durchlaufen, bis alle Schlüssel des Dictionarys abgefragt wurden.

Hinweis

Das Programm ist nicht gegen Falscheingaben abgesichert. Es kann auch vorkommen, dass falsche Eingaben als richtig interpretiert werden.

Listing 2.7 gibt uns die Fragestellung für das nächste Kapitel mit auf den Weg: Wie funktionieren Verzweigungs- und Wiederholstrukturen genau, und wie können selbst definierte Python-Funktionen prinzipiell implementiert werden?