Dictionary
Inhalt
Dictionary¶
(Fortgeschrittene)
Die Grundlagen von den Wörterbüchern sind uns schon bekannt. Hier wollen wir nun die Details studieren.
Fortgeschrittene Techniken¶
Dictionary Anlegen¶
Überlicherweise werden die Wörterbücher wie folgt angelegt:
d = {'a': 1, 'b': 2, 'c': 3}
dict sind dynamische Datentypen. Wir können also leere Wörterbücher erzeugen und dann die Elemente hinzufügen.
d = {}
type(d)
dict
Das Key/Value Paar können wir mit der Synthax d[key]=value hinzufügen.
d['a']=1
d
{'a': 1}
d['b']=2
d['c']=3
d
{'b': 2, 'c': 3}
Wenn wir die Built-in Funktion verwenden wollen lautet die Synthax d(key1=value1,key2=value2,...) benutzen.
dict(a=1,b=2,c=3)
{'a': 1, 'b': 2, 'c': 3}
Dictionary sind geordnet¶¶
Wörterbücher sind geordnete Datentypen.
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'a': 1, 'b': 2, 'c': 3}
Der Vergleichsoperator == zeigt das beide Wörterbücher dieselben Elemente in derselben Reihenfolgen enthalten.
d1 == d2
True
d1 = {'c': 1, 'b': 2, 'a': 3}
d2 = {'a': 1, 'b': 2, 'c': 3}
Sind die Elemente in den Wörterbüchern verschieden angeordnet, so zeigt der Vergleichsoperator == dass diese verschieden sind.
d1 == d2
False
Dictionary mit willkürlichen Objekten¶
Wörterbücher können verschiedenste Datentypen enthalten. Zum Beispiel können wir vier numerische Datentypen in einem Wörterbücher verwenden.
d1 = {'int': 1, 'float': 2.0, 'complex': 1+1j, 'boolean': True}
d1
{'int': 1, 'float': 2.0, 'complex': (1+1j), 'boolean': True}
Zugriff auf Wörterbuchwerte¶
Der Zugriff erfolgt einfach mit dem key.
d1 = {'a': 1, 'b': 2, 'c': 3}
d1['a']
1
Auch wenn der key eine Zahl ist, erfolgt der Zugriff in der gleichen Weise.
d1 = {0: 'a', 1: 'b', 2: 'c'}
d1[0]
'a'
Dict von Dicts¶
Wir können auch Wörterbücher von Wörterbüchern erzeugen.
d1 = {0: 'a', 1: 'b', 2: 'c'}
d2 = {24: 'x', 25: 'y', 26: 'z'}
d = {0: d1, 1: d2}
d
{0: {0: 'a', 1: 'b', 2: 'c'}, 1: {24: 'x', 25: 'y', 26: 'z'}}
Der Zugriff erfolgt mit d[key][key].
d[0][0]
'a'
d[1][24]
'x'
Verschachtelte Dicts¶¶
Auch eine Verschachtlung von Wörterbüchern ist möglich. Wie immer sollten wir mit solchen Konstruktionen vorsichtig sein.
d = {0: 'a', 1: {0: 'aa', 1: 'bb'}, 2: 'b'}
d[0]
'a'
d[1]
{0: 'aa', 1: 'bb'}
d[1][0]
'aa'
Dicts verändern¶¶
Da Wörterbücher dynamisch sind, können wir alle Werte verändern.
d = {'a': 0, 'b': 1, 'c': 2}
d['a'] = 10
d
{'a': 10, 'b': 1, 'c': 2}
Dictionary Methoden¶
Mit Hilfe von dir bekommen wir alle Attribute. Wir wollen nur Methoden selektieren.
dict_methods = [name for name in dir(dict) if name.islower() and name[0] !='_']
print(len(dict_methods))
print(dict_methods)
11
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
Name |
Typ |
Operation |
Beschreibung |
|---|---|---|---|
len() |
Built-In |
Länge des Wörterbuches |
|
min() |
Built-In |
Element mit dem Schlüssel welches dem Minimum entspricht |
|
max() |
Built-In |
Element mit dem Schlüssel welches dem Maximum entspricht |
|
list() |
Built-In |
Erzeugt |
Erzeugt ein Wörterbuch |
update() |
Built-In |
Hinzufügen |
Hinzufügen von Elementen |
fromkeys()¶
Die fromkeys() Methode erlaubt das Erstellen von
Bemerkung
d.update(<obj>)
keys = ['a','b','c']
dict.fromkeys(keys)
{'a': None, 'b': None, 'c': None}
dict.fromkeys(keys, 0)
{'a': 0, 'b': 0, 'c': 0}
update()¶
Die update() Methode erlaubt das Anhängen von Elementen. Auch das Verändern der Werte ist möglich. Seit Python3.9 können auch die Operatoren =| und | verwendet werden.
Bemerkung
d.update(<obj>)
d1 = {'a': 1, 'b': 2, 'c': 3}
Hinzufügen
d1.update(e=4,f=5)
d1
{'a': 1, 'b': 2, 'c': 3, 'e': 4, 'f': 5}
d1 |= {'g':6, 'h':7}
d1
{'a': 1, 'b': 2, 'c': 3, 'g': 6, 'h': 7}
Werte Ändern
d1.update([('a', -1),('b', -2)])
d1
{'a': -1, 'b': -2, 'c': 3, 'e': 4, 'f': 5, 'g': 6}
d1 |= {'a':1, 'b':2}
d1
{'a': 1, 'b': 2, 'c': 3, 'e': 4, 'f': 5, 'g': 6}
d1.update(a=-1, b=-2)
d1
{'a': -1, 'b': -2, 'c': 3, 'd': 4, 'e': 5}
Vereinigung
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'c': 3, 'd': 4, 'e': 5}
d1.update(d2)
d1
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'c': 3, 'd': 4, 'e': 5}
d1 = d1 | d2
d1
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'c': 3, 'd': 4, 'e': 5}
d1 |= d2
d1
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
get()¶
Bemerkung
d.get(<key>[, <default>])
d1 = {'a': 1, 'b': 2, 'c': 3}
d1.get('a')
1
print(d1.get('z'))
None
d.get('z', -1)
-1
items()¶
Bemerkung
d.items()
list(d.items())
[('a', 1), ('b', 2), ('c', 3)]
list(d.items())[1][0]
'b'
list(d.items())[1][1]
2
pop()¶
Bemerkung
d.pop(<key>[, <default>])
d.pop('b')
2
d
{'a': 1, 'c': 3}
# d.pop('z')
d.pop('z',-1)
-1
popitem()¶
Bemerkung
d.popitem()
d = {'a': 1, 'b': 2, 'c': 3}
d.popitem()
('c', 3)
d
{'a': 1, 'b': 2}
d.popitem()
('b', 2)
d
{'a': 1}