Dicionários

Procurar coisas pelo nome

Um dicionário (dict) associa chaves a valores: {"AAPL": 184.5, "MSFT": 410.2}. Onde uma lista encontra um item pela posição, um dicionário o encontra pela chave, e a busca continua rápida qualquer que seja o número de entradas. prices["AAPL"] lê um valor, prices["TSLA"] = 251.0 adiciona uma entrada ou substitui a existente, e "AAPL" in prices pergunta se uma chave existe. Ler uma chave ausente com colchetes gera um KeyError.

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: uma chave ausente não é um erro

prices.get("GOOG", 0.0) devolve o valor, ou o padrão que você der quando a chave falta (None se não der nenhum), e nunca gera erro. Isso facilita um contador: counts[symbol] = counts.get(symbol, 0) + 1 começa em 0 para um símbolo novo e soma um a cada ocorrência. Use [] quando uma chave ausente seria um bug que você quer notar, e get quando a ausência é normal.

# 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}

Percorrer um dicionário

Um simples for key in prices percorre as chaves. Use prices.values() para os valores e prices.items() para pares (chave, valor), que se desempacotam no laço: for symbol, price in prices.items(). Os dicionários lembram a ordem em que as chaves foram adicionadas. Não adicione nem remova chaves enquanto percorre o mesmo dicionário; percorra uma cópia ou construa um novo.

# 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

Remover, combinar e copiar

prices.pop("AAPL", None) remove uma chave e devolve o valor (o padrão se faltava); del prices["AAPL"] remove e gera KeyError se estiver ausente. a.update(b) copia as entradas de b para a, alterando a; {**a, **b} ou a | b cria um dicionário novo em que b vence nas chaves comuns. Como nas listas, copy = prices é só um segundo nome: use dict(prices) ou prices.copy() para uma cópia real.

# 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'}

O que pode ser uma chave

Uma chave deve ser hashable, o que na prática significa que não pode mudar: strings, números e tuplas deles servem; listas e dicionários, não. Tuplas são boas chaves compostas, por exemplo (symbol, venue). Os valores podem ser qualquer coisa, inclusive outra lista ou outro dicionário. A mesma chave só aparece uma vez, então atribuir a ela de novo substitui o valor antigo.

# 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: ler, escrever, testar uma chave.
• d.get(key, default): uma busca segura; d.items(): pares para percorrer.
• d.pop(key, default), del d[key], d.update(other), {**a, **b}: remover e combinar.

A seguir: conjuntos, coleções de valores únicos com testes de pertinência rápidos e uma aritmética de conjuntos elegante.

Lab: o que é avaliado

• Guardar o preço mais recente por símbolo com latest_prices25 pts
• Contar quantas vezes cada símbolo aparece com count_symbols25 pts
• Avaliar uma carteira com dois dicionários usando portfolio_value25 pts
• Combinar dois livros de posições com merge_positions25 pts