Dicionários são estruturas de dados fundamentais em Python, que armazenam pares chave-valor. Eles são mutáveis, iteráveis e extremamente versáteis para representar dados associativos. Nesta aula, você aprenderá a criar, acessar, modificar e iterar sobre dicionários, além de compreender os principais métodos e como usar compreensões de dicionário para criar estruturas de forma concisa.

Dicionários são implementados internamente como tabelas hash, o que garante acesso rápido (O(1) em média) para operações de busca, inserção e remoção. Eles são amplamente utilizados em aplicações reais, como configurações, mapeamento de dados e representação de objetos JSON.

Criação e acesso

Um dicionário é criado usando chaves {} ou o construtor dict(). Cada elemento é um par chave: valor, separado por vírgulas. As chaves devem ser imutáveis (strings, números, tuplas) e os valores podem ser de qualquer tipo.

Para acessar um valor, usamos a chave entre colchetes []. Se a chave não existir, um erro KeyError é lançado. Para evitar isso, podemos usar o método get() que retorna None ou um valor padrão.

# Criação
meu_dict = {'nome': 'Ana', 'idade': 30, 'cidade': 'São Paulo'}
outro_dict = dict(chave1=1, chave2=2)  # chaves devem ser strings válidas

# Acesso
print(meu_dict['nome'])  # Ana
# print(meu_dict['pais'])  # KeyError

print(meu_dict.get('pais'))  # None
print(meu_dict.get('pais', 'Brasil'))  # Brasil

Métodos (get, items, keys)

Os dicionários possuem diversos métodos úteis. keys() retorna uma visão (view) das chaves, values() retorna uma visão dos valores e items() retorna uma visão de pares (chave, valor). Essas visões são dinâmicas e refletem mudanças no dicionário.

O método get() já foi mencionado. Outros métodos importantes incluem pop() (remove e retorna o valor de uma chave), popitem() (remove e retorna o último par inserido), update() (atualiza o dicionário com pares de outro) e clear() (remove todos os itens).

d = {'a': 1, 'b': 2, 'c': 3}

print(d.keys())   # dict_keys(['a', 'b', 'c'])
print(d.values()) # dict_values([1, 2, 3])
print(d.items())  # dict_items([('a', 1), ('b', 2), ('c', 3)])

# get já visto
print(d.get('d', 'Não encontrado'))  # Não encontrado

# pop
valor = d.pop('a')
print(valor)  # 1
print(d)      # {'b': 2, 'c': 3}

# update
d.update({'d': 4, 'b': 20})
print(d)  # {'b': 20, 'c': 3, 'd': 4}

Iteração

Podemos iterar sobre dicionários de várias formas. O loop for padrão itera sobre as chaves. Para iterar sobre valores, usamos .values(), e para pares chave-valor, .items().

É importante lembrar que a ordem de iteração é a ordem de inserção (a partir do Python 3.7). Em versões anteriores, a ordem não era garantida.

d = {'nome': 'João', 'idade': 25, 'curso': 'Python'}

# Iterar sobre chaves
for chave in d:
    print(chave, '->', d[chave])

# Iterar sobre valores
for valor in d.values():
    print(valor)

# Iterar sobre itens
for chave, valor in d.items():
    print(f'{chave}: {valor}')

Dict comprehensions

Dict comprehensions permitem criar dicionários de forma concisa, similar às list comprehensions. A sintaxe é {chave: valor for elemento in iterável}. Podemos incluir condições opcionais.

São úteis para transformar dados, como inverter um dicionário ou filtrar itens.

# Dicionário de números ao quadrado
quadrados = {x: x**2 for x in range(5)}
print(quadrados)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Filtrar pares
pares = {x: x**2 for x in range(10) if x % 2 == 0}
print(pares)  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# Inverter chave e valor (valores únicos)
original = {'a': 1, 'b': 2, 'c': 3}
invertido = {valor: chave for chave, valor in original.items()}
print(invertido)  # {1: 'a', 2: 'b', 3: 'c'}

Boas práticas

Use get() em vez de acesso direto quando não tiver certeza se a chave existe. Prefira .items() para iterar sobre chave e valor simultaneamente. Evite modificar o dicionário enquanto itera sobre ele; se necessário, crie uma cópia. Dict comprehensions são eficientes, mas não abuse da complexidade; mantenha a legibilidade.

Referências

Exercícios

  1. Crie um dicionário chamado aluno com as chaves 'nome', 'idade', 'nota' e valores 'Maria', 22, 9.5. Em seguida, imprima a idade do aluno usando o método get.

    ✓ Resposta:
    aluno = {'nome': 'Maria', 'idade': 22, 'nota': 9.5}
print(aluno.get('idade'))  # 22

  2. Dado o dicionário estoque = {'maçã': 10, 'banana': 5, 'laranja': 8}, use o método items() para imprimir cada produto e sua quantidade, um por linha, no formato 'Produto: quantidade'.

    ✓ Resposta:
    estoque = {'maçã': 10, 'banana': 5, 'laranja': 8}
for produto, qtd in estoque.items():
    print(f'{produto}: {qtd}')

  3. Escreva uma dict comprehension que gere um dicionário onde as chaves são números de 1 a 10 e os valores são seus cubos.

    ✓ Resposta:
    cubos = {x: x**3 for x in range(1, 11)}
print(cubos)

  4. Crie um dicionário a partir de duas listas: chaves = ['a', 'b', 'c'] e valores = [1, 2, 3]. Use o construtor dict() com zip() ou dict comprehension.

    ✓ Resposta:
    chaves = ['a', 'b', 'c']
valores = [1, 2, 3]
# usando dict com zip
meu_dict = dict(zip(chaves, valores))
print(meu_dict)  # {'a': 1, 'b': 2, 'c': 3}
# ou dict comprehension
meu_dict2 = {chave: valor for chave, valor in zip(chaves, valores)}

  5. Dado o dicionário notas = {'Ana': 8, 'Bia': 9, 'Carlos': 7, 'Duda': 10}, crie um novo dicionário apenas com os alunos que têm nota maior ou igual a 9, usando dict comprehension.

    ✓ Resposta:
    notas = {'Ana': 8, 'Bia': 9, 'Carlos': 7, 'Duda': 10}
melhores = {aluno: nota for aluno, nota in notas.items() if nota >= 9}
print(melhores)  # {'Bia': 9, 'Duda': 10}