Dicionários: chave, valor e as estruturas do mundo real

Se listas organizam dados por posição, dicionários organizam dados por significado. Em vez de acessar um valor pelo índice 0 ou 3, você o acessa por um nome descritivo — uma chave. Dicionários são a estrutura de dados mais versátil do Python e aparecem em praticamente todo código profissional: configurações, respostas de APIs, registros de banco de dados e muito mais.

Criando Dicionários

# Sintaxe literal com chaves
aluno = {
    "nome": "Ricardo",
    "idade": 35,
    "curso": "Python",
    "ativo": True
}

# Construtor dict()
produto = dict(nome="Teclado", preco=299.90, estoque=15)

# Dicionário vazio
config = {}
config = dict()

Acessando Valores

aluno = {"nome": "Ana", "nota": 9.5, "cidade": "Recife"}

# Por chave
print(aluno["nome"])    # Ana

# Com get() — retorna None se a chave não existir (sem erro)
print(aluno.get("nota"))       # 9.5
print(aluno.get("email"))      # None
print(aluno.get("email", "não informado"))  # valor padrão

Prefira .get() quando não tem certeza se a chave existe — acessar uma chave inexistente com [] gera KeyError.

Modificando Dicionários

aluno = {"nome": "Bruno", "nota": 7.0}

# Adicionando ou atualizando
aluno["email"] = "bruno@email.com"
aluno["nota"] = 8.5

# Atualizando múltiplos valores de uma vez
aluno.update({"nota": 9.0, "cidade": "Salvador"})

print(aluno)
# {'nome': 'Bruno', 'nota': 9.0, 'email': 'bruno@email.com', 'cidade': 'Salvador'}

Removendo Entradas

dados = {"a": 1, "b": 2, "c": 3, "d": 4}

# pop() — remove e retorna o valor
valor = dados.pop("b")
print(valor)   # 2

# pop() com padrão — evita KeyError
valor = dados.pop("z", None)

# del — remove sem retornar
del dados["c"]

# popitem() — remove e retorna o último par inserido (Python 3.7+)
chave, valor = dados.popitem()

# clear() — esvazia o dicionário
dados.clear()

Iterando sobre Dicionários

estoque = {"maçã": 50, "banana": 30, "laranja": 45}

# Iterando sobre chaves (padrão)
for fruta in estoque:
    print(fruta)

# Iterando sobre valores
for quantidade in estoque.values():
    print(quantidade)

# Iterando sobre pares chave-valor
for fruta, quantidade in estoque.items():
    print(f"{fruta}: {quantidade} unidades")

Verificando Existência de Chaves

config = {"debug": True, "host": "localhost", "porta": 8080}

if "debug" in config:
    print("Modo debug ativo")

if "timeout" not in config:
    config["timeout"] = 30

Métodos Úteis

d = {"x": 10, "y": 20, "z": 30}

print(d.keys())    # dict_keys(['x', 'y', 'z'])
print(d.values())  # dict_values([10, 20, 30])
print(d.items())   # dict_items([('x', 10), ('y', 20), ('z', 30)])
print(len(d))      # 3

# Copiando corretamente
copia = d.copy()

# setdefault — insere chave com valor padrão se não existir
d.setdefault("w", 0)
print(d["w"])  # 0

Dict Comprehension

Assim como list comprehensions, dicionários têm sua versão compacta:

# Quadrados de 1 a 5
quadrados = {n: n ** 2 for n in range(1, 6)}
print(quadrados)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Filtrando itens
estoque = {"maçã": 50, "banana": 0, "laranja": 45, "uva": 0}
disponiveis = {k: v for k, v in estoque.items() if v > 0}
print(disponiveis)  # {'maçã': 50, 'laranja': 45}

# Invertendo chaves e valores
codigos = {"BR": "Brasil", "US": "Estados Unidos", "DE": "Alemanha"}
invertido = {v: k for k, v in codigos.items()}
print(invertido)  # {'Brasil': 'BR', ...}

Dicionários Aninhados

Dicionários podem conter outros dicionários — estrutura comum em dados de APIs e configurações:

usuarios = {
    "ana": {
        "email": "ana@email.com",
        "nivel": "admin",
        "pontos": 1500
    },
    "bruno": {
        "email": "bruno@email.com",
        "nivel": "usuario",
        "pontos": 320
    }
}

# Acessando dados aninhados
print(usuarios["ana"]["email"])    # ana@email.com
print(usuarios["bruno"]["pontos"]) # 320

# Iterando
for usuario, dados in usuarios.items():
    print(f"{usuario} ({dados['nivel']}): {dados['pontos']} pontos")

Mesclando Dicionários

A partir do Python 3.9, há uma sintaxe elegante para mesclar dicionários:

padroes = {"tema": "claro", "idioma": "pt-BR", "timeout": 30}
personalizados = {"tema": "escuro", "fonte": "JetBrains Mono"}

# Operador | — cria novo dicionário mesclado
config = padroes | personalizados
print(config)
# {'tema': 'escuro', 'idioma': 'pt-BR', 'timeout': 30, 'fonte': 'JetBrains Mono'}

# Operador |= — atualiza in-place
padroes |= personalizados

Em versões anteriores ao Python 3.9, use {**padroes, **personalizados}.

Exemplo Completo: Frequência de Palavras

def contar_palavras(texto):
    """Conta a frequência de cada palavra em um texto."""
    palavras = texto.lower().split()
    frequencia = {}

    for palavra in palavras:
        # Remove pontuação simples
        palavra = palavra.strip(".,!?;:")
        frequencia[palavra] = frequencia.get(palavra, 0) + 1

    return frequencia

def top_palavras(frequencia, n=5):
    """Retorna as n palavras mais frequentes."""
    ordenado = sorted(frequencia.items(), key=lambda item: item[1], reverse=True)
    return ordenado[:n]


texto = """
Python é uma linguagem incrível. Python é simples e Python é poderoso.
Aprender Python vale muito a pena. A linguagem Python cresce a cada ano.
"""

freq = contar_palavras(texto)
print("Top 5 palavras:")
for palavra, count in top_palavras(freq):
    print(f"  {palavra:>10}: {count}x")

Saída:

Top 5 palavras:
     python: 5x
          é: 4x
          a: 3x
   linguagem: 2x
      simples: 1x

Resumo

Dicionários armazenam pares chave-valor com acesso por nome
Use .get() para acesso seguro sem risco de KeyError
.keys(), .values() e .items() permitem iteração flexível
Dict comprehensions criam dicionários de forma compacta e expressiva
Dicionários aninhados representam estruturas complexas como objetos JSON
O operador | (Python 3.9+) mescla dicionários de forma elegante
setdefault() e .get(chave, padrão) evitam verificações manuais de existência

Referências e Leituras Complementares

Dicionários — documentação oficial — https://docs.python.org/3/tutorial/datastructures.html#dictionaries
dict.get(), setdefault(), update() — https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
PEP 584 — operador de união para dicionários — https://peps.python.org/pep-0584/
Dict comprehensions (PEP 274) — https://peps.python.org/pep-0274/
RAMALHO, Luciano. Fluent Python. 2. ed. O'Reilly Media, 2022. Cap. 3 — análise profunda de dicionários e sets como tabelas hash.
GOODRICH, Michael T. et al. Data Structures and Algorithms in Python. Wiley, 2013. Cap. 10 — mapas, tabelas hash e implementações.
HUNT, John. Advanced Guide to Python 3 Programming. Springer, 2019. Cap. 4 — uso avançado de coleções em Python.

Dicionários: chave, valor e as estruturas do mundo real Já leu