Dicionários (dict) em Python

Laboratório de Programação — Ciência da Computação • UFPI

Sintaxe básica, características, exemplos práticos e usos comuns — com syntax highlighting

O que são Dicionários?

  • Estruturas que armazenam pares chave→valor.
  • Chaves devem ser únicas e imutáveis (hashable): str, int, tuple…
  • Valores podem ser de qualquer tipo (incluindo listas, dicts, etc.).
  • Desde o Python 3.7+, preservam ordem de inserção.

Criando dicionários

meu_dicionario = {"nome": "João", "idade": 30, "cidade": "São Paulo"}
vazio = {}

# dict() com pares e iteráveis
dados = dict(nome="Maria", idade=25)
pares = dict([("a", 1), ("b", 2)])

Acessando valores

pessoa = {"nome": "João", "idade": 30}
nome = pessoa["nome"]      # KeyError se "nome" não existir
idade = pessoa.get("idade")# None (ou default) se não existir

# Valor padrão com get()
telefone = pessoa.get("telefone", "sem telefone")

Modificando & adicionando

pessoa = {"nome": "João", "idade": 30}
pessoa["idade"] = 31              # modifica
pessoa["profissao"] = "Programador" # adiciona novo par

# update() mescla/atualiza
pessoa.update({"cidade": "São Paulo", "idade": 32})

Removendo pares

pessoa = {"nome": "João", "idade": 30, "cidade": "SP"}

del pessoa["cidade"]     # remove pela chave (KeyError se não existir)

valor = pessoa.pop("idade", None)  # remove e retorna (ou default)
chave, valor = pessoa.popitem()    # remove o último par inserido

pessoa.clear()            # esvazia o dicionário

Iterando

usuario = {"nome": "Maria", "idade": 25, "email": "maria@example.com"}

for chave in usuario:
    print(chave)               # chaves

for valor in usuario.values():
    print(valor)               # valores

for chave, valor in usuario.items():
    print(chave, valor)        # pares (chave, valor)

Métodos úteis

d = {"a": 1, "b": 2}
d.keys()      # visão dinâmica de chaves
d.values()    # visão de valores
d.items()     # visão de pares

d.get("x", 0) # valor padrão
d.setdefault("c", 3)  # define se não existir

outro = {"b": 22, "d": 4}
d.update(outro)  # mescla/atualiza chaves

len(d)        # quantidade de pares
"x" in d      # teste de existência de CHAVE

Dict comprehension

palavras = ["python", "dados", "laboratorio"]
tamanhos = {p: len(p) for p in palavras}  # {'python':6, ...}

# Inverter chaves/valores (cuidado com duplicatas)
inverso = {v: k for k, v in {"a":1, "b":2}.items()}

Estruturas aninhadas

# Lista de dicionários
alunos = [
    {"nome": "Ana", "nota": 9.1},
    {"nome": "Rui", "nota": 7.8},
]

# Dicionário de listas
turma = {
    "A": ["Ana", "Bea"],
    "B": ["Rui", "Lia"],
}

Exemplo completo — Contagem de palavras

texto = "Python é uma linguagem de programação poderosa e versátil"
contagem_palavras = {}

for palavra in texto.split():
    contagem_palavras[palavra] = contagem_palavras.get(palavra, 0) + 1

print(contagem_palavras)

Contagem de letras

texto = "banana"
contagem_letras = {}
for letra in texto:
    contagem_letras[letra] = contagem_letras.get(letra, 0) + 1

print(contagem_letras)  # {'b': 1, 'a': 3, 'n': 2}

Tradutor simples

dicionario_en_pt = {"hello": "olá", "world": "mundo"}
print(dicionario_en_pt["hello"])   # olá

Cache (memoization)

cache = {}

def caro(n):
    if n in cache:
        return cache[n]
    # simulação de cálculo caro
    r = n * n
    cache[n] = r
    return r

Representando grafos (adjacência)

grafo = {
    "A": ["B", "C"],
    "B": ["A", "D"],
    "C": ["A"],
    "D": ["B"]
}

Configurações (settings)

config = {
  "idioma": "pt-BR",
  "tema": "claro",
  "notificacoes": True
}

Boas práticas & armadilhas

  • Chaves imutáveis: use str, int, tuple (evite listas/dicts como chave).
  • Evite KeyError: prefira get(), in ou setdefault().
  • Ordem preservada (3.7+), mas não use dict para ordenação — prefira sorted(d.items()).
  • Cópias: copy() é rasa; para profundidade use copy.deepcopy().
  • Merge moderno (3.9+): novo = d1 | d2 e d1 |= d2.

Usos comuns de dict

  • Armazenar dados estruturados (usuários, produtos, configs).
  • Contadores/estatísticas (palavras, letras, eventos).
  • Grafos/Mapas (listas de adjacência).
  • Cache de resultados caros e dados de API.
  • Tradução/lookup chave→valor rápido.

Cheat Sheet

# Criar: {}, dict(), dict(k=v), dict(lista_de_pares)
# Acesso: d[k]; d.get(k, default); k in d
# Inserir/Atualizar: d[k]=v; d.update({k:v}); d |= outro
# Remover: del d[k]; d.pop(k, default); d.popitem(); d.clear()
# Iterar: for k in d; for v in d.values(); for k,v in d.items()
# Views: d.keys(), d.values(), d.items() (dinâmicas)
# Comprehension: {k: f(v) for k, v in pares if cond}
# Cópias: d.copy() (rasa); copy.deepcopy(d) (profunda)

Conclusões & Dicas

  • Dict = mapeamento flexível e eficiente (chave→valor).
  • Escolha chaves imutáveis e autoexplicativas.
  • Use métodos como get, setdefault e update a seu favor.
  • Combine com listas/tuplas para modelar dados complexos.