Dicionários: cada valor com o seu nome

O problema do quem é quem

Suponha que o seu programa precise guardar o nome e a idade de três pessoas. Com o que você sabe até aqui, a saída seria duas listas andando em paralelo: uma de nomes, outra de idades, torcendo para as posições continuarem casadas. O nome no índice 1 combina com a idade no índice 1, e assim por diante. Funciona até alguém remover um item de uma lista e esquecer da outra. A partir daí, Bruno passa a ter a idade da Carla, e nenhum erro aparece na tela: o programa segue rodando, confiante e errado.

nomes = ["Ana", "Bruno", "Carla"]
idades = [21, 35, 28]

# Alguém remove a Ana da lista de nomes e esquece a idade dela...
nomes.remove("Ana")

print(nomes[0], idades[0])

# Saída:
# Bruno 21
# O Bruno herdou a idade da Ana. Nenhum erro, só dado errado.

Listas paralelas quebram em silêncio: o pior tipo de defeito, o que não avisa.

O dicionário elimina essa fragilidade amarrando cada valor à sua etiqueta. Em vez de duas coleções torcendo para ficarem sincronizadas, uma única estrutura guarda os pares: a chave Ana aponta para 21, a chave Bruno aponta para 35. Removeu a Ana? O par inteiro sai junto. Não existe mais a posição 0 de uma lista casando com a posição 0 de outra; existe a pergunta direta, qual é a idade do Bruno, respondida pelo nome.

idades = {"Ana": 21, "Bruno": 35, "Carla": 28}

print(idades["Bruno"])
print(type(idades))

# Saída:
# 35
# <class 'dict'>

O dicionário: chaves { } por fora, pares chave: valor por dentro, busca pelo nome.

Acessar, adicionar e alterar

A sintaxe do dia a dia cabe em uma regra: colchetes com a chave dentro. Para ler, idades["Ana"]. Para alterar, idades["Ana"] = 22. Para adicionar um par novo, a mesma coisa com uma chave que ainda não existe: idades["Duda"] = 19. O Python decide sozinho: se a chave existe, troca o valor; se não existe, cria o par. Uma sintaxe, três operações.

idades = {"Ana": 21, "Bruno": 35, "Carla": 28}

idades["Duda"] = 19   # chave nova: adiciona o par
idades["Ana"] = 22    # chave existente: altera o valor

print(idades)
print(len(idades))

# Saída:
# {'Ana': 22, 'Bruno': 35, 'Carla': 28, 'Duda': 19}
# 4

Adicionar e alterar têm a mesma cara; o que muda é a chave já existir ou não.

Duas observações que evitam confusão adiante. Primeira: as chaves são únicas. Se você atribuir idades["Ana"] duas vezes, a segunda atribuição sobrescreve a primeira; não existem duas Anas no mesmo dicionário. Segunda: os valores podem ser de qualquer tipo e podem se repetir à vontade. Duas pessoas com 28 anos não geram conflito nenhum, porque a unicidade é exigida só do lado da chave.

Para remover um par, existe a instrução del: del idades["Carla"] apaga a chave e o valor juntos. E o operador in, que você usou com listas no módulo 10, aqui verifica as chaves: "Ana" in idades responde True. Repare como o conhecimento acumulado vai se encaixando: in, len e for funcionam em todas as coleções, cada uma com o seu jeito.

KeyError e o get: perguntando sem quebrar

E quando a chave não existe? Depende de como você pergunta. Com colchetes, o Python é rigoroso: pedir idades["Felipe"] num dicionário sem Felipe derruba o programa com KeyError, apontando a chave que faltou. É o mesmo espírito do IndexError das listas: pergunta impossível, erro imediato.

idades = {"Ana": 22, "Bruno": 35}

print(idades["Felipe"])

# KeyError: 'Felipe'
# O Python aponta exatamente a chave que não foi encontrada.

Colchetes com chave inexistente: KeyError e programa parado na linha do problema.

Só que nem toda chave ausente é um defeito. Às vezes ela é uma possibilidade legítima: o usuário busca um contato que talvez não esteja na agenda, o placar consulta um jogador que talvez ainda não pontuou. Para esses casos existe o método get, que faz a mesma pergunta com um plano B embutido: se a chave existir, devolve o valor; se não existir, devolve None ou o padrão que você escolher, sem derrubar nada.

idades = {"Ana": 22, "Bruno": 35}

print(idades.get("Felipe"))
print(idades.get("Felipe", 0))
print(idades.get("Ana", 0))

# Saída:
# None
# 0
# 22

O get nunca explode: devolve None, ou o padrão informado, ou o valor real se a chave existe.

Qual usar? Colchetes quando a chave TEM que existir, porque aí o KeyError é seu aliado, denunciando um defeito cedo. O get quando a ausência é normal e o programa tem o que fazer nesse caso. Guardar essa distinção agora vai render: no módulo 14, sobre erros e exceções, essa ideia de escolher entre erro barulhento e plano B volta como tema central.