curso
Tutorial de compreensão de dicionário Python
Os dicionários (ou dict
em Python) são uma forma de armazenar elementos como você faria em uma lista Python. Mas, em vez de acessar os elementos usando seu índice, você atribui uma chave fixa a ele e acessa o elemento usando a chave. Agora você está lidando com um par "chave-valor", que às vezes é uma estrutura de dados mais apropriada para muitos problemas, em vez de uma simples lista. Muitas vezes, você terá de lidar com dicionários ao fazer ciência de dados, o que torna a compreensão de dicionários uma habilidade que você deve dominar.
Neste tutorial:
- Primeiro, você verá o que realmente é um dicionário Python e como você pode usá-lo de forma eficaz.
- Em seguida, você aprenderá sobre as compreensões de dicionário do Python: você verá o que é, por que é importante e como pode servir como uma alternativa aos loops for e às funções lambda.
- Você aprenderá a adicionar condicionais às compreensões de dicionário: trabalhará com condições if, várias condições if e também com declarações if-else.
- Por fim, você verá o que é a compreensão de dicionário aninhado, como você pode usá-la e como é possível reescrevê-la com loops for.
Para executar facilmente todos os exemplos de código deste tutorial, você pode criar gratuitamente uma pasta de trabalho do DataLab que tenha o Python pré-instalado e contenha todos os exemplos de código. Para praticar mais a compreensão de dicionário, confira este exercício prático do DataCamp.
Dicionário Python
Um dicionário em Python é uma coleção de itens acessados por uma chave específica em vez de por um índice. O que isso significa?
Imagine um dicionário no mundo real... quando você precisa procurar o significado de uma palavra, você tenta encontrar o significado usando a própria palavra e não o possível índice da palavra. Os dicionários Python funcionam com o mesmo conceito: a palavra cujo significado você está procurando é a chave, e o significado da palavra é o valor; você não precisa saber o índice da palavra em um dicionário para encontrar seu significado.
Inicialização de um dicionário em Python
Você pode inicializar um dicionário em Python desta forma:
a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])
fruit
print(a[0])
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-9-00d4a978143a> in <module>() ----> 1 print(a[0]) KeyError: 0
Primeiro, criamos um dicionário chamado a
que tem três pares de valores-chave: "apple" (maçã): "fruit" (fruta), "beetroot" (beterraba): "vegetable" (vegetal) e "cake" (bolo): "dessert" (sobremesa). As chaves são cadeias de caracteres que representam os nomes dos itens e os valores são cadeias de caracteres que representam o tipo ou a categoria do item.
Em seguida, adicionamos um novo par de valores-chave ao dicionário a
usando a sintaxe a['doughnut'] = 'snack'
. Isso adiciona a chave 'doughnut' ao dicionário com o valor correspondente 'snack'.
A terceira linha do código imprime o valor associado à chave 'apple' no dicionário a
. Como "apple" é uma chave no dicionário, o código imprime o valor "fruit".
A quarta linha do código tenta imprimir o valor associado à chave 0 no dicionário a
, que não é uma chave válida no dicionário. Isso resulta em um KeyError, que é gerado quando você tenta acessar uma chave que não existe em um dicionário.
Tipos de dados do dicionário Python
Os itens em um dicionário podem ter qualquer tipo de dados. Veja mais alguns exemplos de dicionário abaixo para que você possa entender melhor:
Crie um dicionário a
com quatro pares de valores-chave:
a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1}
Atualize o valor associado à chave 'one' no dicionário a para 1,0.
# Update a dictionary
a['one'] = 1.0
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}
Exclui o par chave-valor associado à chave 'um' do dicionário a.
# Delete a single element
del a['one']
print(a)
{'four': [4, 4.0], 'two': 'to', 'three': 3.0}
Remova todos os pares de valores-chave do dicionário a
usando o método clear().
# Delete all elements in the dictionary
a.clear()
print(a)
{}
Exclua o dicionário a
usando a palavra-chave del.
# Delete the dictionary
del a
print(a)
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-12-701c9d6596da> in <module>()
1 del a #Deletes the dictionary
----> 2 print(a)
NameError: name 'a' is not defined
É importante lembrar que uma chave deve ser exclusiva em um dicionário; não são permitidas duplicatas. No entanto, no caso de chaves duplicadas, em vez de apresentar um erro, o Python considerará válida a última instância da chave e simplesmente ignorará o primeiro par chave-valor. Veja você mesmo:
sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])
icecream
Compreensão do dicionário Python
A compreensão de dicionário é um método para transformar um dicionário em outro dicionário. Durante essa transformação, os itens do dicionário original podem ser incluídos condicionalmente no novo dicionário, e cada item pode ser transformado conforme necessário.
Uma boa compreensão de lista pode tornar seu código mais expressivo e, portanto, mais fácil de ler. O segredo para criar compreensões é não deixá-las tão complexas a ponto de sua cabeça girar quando você tentar decifrar o que elas realmente estão fazendo. Mantendo viva a ideia de "fácil de ler".
A maneira de compreender um dicionário em Python é poder acessar os objetos key
e os objetos value
de um dicionário.
Como isso pode ser feito?
O Python tem tudo o que você precisa! Você pode simplesmente usar os métodos internos para isso:
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()
dict_keys(['c', 'd', 'a', 'b'])
# Put all values saved in `dict1` in a list and returns the list
dict1.values()
dict_values([3, 4, 1, 2])
O código acima cria um dicionário Python chamado dict1
com quatro pares de valores-chave. O método keys() é chamado no dicionário, que retorna um objeto de visualização contendo todas as chaves do dicionário.
O método values() também é chamado no dicionário, que retorna um objeto de visualização contendo todos os valores do dicionário.
Ambos os objetos de visualização se comportam como conjuntos e podem ser usados para executar operações de conjunto nas chaves e nos valores, respectivamente.
Observe que não é garantido que a ordem das chaves e dos valores nos objetos de visualização seja a mesma ordem em que eles foram adicionados ao dicionário.
Usando o método items()
Então, agora que você sabe como acessar todas as chaves e seus valores em um dicionário. Você também pode acessar cada par chave-valor em um dicionário usando o método items()
:
dict1.items()
dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])
Esse é o modelo geral que você pode seguir para a compreensão de dicionário em Python:
dict_variable = {key:value for (key,value) in dictonary.items()}
Isso pode servir como o modelo básico e mais simples. Isso pode ficar cada vez mais complexo à medida que você adiciona condicionalidades a ele.
Exemplo básico de compreensão de dicionário Python
Vamos começar com uma simples compreensão do dicionário:
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)
{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}
No código de compreensão acima, criamos um novo dicionário double_dict1
a partir de um dicionário dict1
simplesmente duplicando cada valor nele contido.
Você também pode fazer alterações nos valores-chave. Por exemplo, vamos criar o mesmo dicionário que o anterior, mas também alterar os nomes das chaves.
dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)
{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}
Por que usar o Dictionary Comprehension?
A compreensão de dicionário é um conceito poderoso e pode ser usada para substituir os loops for
e as funções lambda
. No entanto, nem todos os loops for podem ser escritos como uma compreensão de dicionário, mas todas as compreensões de dicionário podem ser escritas com um loop for.
Considere o seguinte problema em que você deseja criar um novo dicionário em que a chave é um número divisível por 2 em um intervalo de 0 a 10, e seu valor é o quadrado do número.
Vamos ver como você pode resolver o mesmo problema usando um loop for e a compreensão de dicionário:
numbers = range(10)
new_dict_for = {}
# Add values to `new_dict` using for loop
for n in numbers:
if n%2==0:
new_dict_for[n] = n**2
print(new_dict_for)
{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}
print(new_dict_comp)
{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
Alternativa para for
loops
Os loops for são usados para repetir uma determinada operação ou um bloco de instruções em um programa por um determinado número de vezes. No entanto, os loops for aninhados (loop for dentro de outro loop for) podem ser confusos e complexos. As compreensões de dicionário são melhores em tais situações e podem simplificar a legibilidade e a compreensão do código.
Dica: confira o tutorial Loops em Python da DataCamp para obter mais informações sobre loops em Python.
Alternativa para lambda
funções
As funções lambda são uma forma de criar pequenas funções anônimas. São funções sem nome. Essas funções são funções descartáveis, que são necessárias apenas onde foram criadas. As funções lambda são usadas principalmente em combinação com as funções filter()
, map()
e reduce()
.
Vamos dar uma olhada na função lambda junto com a função map()
:
# Initialize `fahrenheit` dictionary
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}
#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))
#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))
print(celsius_dict)
{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Exemplo de compreensão de dicionário Python
Vejamos outra situação em que você deseja converter um dicionário de temperaturas Fahrenheit em celsius.
Vamos detalhar o código: primeiro, você precisa definir uma fórmula matemática que faça a conversão de Fahrenheit para Celsius.
No código, isso é feito com a ajuda da função lambda. Em seguida, você passa essa função como um argumento para a função map()
, que aplica a operação a cada item da lista fahrenheit.values()
.
Você se lembra da função values()
? Ele retorna uma lista que contém os itens armazenados no dicionário.
O que você tem agora é uma lista que contém o valor da temperatura em celsius, mas a solução exige que ela seja um dicionário.
O Python tem uma função integrada chamada zip()
que percorre os elementos dos iteradores e os agrega. Você pode ler mais sobre a função zip()
neste exemplo em Python.
Em nosso exemplo acima, a função zip agrega o item de fahrenheit.keys()
e a lista celsius
, fornecendo um par de valores-chave que você pode reunir em um dicionário usando a função dict
, que é o resultado desejado.
Agora, vamos tentar resolver o mesmo problema usando a compreensão de dicionário:
# Initialize the `fahrenheit` dictionary
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}
# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}
print(celsius_dict)
{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
Aqui está um detalhamento do que criamos no código acima:
- Crie um dicionário chamado
fahrenheit
com quatro pares de valores-chave que representam as leituras de temperatura em Fahrenheit. - Defina um novo dicionário chamado
celsius
. - Use uma compreensão de dicionário para iterar no dicionário
fahrenheit
e converter as leituras de temperatura de Fahrenheit para Celsius usando a fórmula(5/9) * (F-32)
. - Para cada par chave-valor em
fahrenheit
, a chave é atribuída à variávelk
e o valor é atribuído à variávelv
. - O valor da temperatura Celsius correspondente a cada temperatura Fahrenheit é calculado usando a fórmula acima e é adicionado como um par de valores-chave ao dicionário
celsius
. - O dicionário
celsius
resultante é impresso no console.
Como você pode ver, o problema pode ser resolvido com uma única linha de código usando a compreensão de dicionário em comparação com o processo de duas etapas e entendendo o funcionamento de três funções (lambda
, map()
e zip()
) para a primeira implementação.
Além disso, a solução é intuitiva e fácil de entender com a compreensão do dicionário. Portanto, a compreensão do dicionário pode servir como uma boa alternativa às funções lambda.
Adicionando condicionais à compreensão do dicionário
Muitas vezes você precisa adicionar condições a uma solução ao resolver problemas. Vamos explorar como você pode adicionar condicionais à compreensão de dicionário para torná-la mais eficiente.
Se a condição
Vamos supor que você precise criar um novo dicionário a partir de um determinado dicionário, mas com itens maiores que 2. Isso significa que você precisa adicionar uma condição ao modelo original que você viu acima...
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}
print(dict1_cond)
{'e': 5, 'c': 3, 'd': 4}
Isso não é tão difícil! Mas e se você tiver várias doenças?
Múltiplas condições if
No problema acima, e se você precisar não apenas obter os itens maiores que 2, mas também verificar se eles são múltiplos de 2 ao mesmo tempo?
dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)
{'d': 4}
A solução para adicionar várias condicionais é tão fácil quanto simplesmente adicionar as condições uma após a outra em sua compreensão. No entanto, você precisa ter cuidado com o que está tentando fazer no problema. Lembre-se de que as instruções if consecutivas funcionam como se tivessem cláusulas and
entre elas.
Vamos ver mais um exemplo com três condicionais:
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}
dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}
print(dict1_tripleCond)
{'f': 6}
Em um loop for, isso corresponderá a:
dict1_tripleCond = {}
for (k,v) in dict1.items():
if (v>=2 and v%2 == 0 and v%3 == 0):
dict1_tripleCond[k] = v
print(dict1_tripleCond)
{'f': 6}
Condições If-Else
Lidar com uma condição if-else também é fácil com a compreensão de dicionário. Confira o exemplo a seguir para ver você mesmo:
dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}
# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}
print(dict1_tripleCond)
{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}
Compreensão de dicionário aninhado
O aninhamento é um conceito de programação em que os dados são organizados em camadas ou em que os objetos contêm outros objetos semelhantes. Você deve ter visto com frequência uma estrutura "if" aninhada, que é uma condição if dentro de outra condição if.
Da mesma forma, os dicionários podem ser aninhados e, portanto, suas compreensões também podem ser aninhadas. Vamos ver o que isso significa:
nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)
{'first': {1.0}, 'second': {2.0}}
Este é um exemplo de um dicionário aninhado. O nested_dict
é um dicionário com as chaves: first
e second
, que contêm objetos de dicionário em seus valores. O código trabalha com os valores internos do dicionário e os converte em float e, em seguida, combina as chaves externas com os novos valores internos float em um novo dicionário.
O código também tem uma compreensão de dicionário aninhada, que é a compreensão de um dicionário dentro de outro. A compreensão do dicionário, quando aninhada, pode se tornar muito difícil de ler e de entender, o que, em primeiro lugar, tira todo o objetivo do uso de compreensões.
À medida que a estrutura do dicionário com o qual você está trabalhando se complica, a compreensão do dicionário também começa a se complicar. Nessas situações, talvez seja melhor você não usar compreensões complicadas em seu código.
Observe que você pode reescrever o trecho de código acima também com um loop for aninhado:
nested_dict = {'first':{'a':1}, 'second':{'b':2}}
for (outer_k, outer_v) in nested_dict.items():
for (inner_k, inner_v) in outer_v.items():
outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})
print(nested_dict)
{'first': {'a': 1.0}, 'second': {'b': 2.0}}
Considerações finais
Esperamos que agora você tenha aprendido sobre dicionários em Python, o conceito de compreensão e por que e onde a compreensão de dicionário em Python pode ser útil.
A prática torna seu Python melhor! Confira algumas de nossas principais dicas e truques de Python para aprimorar seu código ou faça nosso curso de habilidades em Python para dominar mais os fundamentos.
Perguntas frequentes sobre a compreensão do dicionário Python
O que é compreensão de dicionário em Python?
A compreensão de dicionário é uma maneira concisa e legível de criar dicionários em Python. Ele oferece uma maneira de criar um novo dicionário a partir de um objeto iterável, como uma lista, uma tupla ou um conjunto.
Qual é a sintaxe para a compreensão de dicionário em Python?
A sintaxe para compreensão de dicionário em Python é a seguinte: {key:value for (key,value) in iterable}
Como faço para criar um dicionário a partir de uma lista usando a compreensão de dicionário em Python?
Você pode criar um dicionário a partir de uma lista usando a compreensão de dicionário no Python, iterando sobre a lista e definindo os elementos da lista como chaves e valores no novo dicionário.
Posso usar instruções condicionais na compreensão de dicionário em Python?
Sim, você pode usar instruções condicionais na compreensão de dicionário em Python para filtrar determinados elementos.
Quais são os benefícios de usar a compreensão de dicionário no Python?
As vantagens de usar a compreensão de dicionário no Python são que ela é concisa, legível e reduz a quantidade de código necessária para criar dicionários. Ele também permite a filtragem e a transformação de elementos do dicionário em uma única linha de código.
Cursos de Python
curso
Introduction to Data Science in Python
curso
Intermediate Python
tutorial
Tutorial de funções Python
tutorial
Tutorial de lambda em Python

DataCamp Team
3 min
tutorial
Tutorial de conjuntos e teoria de conjuntos em Python

DataCamp Team
13 min
tutorial
Tutorial e exemplos de funções e métodos de lista do Python
tutorial
Tutorial do For Loops em Python
tutorial
Tutorial de Python

DataCamp Team
3 min