Dicionários: Pares Chave-Valor 🔑

Bem-vindo à aula sobre Dicionários, uma das estruturas de dados mais versáteis e poderosas do Python! Prepare-se para desvendar como organizar informações de forma intuitiva, usando pares de "chave" e "valor".

1. Introdução: O Que São Dicionários? 🤔

Imagine que você tem uma agenda de contatos. Para cada pessoa, você tem um nome (a "chave") e um número de telefone (o "valor"). Ou pense em um dicionário de verdade: para cada palavra (a "chave"), existe uma definição (o "valor").

Em Python, um dicionário é exatamente isso: uma coleção não ordenada de pares de chave-valor.

• Chave (Key): Deve ser um tipo de dado imutável (como strings, números, tuplas). É única dentro do dicionário.
• Valor (Value): Pode ser qualquer tipo de dado em Python (números, strings, listas, outros dicionários, etc.).

Dicionários são extremamente úteis quando você precisa associar informações de forma lógica e acessá-las rapidamente usando um identificador significativo (a chave), em vez de um índice numérico (como em listas).

Por que usar Dicionários?

• Acesso Rápido: Encontrar um valor por sua chave é muito eficiente.
• Clareza: O código se torna mais legível ao usar chaves descritivas.
• Flexibilidade: Os valores podem ser de qualquer tipo, permitindo armazenar estruturas de dados complexas.

2. Explicação Detalhada com Exemplos 🧑‍🏫

Vamos mergulhar nos detalhes de como criar, manipular e interagir com dicionários.

2.1. Criando Dicionários 🛠️

Dicionários são criados usando chaves {} e separando os pares chave-valor por dois pontos : e cada par por vírgulas ,.

Dicionário Vazio

Você pode iniciar um dicionário sem nenhum par chave-valor:

# Criando um dicionário vazio
dicionario_vazio = {}
print(f"Dicionário vazio: {dicionario_vazio}")
print(f"Tipo: {type(dicionario_vazio)}")

Dicionário com Pares Chave-Valor Iniciais

Você pode preenchê-lo com dados desde o início:

# Dicionário de informações de um aluno
aluno = {
    "nome": "Ana Silva",
    "idade": 20,
    "curso": "Engenharia de Software",
    "matricula": "2023001"
}
print(f"Informações do aluno: {aluno}")
 
# Dicionário de preços de frutas
precos_frutas = {
    "maçã": 2.50,
    "banana": 1.80,
    "laranja": 3.00
}
print(f"Preços das frutas: {precos_frutas}")

2.2. Acessando Valores 🔍

Para acessar o valor associado a uma chave, você usa a notação de colchetes [] com a chave dentro.

aluno = {
    "nome": "Ana Silva",
    "idade": 20,
    "curso": "Engenharia de Software",
    "matricula": "2023001"
}
 
# Acessando o nome do aluno
nome_aluno = aluno["nome"]
print(f"Nome do aluno: {nome_aluno}")
 
# Acessando a idade
idade_aluno = aluno["idade"]
print(f"Idade do aluno: {idade_aluno}")

Lidando com Chaves Inexistentes: KeyError 🚨

Se você tentar acessar uma chave que não existe, o Python levantará um erro KeyError.

aluno = {
    "nome": "Ana Silva",
    "idade": 20,
    "curso": "Engenharia de Software"
}
 
# Isso causaria um KeyError se 'telefone' não existisse
# print(aluno["telefone"]) # Descomente para ver o erro

Para evitar isso, você pode usar o método .get():

# Usando .get() para acessar valores
telefone_aluno = aluno.get("telefone")
print(f"Telefone do aluno (usando .get()): {telefone_aluno}") # Saída: None
 
# Você pode fornecer um valor padrão se a chave não for encontrada
email_aluno = aluno.get("email", "Não informado")
print(f"Email do aluno (com valor padrão): {email_aluno}") # Saída: Não informado
 
curso_aluno = aluno.get("curso", "Curso desconhecido")
print(f"Curso do aluno (chave existente): {curso_aluno}") # Saída: Engenharia de Software

2.3. Adicionando e Modificando Elementos ➕✍️

Dicionários são mutáveis, o que significa que você pode adicionar novos pares chave-valor ou modificar valores existentes.

Adicionando um Novo Par Chave-Valor

Basta atribuir um valor a uma nova chave:

aluno = {
    "nome": "Ana Silva",
    "idade": 20,
    "curso": "Engenharia de Software"
}
 
# Adicionando um novo campo
aluno["cidade"] = "São Paulo"
print(f"Aluno com cidade adicionada: {aluno}")

Modificando um Valor Existente

Atribua um novo valor a uma chave já existente:

# Modificando a idade do aluno
aluno["idade"] = 21
print(f"Aluno com idade atualizada: {aluno}")
 
# Modificando o curso
aluno["curso"] = "Ciência da Computação"
print(f"Aluno com curso atualizado: {aluno}")

2.4. Removendo Elementos ➖

Existem várias maneiras de remover pares chave-valor de um dicionário.

Usando del

O operador del remove um par chave-valor específico. Se a chave não existir, ele causará um KeyError.

aluno = {
    "nome": "Ana Silva",
    "idade": 21,
    "curso": "Ciência da Computação",
    "cidade": "São Paulo"
}
 
del aluno["cidade"]
print(f"Aluno após remover 'cidade' com del: {aluno}")
 
# del aluno["telefone"] # Descomente para ver o KeyError

Usando .pop()

O método .pop() remove o item com a chave especificada e retorna o valor desse item. Você pode fornecer um valor padrão para retornar se a chave não for encontrada, evitando um KeyError.

aluno = {
    "nome": "Ana Silva",
    "idade": 21,
    "curso": "Ciência da Computação",
    "matricula": "2023001"
}
 
matricula_removida = aluno.pop("matricula")
print(f"Matrícula removida: {matricula_removida}")
print(f"Aluno após remover 'matricula' com pop(): {aluno}")
 
# Tentando remover uma chave inexistente com valor padrão
telefone_removido = aluno.pop("telefone", "Chave 'telefone' não encontrada")
print(f"Tentativa de remover 'telefone': {telefone_removido}")
print(f"Aluno: {aluno}")

Usando .popitem()

O método .popitem() remove e retorna um par chave-valor arbitrário (geralmente o último par inserido em versões recentes do Python). É útil para processar itens em um loop sem se preocupar com a chave.

aluno = {
    "nome": "Ana Silva",
    "idade": 21,
    "curso": "Ciência da Computação"
}
 
item_removido = aluno.popitem()
print(f"Item removido com popitem(): {item_removido}") # Ex: ('curso', 'Ciência da Computação')
print(f"Aluno após popitem(): {aluno}")

Usando .clear()

O método .clear() remove todos os itens de um dicionário, deixando-o vazio.

aluno = {
    "nome": "Ana Silva",
    "idade": 21,
    "curso": "Ciência da Computação"
}
 
aluno.clear()
print(f"Aluno após clear(): {aluno}")

2.5. Iterando Sobre Dicionários 🔄

Você pode iterar sobre dicionários de várias maneiras, dependendo do que você precisa acessar: chaves, valores ou ambos.

cidades_populacao = {
    "São Paulo": 12_000_000,
    "Rio de Janeiro": 6_700_000,
    "Belo Horizonte": 2_500_000,
    "Salvador": 2_900_000
}
 
print("--- Iterando sobre as chaves (padrão) ---")
for cidade in cidades_populacao: # ou for cidade in cidades_populacao.keys():
    print(f"Cidade: {cidade}")
 
print("\n--- Iterando sobre os valores ---")
for populacao in cidades_populacao.values():
    print(f"População: {populacao:,}") # Formatação para milhares
 
print("\n--- Iterando sobre os itens (chave e valor) ---")
for cidade, populacao in cidades_populacao.items():
    print(f"A população de {cidade} é de {populacao:,} habitantes.")

2.6. Métodos Comuns de Dicionários 📚

Além dos métodos .get(), .pop(), .popitem() e .clear() que já vimos, outros métodos importantes são:

• .keys(): Retorna uma "view" dos objetos de chave do dicionário.
• .values(): Retorna uma "view" dos objetos de valor do dicionário.
• .items(): Retorna uma "view" dos pares chave-valor do dicionário como tuplas.
• .update(): Atualiza o dicionário com pares chave-valor de outro dicionário ou de um iterável de pares chave-valor.
• .copy(): Retorna uma cópia rasa do dicionário.

configuracoes_padrao = {
    "tema": "escuro",
    "idioma": "pt-br",
    "notificacoes": True
}
 
configuracoes_usuario = {
    "idioma": "en-us",
    "fonte_tamanho": 14
}
 
# .keys(), .values(), .items() já foram demonstrados na iteração.
 
# Usando .update()
# Adiciona novos pares ou atualiza existentes
configuracoes_padrao.update(configuracoes_usuario)
print(f"\nConfigurações atualizadas: {configuracoes_padrao}")
 
# Usando .copy()
# Cria uma cópia independente do dicionário
copia_configuracoes = configuracoes_padrao.copy()
copia_configuracoes["tema"] = "claro"
print(f"Cópia das configurações (tema claro): {copia_configuracoes}")
print(f"Configurações originais (inalteradas): {configuracoes_padrao}")

3. Código de Exemplo Oficial (Adaptado) 🐍

A documentação oficial do Python (disponível em docs.python.org/pt-br/3/tutorial/datastructures.html#dictionaries) ilustra o uso de dicionários de forma concisa. Vamos adaptar um exemplo para reforçar o que aprendemos.

# Exemplo inspirado na documentação oficial
tel = {'jack': 4098, 'sape': 4139}
print(f"Dicionário inicial: {tel}")
 
# Adicionando um novo par
tel['guido'] = 4127
print(f"Após adicionar 'guido': {tel}")
 
# Acessando um valor
print(f"Número de jack: {tel['jack']}")
 
# Removendo um par
del tel['sape']
print(f"Após remover 'sape': {tel}")
 
# Adicionando outro par
tel['irv'] = 4127
print(f"Após adicionar 'irv': {tel}")
 
# Verificando se uma chave existe
print(f"A chave 'guido' está em tel? {'guido' in tel}")
print(f"A chave 'jack' não está em tel? {'jack' not in tel}")
 
# Iterando sobre os itens
print("\nNúmeros de telefone:")
for nome, numero in tel.items():
    print(f"{nome}: {numero}")

4. Resumo e Próximos Passos 🚀

Nesta aula, você aprendeu sobre os Dicionários em Python, uma estrutura de dados fundamental para organizar informações como pares chave-valor.

Pontos Chave:

• Dicionários são coleções não ordenadas de pares chave: valor.
• As chaves devem ser imutáveis e únicas.
• Os valores podem ser de qualquer tipo.
• Você pode criar dicionários vazios ou com dados iniciais usando {}.
• Acessar valores é feito com dicionario[chave] ou de forma segura com dicionario.get(chave, valor_padrao).
• Adicionar ou modificar elementos é feito por atribuição: dicionario[chave] = valor.
• Remover elementos pode ser feito com del dicionario[chave], dicionario.pop(chave) ou dicionario.popitem().
• Você pode iterar sobre chaves, valores ou itens (pares chave-valor) usando .keys(), .values(), e .items(), respectivamente.

Dominar dicionários é crucial para escrever código Python eficiente e legível, especialmente ao lidar com dados estruturados, como configurações, registros de banco de dados ou respostas de APIs.

Próximos Passos:

No próximo módulo, exploraremos outras estruturas de dados importantes, como os Conjuntos (Sets), que oferecem uma maneira eficiente de lidar com coleções de itens únicos. Fique ligado!