Métodos de dicionário: get, items, keys, values

1. Introdução aos Métodos de Dicionário em Python

Os dicionários em Python são estruturas de dados fundamentais que armazenam pares chave-valor. Para manipular esses dados de forma eficiente e segura, a linguagem oferece métodos específicos que evitam erros comuns e tornam o código mais expressivo. Os quatro métodos essenciais que todo desenvolvedor Python deve dominar são get(), items(), keys() e values().

Diferentemente do acesso direto com colchetes (dicionario[chave]), que levanta KeyError quando a chave não existe, esses métodos fornecem maneiras mais seguras e flexíveis de interagir com os dados. Além disso, eles retornam objetos de visão (dict_keys, dict_values, dict_items) que são dinâmicos e eficientes em termos de memória.

2. Método get(): Acesso Seguro a Valores

O método get() é a alternativa segura ao acesso direto com colchetes. Sua sintaxe básica é:

contatos = {
    "Alice": "alice@email.com",
    "Bruno": "bruno@email.com",
    "Carla": "carla@email.com"
}

# Acesso direto - pode gerar KeyError
email_daniel = contatos["Daniel"]  # KeyError!

# Acesso seguro com get()
email_daniel = contatos.get("Daniel")  # Retorna None
email_daniel = contatos.get("Daniel", "Contato não encontrado")  # Valor padrão personalizado

print(contatos.get("Alice", "Não encontrado"))  # alice@email.com
print(contatos.get("Daniel", "Não encontrado"))  # Não encontrado

O segundo argumento opcional define um valor padrão retornado quando a chave não existe. Isso é extremamente útil em cenários como:

# Contagem de frequência com valor padrão
texto = "python é incrível python é poderoso"
frequencia = {}

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

print(frequencia)  # {'python': 2, 'é': 2, 'incrível': 1, 'poderoso': 1}

3. Método keys(): Navegando pelas Chaves

O método keys() retorna um objeto dict_keys contendo todas as chaves do dicionário. Este objeto é uma visão dinâmica que reflete mudanças no dicionário original.

estoque = {
    "maçã": 50,
    "banana": 30,
    "laranja": 20,
    "uva": 15
}

# Obtendo todas as chaves
chaves = estoque.keys()
print(chaves)  # dict_keys(['maçã', 'banana', 'laranja', 'uva'])

# Iterando sobre as chaves
for fruta in estoque.keys():
    print(f"Temos {fruta} em estoque")

# Convertendo para lista para manipulação
lista_chaves = list(estoque.keys())
print(lista_chaves)  # ['maçã', 'banana', 'laranja', 'uva']

# A visão é dinâmica - reflete mudanças no dicionário
estoque["abacaxi"] = 10
print(chaves)  # dict_keys(['maçã', 'banana', 'laranja', 'uva', 'abacaxi'])

4. Método values(): Acessando os Valores

O método values() retorna um objeto dict_values com todos os valores do dicionário. É particularmente útil para operações que envolvem apenas os valores.

vendas = {
    "Janeiro": 15000,
    "Fevereiro": 22000,
    "Março": 18000,
    "Abril": 25000
}

# Obtendo todos os valores
valores = vendas.values()
print(valores)  # dict_values([15000, 22000, 18000, 25000])

# Somando valores numéricos
total_vendas = sum(vendas.values())
print(f"Total de vendas: R$ {total_vendas:,.2f}")

# Verificando presença de um valor
if 25000 in vendas.values():
    print("Houve vendas de R$ 25.000 em algum mês")

# Cuidado: valores duplicados podem existir
notas = {"Ana": 8.5, "Pedro": 9.0, "Maria": 8.5}
print(list(notas.values()))  # [8.5, 9.0, 8.5] - 8.5 aparece duas vezes

5. Método items(): Trabalhando com Pares Chave-Valor

O método items() retorna objetos dict_items, que são tuplas (chave, valor). É o método mais versátil para iteração completa sobre dicionários.

alunos = {
    "Ana": 8.5,
    "Pedro": 9.0,
    "Maria": 7.5,
    "João": 6.0
}

# Iteração básica com desempacotamento
for nome, nota in alunos.items():
    print(f"{nome}: {nota}")

# Filtrando dados
alunos_aprovados = {nome: nota for nome, nota in alunos.items() if nota >= 7.0}
print(alunos_aprovados)  # {'Ana': 8.5, 'Pedro': 9.0, 'Maria': 7.5}

# Criando relatórios
relatorio = []
for nome, nota in alunos.items():
    status = "Aprovado" if nota >= 7.0 else "Reprovado"
    relatorio.append(f"{nome}: {nota} - {status}")

for linha in relatorio:
    print(linha)

6. Comparação e Combinação dos Métodos

Cada método tem seu propósito específico, e combiná-los pode ser poderoso:

dados = {"a": 1, "b": 2, "c": 3, "d": 4}

# get() vs. in + colchetes
# get() é mais conciso quando você quer um valor padrão
valor = dados.get("x", 0)  # Retorna 0 se não existir

# Equivalente com in
if "x" in dados:
    valor = dados["x"]
else:
    valor = 0

# Combinando métodos para análise
def analisar_dicionario(dic):
    return {
        "chaves": list(dic.keys()),
        "valores": list(dic.values()),
        "pares": list(dic.items()),
        "total_chaves": len(dic)
    }

resultado = analisar_dicionario(dados)
print(resultado)

7. Exemplos Práticos e Boas Práticas

Exemplo 1: Sistema de Configurações

configuracoes_padrao = {
    "tema": "claro",
    "idioma": "português",
    "notificacoes": True,
    "volume": 0.8
}

def carregar_config(usuario_config):
    config_final = {}

    for chave in configuracoes_padrao.keys():
        config_final[chave] = usuario_config.get(chave, configuracoes_padrao[chave])

    return config_final

config_usuario = {"tema": "escuro", "volume": 0.5}
config_atual = carregar_config(config_usuario)
print(config_atual)
# {'tema': 'escuro', 'idioma': 'português', 'notificacoes': True, 'volume': 0.5}

Exemplo 2: Análise de Dados com items()

def processar_vendas(vendas_diarias):
    resumo = {
        "dias": list(vendas_diarias.keys()),
        "total": sum(vendas_diarias.values()),
        "media": sum(vendas_diarias.values()) / len(vendas_diarias),
        "melhor_dia": max(vendas_diarias.items(), key=lambda x: x[1])
    }
    return resumo

vendas = {
    "segunda": 5000,
    "terça": 7500,
    "quarta": 6200,
    "quinta": 8900,
    "sexta": 10300
}

resultado = processar_vendas(vendas)
print(f"Total: R$ {resultado['total']:,.2f}")
print(f"Média: R$ {resultado['media']:,.2f}")
print(f"Melhor dia: {resultado['melhor_dia'][0]} com R$ {resultado['melhor_dia'][1]:,.2f}")

Boas Práticas

# ✅ Prefira get() para acesso seguro
valor = dados.get("chave", 0)

# ✅ Use items() para iteração completa
for k, v in dados.items():
    processar(k, v)

# ✅ Converta views apenas quando necessário
chaves_lista = list(dados.keys())

# ❌ Evite criar listas desnecessárias
for chave in list(dados.keys()):  # Cria lista desnecessária
    pass

# ✅ Prefira iteração direta
for chave in dados:  # Equivalente e mais eficiente
    pass

Dominar esses quatro métodos torna o código Python mais idiomático, seguro e eficiente. Eles são ferramentas essenciais no dia a dia de qualquer desenvolvedor que trabalhe com dicionários.

Referências