Dictionaries

Dinge über ihren Namen nachschlagen

Ein Dictionary (dict) ordnet Schlüssel Werten zu: {"AAPL": 184.5, "MSFT": 410.2}. Wo eine Liste ein Element über die Position findet, findet ein Dictionary es über den Schlüssel, und die Suche bleibt bei beliebig vielen Einträgen schnell. prices["AAPL"] liest einen Wert, prices["TSLA"] = 251.0 fügt einen Eintrag hinzu oder ersetzt den vorhandenen, und "AAPL" in prices fragt, ob ein Schlüssel existiert. Ein fehlender Schlüssel löst beim Lesen mit eckigen Klammern einen KeyError aus.

prices = {"AAPL": 184.5, "MSFT": 410.2}

# Read, add and replace
print(prices["AAPL"])       # 184.5
prices["TSLA"] = 251.0
prices["AAPL"] = 185.0
print(prices)               # {'AAPL': 185.0, 'MSFT': 410.2, 'TSLA': 251.0}

# in tests the keys; a missing key raises KeyError
print("MSFT" in prices, "GOOG" in prices)  # True False
try:
    prices["GOOG"]
except KeyError as error:
    print("no such key:", error)

get: ein fehlender Schlüssel ist kein Fehler

prices.get("GOOG", 0.0) liefert den Wert oder den angegebenen Standardwert, wenn der Schlüssel fehlt (None, wenn Sie keinen angeben), und löst nie einen Fehler aus. Damit wird ein Zähler einfach: counts[symbol] = counts.get(symbol, 0) + 1 beginnt bei 0 für ein neues Symbol und addiert bei jedem Auftreten eins. Nehmen Sie [], wenn ein fehlender Schlüssel ein Fehler wäre, von dem Sie erfahren wollen, und get, wenn Fehlen normal ist.

# get() with a default never raises
prices = {"AAPL": 184.5}
print(prices.get("AAPL", 0.0))   # 184.5
print(prices.get("GOOG", 0.0))   # 0.0
print(prices.get("GOOG"))        # None

# Counting with get
counts = {}
for symbol in ["AAPL", "MSFT", "AAPL", "AAPL"]:
    counts[symbol] = counts.get(symbol, 0) + 1
print(counts)                    # {'AAPL': 3, 'MSFT': 1}

Ein Dictionary durchlaufen

Ein einfaches for key in prices durchläuft die Schlüssel. Mit prices.values() erhalten Sie die Werte und mit prices.items() die Paare (Schlüssel, Wert), die man in der Schleife entpackt: for symbol, price in prices.items(). Dictionaries merken sich die Reihenfolge, in der Schlüssel hinzugefügt wurden. Fügen Sie beim Durchlaufen desselben Dictionaries keine Schlüssel hinzu und entfernen Sie keine; durchlaufen Sie eine Kopie oder bauen Sie ein neues.

# keys(), values() and items()
positions = {"AAPL": 200, "MSFT": 50, "GOOG": 0}
prices = {"AAPL": 184.5, "MSFT": 410.2}

for symbol in positions:
    print(symbol, end=" ")      # AAPL MSFT GOOG
print()

total = 0.0
for symbol, quantity in positions.items():
    total += quantity * prices.get(symbol, 0.0)
print(round(total, 2))          # 57410.0

Entfernen, zusammenführen und kopieren

prices.pop("AAPL", None) entfernt einen Schlüssel und liefert seinen Wert (den Standardwert, falls er fehlte); del prices["AAPL"] entfernt ihn und löst KeyError aus, wenn er fehlt. a.update(b) kopiert die Einträge von b nach a und ändert a; {**a, **b} oder a | b baut ein neues Dictionary, in dem b bei gemeinsamen Schlüsseln gewinnt. Wie bei Listen ist copy = prices nur ein zweiter Name: Für eine echte Kopie nehmen Sie dict(prices) oder prices.copy().

# Removing and merging
book = {"AAPL": 200, "MSFT": 50}
sold = book.pop("MSFT", 0)
print(sold, book)                 # 50 {'AAPL': 200}

# {**a, **b} builds a new dict; b wins on shared keys
defaults = {"fee": 0.001, "currency": "USD"}
custom = {"fee": 0.0005}
settings = {**defaults, **custom}
print(settings)                   # {'fee': 0.0005, 'currency': 'USD'}
print(defaults)                   # unchanged: {'fee': 0.001, 'currency': 'USD'}

Was als Schlüssel dienen kann

Ein Schlüssel muss hashbar sein, was praktisch heißt, dass er sich nicht ändern darf: Strings, Zahlen und Tupel davon sind in Ordnung, Listen und Dictionaries nicht. Tupel eignen sich gut als zusammengesetzte Schlüssel, etwa (symbol, venue). Werte können alles sein, auch eine andere Liste oder ein anderes Dictionary. Derselbe Schlüssel kann nur einmal vorkommen; eine erneute Zuweisung ersetzt den alten Wert.

# A tuple as a compound key, a list as a value
best = {("AAPL", "NYSE"): 184.6, ("AAPL", "ARCA"): 184.5}
print(best[("AAPL", "ARCA")])        # 184.5

fills = {"AAPL": [100, 250], "MSFT": [75]}
fills["AAPL"].append(40)
print(fills)                         # {'AAPL': [100, 250, 40], 'MSFT': [75]}

# A list cannot be a key
try:
    {["AAPL"]: 1}
except TypeError as error:
    print("not hashable:", error)

• d[key], d[key] = value, key in d: lesen, schreiben, einen Schlüssel prüfen.
• d.get(key, default): ein sicheres Nachschlagen; d.items(): Paare zum Durchlaufen.
• d.pop(key, default), del d[key], d.update(other), {**a, **b}: entfernen und zusammenführen.

Als Nächstes: Mengen (Sets), Sammlungen eindeutiger Werte mit schnellen Zugehörigkeitstests und eleganter Mengenarithmetik.

Lab: Was bewertet wird

• Mit latest_prices den neuesten Preis je Symbol behalten25 Pkt.
• Mit count_symbols zählen, wie oft jedes Symbol vorkommt25 Pkt.
• Mit portfolio_value ein Portfolio aus zwei Dictionaries bewerten25 Pkt.
• Mit merge_positions zwei Positionsbücher zusammenführen25 Pkt.