Python Dictionaries (dict)                       (C) 2020 T.Birnthaler OSTC GmbH
==========================

Doku --> docs.python.org/3/library/stdtypes.html#dict

Dictionaries (dict) (auch Map, Hash, Zuordnung oder Assoziatives Array genannt)
speichern PAARE (Key, Value) von Werten und damit eine "Beziehung" zwischen
zwei Datenwerten (Key --> Value).

* Keys müssen IMMUTABLE Objekte bzw. eigentlich HASHABLE Objekte sein
  (None, bool, int, float, complex, str, tuple, bytes).

* Keys müssen UNIQUE sein (d.h. der gleiche Key darf nur 1x vorkommen).

* Als Value sind beliebige Python-Objekte erlaubt.

* Values dürfen NON-UNIQUE sein (d.h. der gleiche Value darf mehrfach vorkommen).

  d1 = {}                                        # Leeres Dictionary
  d2 = {"abc": 123, True: 4.0, (1,2): None}
  d3 = {"a": 1, "b": 2, "c": 1, "d": 2, "e": 3}

Die Zugriffsgeschwindigkeit auf einen bestimmten Key (und damit seinen Value)
ist unabhängig von der Dictionary-Größe immer gleich schnell ("RANDOM ACCESS").

Die Zugriffsgeschwindigkeit auf einen bestimmten Value ist abhängig von der
Dictionary-Größe und immer langsam (da sie das Durchsuchen des gesamten
Dictionaries erfordert).

Folgende Operation werden von Python Dictionaries unterstützt (K ist ein Key =
immutable Objekt, V und DFLT sind Values = beliebige Objekte, D und D2 sind
Dictionaries, ITBL ist ein Iterable):

+-----------------------+------------------------------------------------------+
| len(D)                | Anzahl Paare                                         |
+-----------------------+------------------------------------------------------+
| K in D                | Ist Key enthalten?                                   |
| K not in D            | Ist Key nicht enthalten?                             |
+-----------------------+------------------------------------------------------+
| V = D[K]              | Wert von Key holen (oder KeyError falls Key fehlt)   |
| V = D.get(K, DFLT)    | Wert von Key holen (oder DFLT)                       |
+-----------------------+------------------------------------------------------+
| D[K] = V              | Wert zu Key setzen (oder ersetzen)                   |
| D.setdefault(K, DFLT) | Wert von Key setzen (falls vorhanden)                |
+-----------------------+------------------------------------------------------+
| del D[K]              | Key + Wert löschen (oder KeyError falls Key fehlt)   |
+-----------------------+------------------------------------------------------+
| L = list(D)           | Liste aller Keys (unsortiert)                        |
| L = D.keys()          | Liste aller Keys (unsortiert)                        |
| L = D.values()        | Liste alle Werte (unsortiert)                        |
| L = D.items()         | Liste aller Paare (unsortiert)                       |
| L = iter(D)           | Abkürzung für iter(D.keys())                         |
| L = reversed(D)       | Abkürzung für reversed(D.keys())                     |
+-----------------------+------------------------------------------------------+
| V = D.pop(K, DFLT)    | Wert von Key holen (KeyError oder DFLT) + Key löschen|
| (K,V) = D.popitem()   | Paar holen + entfernen (KeyError falls D leer)       |
+-----------------------+------------------------------------------------------+
| D = fromkeys(ITBL, V) | Dict mit Keys aus ITBL + Value V (None) erzeugen     |
| D.update(D2)          | Paare aus D2 hinzufügen (vorhandene überschreiben)   |
| D.clear()             | Dictionary leeren (alle Keys + Values entfernen)     |
| D2 = D.copy()         | Shallow/Flache Kopie                                 |
+-----------------------+------------------------------------------------------+

HINWEIS: Seit Python 3.7 entspricht die Keyreihenfolge im Dictionary der
Einfügereihenfolge, vorher war die Reihenfolge der Keys zufällig und konnte
sich jederzeit ändern.