10 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Se você já se perguntou “o que é um dicionário em Python e quando usar?”, saiba que esse é um dos conceitos mais importantes para quem está começando a trabalhar com dados.
Ao desenvolver aplicações, é comum precisarmos organizar informações de forma que façam sentido. Pense, que você precisa criar uma agenda de contatos telefônicos em Python.
Uma primeira ideia pode ser usar uma lista para armazenar os números:
telefones = ['1234-5678', '9999-9999', '8765-4321', '8877-7788']Essa estrutura armazena os números, mas não indica a quem cada número pertence. Por exemplo, não é possível saber facilmente de quem é o número na segunda posição.
Para resolver isso, precisamos conectar os nomes às informações dos contatos. Para essa associação, uma possibilidade é utilizar uma a tupla:
contato = ('Yan', '1234-5678') Para não precisarmos de uma variável para cada contato, podemos colocá-los direto em uma lista de contatos:
contatos_lista = [('Yan', '1234-5678'), ('Pedro', '9999-9999'),
('Ana', '8765-4321'), ('Marina', '8877-7788')]Por exemplo, se quisermos acessar o número de telefone da pessoa de nome Marina, podemos fazer:
print(contatos_lista[3][1]) E o resultado:
8877-7788 Conseguimos! Agora, o número do Pedro: … Mas espera, qual é mesmo a posição do Pedro na nossa lista de contatos?
Dessa forma, a utilidade de manter os nomes armazenados é limitada, já que só se pode acessar o contato pela posição na lista. Existe uma maneira mais eficiente de estruturar esses dados?
Até agora temos uma lista de contatos em que, ao menos, cada contato tem seu nome e telefone conectados. Entretanto, por enquanto, só conseguimos acessar um contato individualmente pela sua posição na lista, e não pelo seu próprio nome.
O ideal seria mapear o nome de cada contato com seu telefone, evitando outros problemas.
Por exemplo, podemos associar o contato Yan ao número 1234-5678. Dessa forma, quando quisermos consultar o telefone de Yan, basta utilizar o seu nome como referência. Assim, não precisamos lembrar a posição do dado em uma lista, apenas a informação que faz sentido no contexto: o nome do contato.
Nesse caso, utilizamos uma estrutura semelhante a um dicionário de idiomas: há uma chave (por exemplo, o nome do contato) e um valor correspondente (número de telefone).
Quando achamos essa palavra, podemos ver o seu significado, isto é, o valor daquela palavra na língua, que no nosso caso, é o número de telefone.
Esse tipo de estrutura é muito utilizado em diversas linguagens de programação (mas normalmente tem outro nome, como array associativo. Com ela, conseguimos ter um comportamento parecido com o de dicionários.
No Python, dicionários são criados utilizando chaves ({}). Por exemplo, podemos definir que a chave 'Yan' tem como valor o telefone '1234-5678':
contatos = {'Yan': '1234-5678'}
print(type(contatos))E olha o tipo da variável contatos que acabamos de criar:
<class 'dict'> O tipo retornado é 'dict', que corresponde a um dicionário. Não é necessário redigitar todos os dados já existentes em uma lista de tuplas; é possível criar um dicionário diretamente usando a função construtora dict(), passando uma lista de tuplas como parâmetro:
contatos_lista = [('Yan', '1234-5678'), ('Pedro', '9999-9999'),
('Ana', '8765-4321'), ('Marina', '8877-7788')]
contatos = dict(contatos_lista)
print(contatos)E agora:
{'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'Marina': '8877-7788'}Com a estrutura montada, surge a dúvida: como acessar os itens de um dicionário, mesmo sem uma ordem definida?
Os valores do dicionário podem ser acessados de maneira semelhante ao acesso por índice em listas, mas aqui utilizamos as chaves definidas, em vez de índices numéricos:
print(contatos['Ana']) E o resultado:
8765-4321 No entanto, se tentarmos buscar uma chave que não existe, como 'João', o resultado será diferente:
print(contatos['João']) Olha o que aparece na tela:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'João'Esse erro ocorre porque a chave 'João' não está presente no dicionário, resultando em uma exceção do tipo KeyError. Exibir essa mensagem diretamente ao usuário pode ser confuso; portanto, é interessante buscar alternativas de tratamento
Os dicionários possuem um método específico para busca de valores, o get(), no qual podemos passar como parâmetros a chave que queremos e um valor padrão para retornar caso essa chave não seja encontrada:
print(contatos.get('Yan', 'Contato não encontrado'))
print(contatos.get('João', 'Contato não encontrado'))E o resultado:
1234-5678 Contato não encontrado
Muito melhor agora!
Também podemos verificar se um contato está em nosso dicionário através da palavra chave in:
print('Yan' in contatos) E a resposta:
True Como esperado!
Também podemos verificar se um número de telefone está armazenado no dicionário, utilizando o operador in:
print('9999-9999' in contatos) Dessa vez, olha o resultado:
False Ué! Mas esse número está sim na agenda, é o número do Pedro! Por que será que o resultado foi False, então?
O motivo é que o operador in, quando aplicado diretamente ao dicionário, verifica apenas a existência de chaves. Para buscar nos valores, utilizamos o método values():
print('9999-9999' in contatos.values()) E a resposta:
True Agora sim! Temos nossa estrutura de mapeamento e já conseguimos visualizar os dados dela. Mas e agora, o que mais conseguimos fazer?
Mas como realizar essa inclusão usando o dicionário de contatos? Caso tente-se utilizar um método append(), semelhante ao de listas, ocorre o seguinte:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'append'Outra tentativa seria somar dois dicionários diretamente, mas isso também não é permitido no Python:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'Para adicionar um novo item ao dicionário, basta atribuir o valor desejado a uma nova chave. Por exemplo, para inserir o telefone de 'João':
contatos['João'] = '8887-7778'
print(contatos)Agora olha como está o dicionário:
{'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'Marina': '8877-7788', 'João': '8887-7778'}Deu certo!
Caso seja necessário remover um contato do dicionário, por exemplo, se um número não pertence mais a determinada pessoa, é possível excluir a entrada correspondente. Veja como:
Uma maneira simples é usando o statement del, dessa forma:
del contatos['Marina']
print(contatos)E agora, nosso dicionário:
{'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'João': '8887-7778'}Certo! Mas e se tentarmos remover um item que não existe?
del contatos['Catarina'] Olha o que acontece:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Catarina'Assim como na busca de chaves não existentes, tentar remover um item ausente com 'del' gera um KeyError. Para evitar essa exceção, pode-se usar o método 'pop()' do dicionário..
O método pop(), além de remover o elemento com a chave especificada do dicionário, nos retorna o valor desse elemento. Também podemos definir um valor padrão de retorno, para caso a chave não seja encontrada:
contatos = {'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'Marina': '8877-7788', 'João': '8887-7778'}
print(contatos.pop('Marina', 'Contato não encontrado'))
print(contatos.pop('Catarina', 'Contato não encontrado'))
print()
print(contatos)E o resultado:
8877-7788 Contato não encontrado
{'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'João': '8887-7778'}Tudo certo, agora! Uma pena que tenho poucos contatos na agenda...
Suponha que outra pessoa envie uma lista de contatos em formato de dicionário. Como juntar os dados dos dois dicionários?
contatos_do_pedro = {'Yan': '1234-5678', 'Fernando':'4345-5434',
'Luiza':'4567-7654'}Como adicionamos todos esses contatos acima em minha agenda? Podemos tentar fazer um loop passando pelos contatos do Pedro e os adicionando um a um:
meus_contatos = {'Yan': '1234-5678', 'Pedro': '9999-9999',
'Ana': '8765-4321', 'João': '8887-7778'}
contatos_do_pedro = {'Yan': '1234-5678', 'Fernando': '4345-5434',
'Luiza': '4567-7654'}
for nome in contatos_do_pedro:
meus_contatos[nome] = contatos_do_pedro[nome]
print(meus_contatos)Agora vamos ver meu dicionário:
{'Yan': '1234-5678', 'Pedro': '9999-9999', 'Ana': '8765-4321',
'João': '8887-7778', 'Fernando': '4345-5434', 'Luiza': '4567-7654'}O resultado é correto, mas existe uma forma ainda mais prática, dispensando o uso do laço 'for'.
Para juntar os dois dicionários, é possível utilizar o método 'update()', que adiciona as chaves e valores do segundo dicionário ao primeiro, substituindo o loop anterior.
meus_contatos.update(contatos_pedro)
print(meus_contatos)E o resultado continua certo, com um código mais sucinto!
Ao tentar utilizar os números armazenados, pode surgir a necessidade de atualizar todos para obedecer a um novo padrão, como acrescentar um prefixo.
Atualmente, os números de celular exigem o prefixo 9, surge a dúvida sobre a necessidade de aplicar o método update() em todos os registros. Tal prática, contudo, parece ser contraproducente!
O ideal seria ter uma lógica mais objetiva, que simplesmente copiasse todo o dicionário de contatos, mas adicionasse um 9 a cada valor. A princípio, uma ideia é fazer um laço de repetição, como um for, o que deve funcionar, mas será que não tem forma mais simples?
Uma alternativa mais elegante ao uso de 'for' é a compreensão de dicionários (dict comprehension), cuja sintaxe é semelhante à da compreensão de listas:
meus_contatos_novo = {nome: '9' + meus_contatos[nome] for nome in meus_contatos}
print(meus_contatos_novo)E o resultado:
{'Yan': '91234-5678', 'Pedro': '99999-9999', 'Ana': '98765-4321',
'João': '98887-7778', 'Fernando': '94345-5434', 'Luiza': '94567-7654'}Conseguimos! Agora já conseguimos manipular bem nossa agenda!
Durante os exemplos, é possível perceber que alterações no dicionário (adições, remoções ou atualizações) são feitas diretamente na mesma estrutura, sem criar um novo objeto.
Isso se dá porque os dicionários, assim como as listas, são mutáveis. É importante ter noção disso, para não nos atrapalharmos nas possíveis complicações que a diferença de mutabilidade implica nos objetos no Python.
Usamos o método values() para verificar se o dicionário tinha um valor específico, mas não chegamos a ver o que ele retorna. Vamos testar:
valores = meus_contatos_novo.values()
print(valores)Aqui chegamos em um ponto interessante. Ao rodarmos esse código no Python:
dict_values(['91234-5678', '99999-9999', '98765-4321',
'98887-7778', '94345-5434', '94567-7654'])O resultado monstra o tipo dict_values. O que é isso?
Esse método é o que chamamos de view de dicionário, que nada mais é que uma janela para os valores do dicionário. Views geralmente são vantajosos, comparados às listas, justamente porque são apenas uma abertura, não uma estrutura em si.
valores = meus_contatos_novo.values()
print(valores)
meus_contatos_novo['Yan'] = '91122-3344'
print(valores)dict_values(['911122-3344', '99999-9999', '98765-4321',
'98887-7778', '94345-5434', '94567-7654'])A variável valores atualizou junto! Além dessa vantagem, também economizamos memória com as views, já que elas sempre ocupam o mesmo espaço, como uma janela:
print(valores.__sizeof__()) O resultado é:
24 Embora tuplas e listas auxiliem na organização de dados, situações que exigem mapeamento direto entre chaves e valores são melhor resolvidas por dicionários.
Para essa necessidade, no Python temos o tipo dicionário, que é mutável e nos provê diversos métodos para facilitar o manipulamento dos dados nessa estrutura.
Se você chegou até aqui, já deu um passo importante para entender como os dicionários funcionam no Python, uma das estruturas mais poderosas e utilizadas no dia a dia de quem trabalha com dados e desenvolvimento.
Mas isso é só o começo da jornada.
Que tal aprofundar ainda mais seus conhecimentos e aprender a aplicar Python em projetos reais, desde a manipulação de dados até a criação de aplicações completas?
Na Alura, você encontra trilhas completas que vão te guiar do básico ao avançado, com prática, desafios e projetos que realmente te preparam para o mercado com a jornada guiada do básico ao avançado de Python para Data Science ou desenvolvimento web com Django.
Invista no seu aprendizado e transforme conhecimento em oportunidade. Bora codar!
Avalie este artigo
