Dicionários em Python: Guia Completo com Exemplos Práticos

Dicionários são uma das estruturas de dados mais poderosas e versáteis do Python. Eles permitem armazenar informações em pares de chave-valor, tornando a organização e recuperação de dados extremamente eficiente. Neste guia completo, você vai aprender tudo sobre dicionários, desde o básico até técnicas avançadas.

🎯 O Que São Dicionários?

Um dicionário em Python é uma coleção não ordenada (a partir do Python 3.7, mantém a ordem de inserção) de pares chave-valor. Cada chave é única e mapeia para um valor específico, funcionando como um índice personalizado.

Pense em um dicionário como um verdadeiro dicionário de palavras: você procura uma palavra (chave) e encontra sua definição (valor). Essa estrutura é incrivelmente útil para representar dados do mundo real.

📝 Criando Dicionários

Existem várias formas de criar dicionários em Python:

# Dicionário vazio
pessoa = {}

# Dicionário com dados
usuario = {
    "nome": "Ana Silva",
    "idade": 28,
    "cidade": "São Paulo",
    "profissao": "Desenvolvedora Python"
}

# Usando o construtor dict()
produto = dict(nome="Notebook", preco=2500.00, estoque=15)

# Dicionário com tipos variados de valores
dados = {
    "texto": "Python",
    "numero": 42,
    "lista": [1, 2, 3],
    "booleano": True,
    "outro_dict": {"chave": "valor"}
}

print(usuario["nome"])  # Ana Silva
print(produto["preco"])  # 2500.0

🔍 Acessando Valores

Existem duas maneiras principais de acessar valores em um dicionário:

livro = {
    "titulo": "Python para Iniciantes",
    "autor": "João Santos",
    "ano": 2025,
    "paginas": 350
}

# Método 1: Usando colchetes
titulo = livro["titulo"]
print(titulo)  # Python para Iniciantes

# Método 2: Usando get() - mais seguro
autor = livro.get("autor")
print(autor)  # João Santos

# Diferença importante: get() não gera erro se a chave não existir
editora = livro.get("editora", "Não informado")
print(editora)  # Não informado

# Já os colchetes geram KeyError se a chave não existir
# isbn = livro["isbn"]  # KeyError: 'isbn'

Por Que Usar get()?

O método get() é mais seguro porque permite definir um valor padrão caso a chave não exista, evitando erros que podem quebrar seu programa. Isso é especialmente útil quando você está trabalhando com dados externos ou APIs.

➕ Adicionando e Modificando Valores

Dicionários são mutáveis, o que significa que você pode adicionar, modificar e remover pares chave-valor após a criação:

aluno = {
    "nome": "Carlos",
    "curso": "Ciência da Computação"
}

# Adicionar nova chave
aluno["matricula"] = "2025001"
aluno["nota"] = 9.5

# Modificar valor existente
aluno["curso"] = "Engenharia de Software"

# Adicionar múltiplos pares com update()
aluno.update({
    "semestre": 3,
    "ativo": True,
    "email": "[email protected]"
})

print(aluno)
# {
#     'nome': 'Carlos',
#     'curso': 'Engenharia de Software',
#     'matricula': '2025001',
#     'nota': 9.5,
#     'semestre': 3,
#     'ativo': True,
#     'email': '[email protected]'
# }

➖ Removendo Elementos

Python oferece várias maneiras de remover elementos de um dicionário:

carro = {
    "marca": "Toyota",
    "modelo": "Corolla",
    "ano": 2024,
    "cor": "Prata",
    "km": 0
}

# Método 1: del - remove chave específica
del carro["cor"]

# Método 2: pop() - remove e retorna o valor
quilometragem = carro.pop("km")
print(f"Removido: {quilometragem} km")  # Removido: 0 km

# Método 3: pop() com valor padrão
acessorios = carro.pop("acessorios", [])
print(acessorios)  # []

# Método 4: popitem() - remove e retorna último par inserido
ultimo_item = carro.popitem()
print(ultimo_item)  # ('modelo', 'Corolla')

# Método 5: clear() - remove todos os elementos
carro.clear()
print(carro)  # {}

🔄 Iterando sobre Dicionários

Existem diversas formas de percorrer um dicionário, cada uma com seu propósito específico:

notas = {
    "matemática": 8.5,
    "português": 9.0,
    "história": 7.5,
    "física": 8.0
}

# Iterar sobre chaves
print("Disciplinas:")
for disciplina in notas.keys():
    print(f"- {disciplina}")

# Iterar sobre valores
print("\nNotas:")
for nota in notas.values():
    print(f"- {nota}")

# Iterar sobre chaves e valores (mais comum)
print("\nBoletim:")
for disciplina, nota in notas.items():
    situacao = "Aprovado ✅" if nota >= 7 else "Reprovado ❌"
    print(f"{disciplina}: {nota} - {situacao}")

# OUTPUT:
# Matemática: 8.5 - Aprovado ✅
# Português: 9.0 - Aprovado ✅
# História: 7.5 - Aprovado ✅
# Física: 8.0 - Aprovado ✅

🔑 Verificando Existência de Chaves

Antes de acessar uma chave, é sempre bom verificar se ela existe:

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

# Verificar com 'in'
if "tema" in config:
    print(f"Tema atual: {config['tema']}")  # Tema atual: escuro

if "volume" not in config:
    config["volume"] = 80  # Define valor padrão

# Alternativa: usar get() com valor padrão
volume = config.get("volume", 50)
brilho = config.get("brilho", 100)

print(f"Volume: {volume}")   # Volume: 80
print(f"Brilho: {brilho}")   # Brilho: 100

📊 Métodos Úteis de Dicionários

Python fornece diversos métodos nativos para trabalhar com dicionários de forma eficiente:

estoque = {
    "notebook": 25,
    "mouse": 150,
    "teclado": 80,
    "monitor": 35
}

# keys() - retorna todas as chaves
produtos = list(estoque.keys())
print(f"Produtos disponíveis: {produtos}")

# values() - retorna todos os valores
quantidades = list(estoque.values())
total_itens = sum(quantidades)
print(f"Total de itens em estoque: {total_itens}")

# items() - retorna pares chave-valor
for produto, quantidade in estoque.items():
    if quantidade < 50:
        print(f"⚠️ Estoque baixo: {produto} ({quantidade} unidades)")

# copy() - cria uma cópia superficial
backup_estoque = estoque.copy()

# fromkeys() - cria dicionário com chaves e valor padrão
categorias = ["eletrônicos", "roupas", "livros"]
estoque_categorias = dict.fromkeys(categorias, 0)
print(estoque_categorias)
# {'eletrônicos': 0, 'roupas': 0, 'livros': 0}

# setdefault() - retorna valor ou define se não existir
estoque.setdefault("webcam", 20)
print(estoque["webcam"])  # 20

🎨 Dictionary Comprehension

Assim como list comprehension (que vimos no nosso guia de listas), também podemos criar dicionários de forma concisa:

# Criar dicionário de quadrados
quadrados = {num: num**2 for num in range(1, 6)}
print(quadrados)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Filtrar dicionário
numeros = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
pares = {k: v for k, v in numeros.items() if v % 2 == 0}
print(pares)  # {'b': 2, 'd': 4}

# Inverter chaves e valores
original = {"nome": "Ana", "cidade": "SP", "idade": "28"}
invertido = {v: k for k, v in original.items()}
print(invertido)  # {'Ana': 'nome', 'SP': 'cidade', '28': 'idade'}

# Transformar lista em dicionário
frutas = ["maçã", "banana", "laranja"]
precos = [3.50, 2.00, 4.00]
tabela_precos = {fruta: preco for fruta, preco in zip(frutas, precos)}
print(tabela_precos)
# {'maçã': 3.5, 'banana': 2.0, 'laranja': 4.0}

# Contagem de caracteres
texto = "python"
contagem = {char: texto.count(char) for char in texto}
print(contagem)  # {'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}

🔁 Dicionários Aninhados

Dicionários podem conter outros dicionários, criando estruturas de dados complexas perfeitas para representar informações hierárquicas:

empresa = {
    "nome": "TechCorp",
    "fundacao": 2020,
    "funcionarios": {
        "dev001": {
            "nome": "Ana Silva",
            "cargo": "Desenvolvedora Senior",
            "salario": 12000,
            "tech_stack": ["Python", "Django", "PostgreSQL"]
        },
        "dev002": {
            "nome": "Bruno Costa",
            "cargo": "DevOps Engineer",
            "salario": 11000,
            "tech_stack": ["Docker", "Kubernetes", "AWS"]
        },
        "dev003": {
            "nome": "Carla Santos",
            "cargo": "Data Scientist",
            "salario": 13000,
            "tech_stack": ["Python", "Pandas", "TensorFlow"]
        }
    },
    "departamentos": {
        "desenvolvimento": ["dev001", "dev002"],
        "dados": ["dev003"]
    }
}

# Acessar dados aninhados
print(empresa["funcionarios"]["dev001"]["nome"])  # Ana Silva

# Iterar sobre funcionários
print("\n👥 Equipe:")
for id_func, dados in empresa["funcionarios"].items():
    print(f"\n{id_func}:")
    print(f"  Nome: {dados['nome']}")
    print(f"  Cargo: {dados['cargo']}")
    print(f"  Tecnologias: {', '.join(dados['tech_stack'])}")

# Calcular folha de pagamento
total_salarios = sum(
    func["salario"] 
    for func in empresa["funcionarios"].values()
)
print(f"\n💰 Folha de pagamento total: R$ {total_salarios:,.2f}")
# 💰 Folha de pagamento total: R$ 36,000.00

🎯 Projeto Prático: Sistema de Cadastro de Alunos

Vamos criar um sistema completo de gerenciamento de alunos usando dicionários:

class SistemaEscolar:
    def __init__(self):
        self.alunos = {}
        self.proximo_id = 1

    def cadastrar_aluno(self, nome, idade, curso):
        """Cadastra um novo aluno no sistema"""
        id_aluno = f"ALU{self.proximo_id:04d}"
        
        self.alunos[id_aluno] = {
            "nome": nome,
            "idade": idade,
            "curso": curso,
            "notas": {},
            "ativo": True
        }
        
        self.proximo_id += 1
        print(f"✅ Aluno cadastrado: {nome} (ID: {id_aluno})")
        return id_aluno

    def adicionar_nota(self, id_aluno, disciplina, nota):
        """Adiciona nota de uma disciplina"""
        if id_aluno in self.alunos:
            self.alunos[id_aluno]["notas"][disciplina] = nota
            print(f"✅ Nota adicionada: {disciplina} = {nota}")
        else:
            print(f"❌ Aluno {id_aluno} não encontrado")

    def calcular_media(self, id_aluno):
        """Calcula média geral do aluno"""
        if id_aluno not in self.alunos:
            return None
        
        notas = self.alunos[id_aluno]["notas"].values()
        if not notas:
            return 0
        
        return sum(notas) / len(notas)

    def exibir_boletim(self, id_aluno):
        """Exibe boletim completo do aluno"""
        if id_aluno not in self.alunos:
            print(f"❌ Aluno {id_aluno} não encontrado")
            return
        
        aluno = self.alunos[id_aluno]
        print(f"\n{'='*50}")
        print(f"📋 BOLETIM - {aluno['nome']}")
        print(f"{'='*50}")
        print(f"ID: {id_aluno}")
        print(f"Curso: {aluno['curso']}")
        print(f"Idade: {aluno['idade']} anos")
        print(f"\n📚 Notas:")
        
        if aluno['notas']:
            for disciplina, nota in aluno['notas'].items():
                status = "✅" if nota >= 7 else "❌"
                print(f"  {disciplina}: {nota} {status}")
            
            media = self.calcular_media(id_aluno)
            print(f"\n📊 Média Geral: {media:.2f}")
            
            if media >= 7:
                print("🎉 Situação: APROVADO")
            else:
                print("⚠️ Situação: REPROVADO")
        else:
            print("  Nenhuma nota cadastrada")
        
        print(f"{'='*50}\n")

    def listar_alunos(self):
        """Lista todos os alunos cadastrados"""
        if not self.alunos:
            print("Nenhum aluno cadastrado")
            return
        
        print(f"\n{'='*50}")
        print("👥 ALUNOS CADASTRADOS")
        print(f"{'='*50}")
        
        for id_aluno, dados in self.alunos.items():
            status = "🟢 Ativo" if dados["ativo"] else "🔴 Inativo"
            media = self.calcular_media(id_aluno)
            
            print(f"{id_aluno} - {dados['nome']}")
            print(f"  Curso: {dados['curso']} | Média: {media:.1f} | {status}")
        
        print(f"{'='*50}\n")


# Testando o sistema
sistema = SistemaEscolar()

# Cadastrar alunos
id1 = sistema.cadastrar_aluno("Ana Silva", 20, "Ciência da Computação")
id2 = sistema.cadastrar_aluno("Bruno Costa", 22, "Engenharia de Software")

# Adicionar notas
sistema.adicionar_nota(id1, "Python", 9.5)
sistema.adicionar_nota(id1, "Banco de Dados", 8.5)
sistema.adicionar_nota(id1, "Algoritmos", 9.0)

sistema.adicionar_nota(id2, "Python", 7.0)
sistema.adicionar_nota(id2, "DevOps", 8.0)

# Exibir informações
sistema.listar_alunos()
sistema.exibir_boletim(id1)

💡 Dicionários vs Listas: Quando Usar Cada Um?

É importante entender quando usar dicionários e quando usar listas:

Use Dicionários quando:

• Você precisa acessar elementos por uma chave personalizada (nome, ID, etc.)
• A ordem dos elementos não é crucial (embora seja mantida desde Python 3.7)
• Você precisa verificar rapidamente se uma chave existe
• Está trabalhando com dados estruturados em formato chave-valor
• Precisa de acesso rápido O(1) aos elementos

Use Listas quando:

• A ordem dos elementos é importante
• Você acessa elementos por posição numérica
• Permite valores duplicados
• Precisa realizar operações de ordenação frequentemente

🔗 Dicionários e JSON

Dicionários Python são perfeitamente compatíveis com JSON, o formato de dados mais usado na web:

import json

# Dicionário Python
usuario = {
    "nome": "João Silva",
    "email": "[email protected]",
    "idade": 30,
    "ativo": True,
    "interesses": ["Python", "Data Science", "IA"]
}

# Converter para JSON (string)
json_string = json.dumps(usuario, indent=2, ensure_ascii=False)
print(json_string)

# Salvar em arquivo
with open("usuario.json", "w", encoding="utf-8") as arquivo:
    json.dump(usuario, arquivo, indent=2, ensure_ascii=False)

# Ler de arquivo
with open("usuario.json", "r", encoding="utf-8") as arquivo:
    dados = json.load(arquivo)
    print(f"Nome: {dados['nome']}")

# Converter JSON string para dicionário
json_texto = '{"linguagem": "Python", "nivel": "Avançado"}'
dicionario = json.loads(json_texto)
print(dicionario)  # {'linguagem': 'Python', 'nivel': 'Avançado'}

⚡ Performance: Dicionários São Rápidos!

Dicionários em Python usam hash tables internamente, o que os torna extremamente eficientes. A busca, inserção e remoção de elementos tem complexidade O(1) em média, ou seja, praticamente instantânea mesmo com milhares de elementos.

import time

# Criar dicionário grande
grande_dict = {i: f"valor_{i}" for i in range(1000000)}

# Busca em dicionário (muito rápido)
inicio = time.time()
valor = grande_dict.get(999999)
fim = time.time()
print(f"Busca em dicionário: {(fim - inicio) * 1000:.6f}ms")

# Comparar com lista (mais lento)
grande_lista = [(i, f"valor_{i}") for i in range(1000000)]

inicio = time.time()
for item in grande_lista:
    if item[0] == 999999:
        valor = item[1]
        break
fim = time.time()
print(f"Busca em lista: {(fim - inicio) * 1000:.6f}ms")

📚 Boas Práticas com Dicionários

1. Use chaves descritivas: Prefira "nome_completo" a "nc"
2. Prefira get() ao acesso direto: Evita KeyError inesperados
3. Use valores padrão: dict.get(chave, valor_padrao)
4. Documente estruturas complexas: Dicionários aninhados podem ficar confusos
5. Valide dados: Especialmente ao receber de fontes externas
6. Use type hints: Em Python 3.5+, ajuda na manutenção do código

from typing import Dict, List, Any

def processar_usuario(dados: Dict[str, Any]) -> Dict[str, str]:
    """
    Processa dados de usuário e retorna informações formatadas.
    
    Args:
        dados: Dicionário com informações do usuário
        
    Returns:
        Dicionário com dados processados
    """
    return {
        "nome_formatado": dados.get("nome", "").title(),
        "email_validado": dados.get("email", "").lower(),
        "status": "ativo" if dados.get("ativo", False) else "inativo"
    }

🎓 Recursos Adicionais

Para aprofundar ainda mais seus conhecimentos sobre dicionários, recomendo consultar a documentação oficial do Python sobre dicionários, que contém informações detalhadas sobre implementação e otimizações.

🚀 Próximos Passos

Agora que você domina dicionários em Python, está pronto para explorar conceitos mais avançados:

• Collections module (defaultdict, Counter, OrderedDict)
• Manipulação de dados com Pandas
• APIs REST e JSON
• Bancos de dados NoSQL (MongoDB, Redis)

Quer se tornar um expert em Python e estruturas de dados? Confira nosso curso completo de Python do zero ao avançado com projetos práticos, exercícios interativos e certificado reconhecido pelo mercado!

📝 Resumo

Neste guia completo, você aprendeu:

• ✅ O que são dicionários e como criá-los
• ✅ Como acessar, adicionar e remover elementos
• ✅ Métodos essenciais: get(), keys(), values(), items()
• ✅ Dictionary comprehension para código conciso
• ✅ Dicionários aninhados para estruturas complexas
• ✅ Integração com JSON para APIs e arquivos
• ✅ Boas práticas e otimizações de performance
• ✅ Projeto prático: Sistema de cadastro de alunos

Dicionários são fundamentais em Python e aparecem em praticamente todos os projetos reais. Dominar essa estrutura de dados é essencial para se tornar um desenvolvedor Python profissional. Continue praticando e explorando as infinitas possibilidades desta ferramenta poderosa!