Dicionários

Dicionários mapeiam chaves hashable para valores arbitrários com busca O(1) em média. Eles são a ferramenta padrão para registros, índices, caches e tabelas de despacho em código de aplicação Python.

Receita

defaults = {"retries": 3, "timeout": 30}
overrides = {"timeout": 60}
config = defaults | overrides
 
for key in config:
    print(key, config[key])
 
if "retries" not in config:
    config["retries"] = 1

Quando usar isso:

• Registros semelhantes a JSON e payloads de API
• Contagem e agrupamento (frequentemente com Counter)
• Caches de memoização com chaves de argumentos
• Tabelas de despacho de string para manipulador

Exemplo de Trabalho

from collections.abc import Callable
 
Handler = Callable[[dict], str]
 
def dispatch(handlers: dict[str, Handler], event: dict) -> str:
    kind = str(event.get("type", "unknown"))
    handler = handlers.get(kind, handlers["unknown"])
    return handler(event)
 
def merge_records(base: dict[str, object], patch: dict[str, object]) -> dict[str, object]:
    merged = base.copy()
    merged.update(patch)
    return merged
 
def invert_unique(mapping: dict[str, int]) -> dict[int, str]:
    return {value: key for key, value in mapping.items()}
 
if __name__ == "__main__":
    handlers: dict[str, Handler] = {
        "user.created": lambda e: f"create {e['id']}",
        "unknown": lambda e: "noop",
    }
    print(dispatch(handlers, {"type": "user.created", "id": 42}))
    print(merge_records({"a": 1}, {"b": 2}))

O que isso demonstra:

• handlers.get(kind, default) evita KeyError para eventos desconhecidos
• dict.copy + update mesclam registros superficialmente
• Compreensão de dicionário inverte o mapeamento quando os valores são únicos
• Valores Callable transformam dicionários em tabelas de despacho

Mergulho Profundo

Como Funciona

• Tabela Hash - Chaves são hasheadas em buckets; endereçamento aberto resolve colisões.
• Ordem de Inserção - A ordem de iteração corresponde à ordem de inserção (re-inserir move a chave para o final em 3.7+).
• Visualizações (Views) - keys(), values(), items() são visualizações dinâmicas, não snapshots.
• Igualdade - Dois dicionários são iguais se tiverem os mesmos pares chave-valor, independentemente da ordem.
• fromkeys - dict.fromkeys(keys, default) cria um dicionário com o cuidado de compartilhar o valor padrão.

Opções de Mesclagem

Notas Python

# setdefault apenas quando ausente
counts: dict[str, int] = {}
counts.setdefault("a", 0)
counts["a"] += 1
 
# pop com padrão
value = config.pop("missing", None)

Armadilhas

• Valores mutáveis compartilhados via fromkeys - dict.fromkeys(keys, []) compartilha uma única lista. Correção: Compreensão com um novo objeto mutável.
• Iterar chaves e depois deletar - RuntimeError se o tamanho mudar durante a iteração. Correção: Use list(d) para criar um snapshot primeiro.
• Usar float NaN como chave - NaN != NaN quebra as suposições de unicidade. Correção: Evite ou normalize.
• Memória de dicionários grandes - Cada objeto de chave é armazenado. Correção: Considere um banco de dados, índice em disco ou objetos __slots__ para registros.
• Confiar na ordem para testes de igualdade - A ordem difere entre construções. Correção: Compare como dicionários, não como listas de chaves.

Alternativas

FAQs

Relacionados

• Sets & Frozensets - operações de unicidade complementares
• Módulo collections - defaultdict, Counter
• Imutabilidade & Hashability - chaves válidas
• TypedDict & NamedTuple - registros tipados

Versões da Pilha: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+ e uv 0.6+.