Introdução
Em Python, um dicionário (dictionary) é uma coleção ordenada (desde Python 3.7) de pares chave: valor. Dicionários são usados para armazenar valores de dados de uma maneira que é mutável, indexada e não permite chaves duplicadas. As principais operações em um dicionário são armazenar um valor com uma chave e extrair o valor dada a chave.
Por exemplo, você pode criar um dicionário para armazenar informações sobre um gato:
## Dictionary: collection of key-value pairs
my_cat = {
'size': 'fat', ## key: 'size', value: 'fat'
'color': 'gray', ## key: 'color', value: 'gray'
'disposition': 'loud' ## key: 'disposition', value: 'loud'
}
Neste laboratório (lab), você aprenderá a criar dicionários, acessar e modificar seus dados, iterar sobre eles e usar vários métodos utilitários para trabalhar com eles de forma eficaz.
Acessando e Modificando Dados do Dicionário
Nesta etapa, você aprenderá como criar um dicionário, adicionar novos pares chave-valor, atualizar os existentes e recuperar valores usando o operador de subscrito [].
Você pode adicionar ou atualizar uma entrada de dicionário atribuindo um valor a uma chave usando o operador []. Se a chave já existir, seu valor é atualizado. Se a chave não existir, um novo par chave-valor é adicionado.
Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.
Vamos começar criando um arquivo para escrever nosso código.
Primeiro, abra o arquivo main.py localizado no diretório ~/project no explorador de arquivos à esquerda.
Agora, adicione o seguinte código ao main.py. Este código define um dicionário e, em seguida, adiciona um novo par chave-valor a ele.
## Add or update dictionary entry using subscript operator
my_cat = {
'size': 'fat',
'color': 'gray',
'disposition': 'loud',
}
my_cat['age_years'] = 2 ## Add new key-value pair
print(my_cat)
Para executar o script, abra um terminal e execute o seguinte comando:
python3 main.py
Você deverá ver o dicionário atualizado impresso no console:
{'size': 'fat', 'color': 'gray', 'disposition': 'loud', 'age_years': 2}
Você também pode recuperar um valor usando a chave dentro do operador de subscrito []. Vamos modificar o arquivo main.py para acessar e imprimir o valor associado à chave 'size'.
Substitua o conteúdo de main.py pelo seguinte código:
my_cat = {
'size': 'fat',
'color': 'gray',
'disposition': 'loud',
}
print(my_cat['size'])
Execute o script novamente:
python3 main.py
A saída será o valor da chave 'size':
fat
Esteja ciente de que se você tentar acessar uma chave que não está no dicionário, o Python levantará um KeyError. Vamos ver isso em ação. Substitua o código em main.py por este:
my_cat = {
'size': 'fat',
'color': 'gray',
'disposition': 'loud',
}
print(my_cat['eye_color'])
Execute o script:
python3 main.py
Isso resultará em um KeyError porque a chave 'eye_color' não existe no dicionário my_cat.
Traceback (most recent call last):
File "/home/labex/project/main.py", line 5, in <module>
print(my_cat['eye_color'])
KeyError: 'eye_color'
Para a verificação, por favor, reverta main.py para o primeiro exemplo que adiciona uma nova chave e imprime o dicionário inteiro.
## Add or update dictionary entry using subscript operator
my_cat = {
'size': 'fat',
'color': 'gray',
'disposition': 'loud',
}
my_cat['age_years'] = 2 ## Add new key-value pair
print(my_cat)
Iterando Sobre Dicionários
Nesta etapa, você explorará diferentes maneiras de percorrer um dicionário. Python fornece vários métodos para iterar sobre as chaves, valores ou ambos de um dicionário.
Iterando Sobre Valores com values()
O método values() retorna um objeto de visualização (view object) que exibe uma lista de todos os valores no dicionário. Você pode percorrer este objeto para acessar cada valor.
Limpe o arquivo main.py e adicione o seguinte código:
## Iterate over dictionary values using .values() method
pet = {'color': 'red', 'age': 42}
for value in pet.values(): ## Loop through all values
print(value)
Execute o script:
python3 main.py
A saída mostrará cada valor em uma nova linha:
red
42
Iterando Sobre Chaves com keys()
Similarmente, o método keys() retorna um objeto de visualização contendo as chaves do dicionário. Embora você possa usar pet.keys(), iterar diretamente sobre o dicionário em si é a maneira mais comum e "Pythonica" de percorrer suas chaves.
Atualize o main.py com o seguinte código:
## Iterating over dictionary directly loops through keys (default behavior)
pet = {'color': 'red', 'age': 42}
for key in pet: ## Equivalent to for key in pet.keys()
print(key)
Execute o script:
python3 main.py
Você verá as chaves impressas:
color
age
Iterando Sobre Pares Chave-Valor com items()
O método items() é muito útil quando você precisa tanto da chave quanto do valor durante a iteração. Ele retorna um objeto de visualização onde cada item é uma tupla (chave, valor).
Atualize o main.py para usar items():
## Iterate over key-value pairs using .items() method
pet = {'color': 'red', 'age': 42}
for key, value in pet.items(): ## Unpack tuple into key and value
print(f'Key: {key} Value: {value}')
Aqui, estamos usando desempacotamento de tuplas (for key, value in ...) para atribuir o primeiro elemento da tupla a key e o segundo a value em cada iteração.
Execute o script:
python3 main.py
A saída será strings formatadas mostrando cada par chave-valor:
Key: color Value: red
Key: age Value: 42
Acesso Seguro e Adição de Itens
Nesta etapa, você aprenderá como recuperar valores com segurança sem causar um KeyError e como adicionar itens condicionalmente.
Acesso Seguro com get()
Como você viu na Etapa 1, tentar acessar uma chave inexistente com [] levanta um KeyError. O método get() fornece uma maneira mais segura de acessar chaves. Ele retorna o valor de uma chave se ela existir, mas se não existir, retorna None em vez de levantar um erro.
Limpe o main.py e adicione o seguinte código:
## .get() method: safely retrieve value, returns None if key doesn't exist
wife = {'name': 'Rose', 'age': 33}
print(f'My wife name is {wife.get("name")}')
print(f'She is deeply in love with {wife.get("husband")}')
Execute o script:
python3 main.py
A saída mostra que get() retornou o valor para 'name' e None para a chave ausente 'husband':
My wife name is Rose
She is deeply in love with None
Você também pode fornecer um valor padrão para get() como um segundo argumento. Este valor será retornado se a chave não for encontrada.
Modifique o main.py para fornecer um valor padrão:
wife = {'name': 'Rose', 'age': 33}
print(f'She is deeply in love with {wife.get("husband", "lover")}')
Execute novamente:
python3 main.py
Agora a saída usa seu valor padrão personalizado:
She is deeply in love with lover
Adição Condicional com setdefault()
O método setdefault() oferece uma maneira concisa de adicionar um par chave-valor somente se a chave ainda não existir. Ele verifica a chave; se estiver presente, retorna o valor da chave. Se não estiver, ele insere a chave com o valor especificado e retorna esse valor.
Atualize o main.py para usar setdefault():
wife = {'name': 'Rose', 'age': 33}
wife.setdefault('has_hair', True) ## 'has_hair' does not exist, so it's added.
wife.setdefault('name', 'Lily') ## 'name' exists, so the dictionary is not changed.
print(wife)
Execute o script:
python3 main.py
A saída mostra que 'has_hair' foi adicionado, mas o valor de 'name' não foi alterado:
{'name': 'Rose', 'age': 33, 'has_hair': True}
Removendo Itens de um Dicionário
Nesta etapa, você praticará vários métodos para remover itens de um dicionário.
Removendo com pop()
O método pop() remove um item com a chave especificada e retorna seu valor. Se a chave não for encontrada, ele levanta um KeyError, a menos que um valor padrão seja fornecido.
Limpe o main.py e adicione o seguinte código para ver o pop() em ação:
wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_value = wife.pop('age')
print(f"Removed value: {removed_value}")
print(wife)
Execute o script:
python3 main.py
A saída mostra o valor removido e o dicionário após a remoção:
Removed value: 33
{'name': 'Rose', 'hair': 'brown'}
Removendo com popitem()
O método popitem() remove o último item inserido em um dicionário (em Python 3.7+). Ele retorna o item removido como uma tupla (chave, valor).
Modifique o main.py para usar popitem():
wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
removed_item = wife.popitem()
print(f"Removed item: {removed_item}")
print(wife)
Execute o script:
python3 main.py
O último item, ('hair', 'brown'), é removido e impresso:
Removed item: ('hair', 'brown')
{'name': 'Rose', 'age': 33}
Removendo com a Palavra-chave del
A palavra-chave del pode ser usada para remover um item por sua chave. Ela não retorna o valor do item removido.
Modifique o main.py para usar del:
wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
del wife['age']
print(wife)
Execute o script:
python3 main.py
O dicionário é impresso sem a chave 'age':
{'name': 'Rose', 'hair': 'brown'}
Removendo Todos os Itens com clear()
O método clear() remove todos os itens de um dicionário, deixando-o vazio.
Modifique o main.py para usar clear():
wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.clear()
print(wife)
Execute o script:
python3 main.py
A saída é um dicionário vazio:
{}
Para a verificação, certifique-se de que seu main.py usa pop() para remover a chave 'age' e imprime o dicionário final.
wife = {'name': 'Rose', 'age': 33, 'hair': 'brown'}
wife.pop('age')
print(wife)
Operações de Utilidade de Dicionário
Nesta etapa, você descobrirá algumas utilidades úteis de dicionário, incluindo a verificação da existência de chaves e valores, impressão formatada (pretty-printing) e mesclagem de dicionários.
Verificando Chaves e Valores com in
Você pode usar o operador in para verificar se uma chave existe em um dicionário.
Limpe o main.py e adicione este código:
person = {'name': 'Rose', 'age': 33}
print(f"'name' in person: {'name' in person}")
print(f"'height' in person: {'height' in person}")
Execute o script:
python3 main.py
A saída mostra True para uma chave existente e False para uma inexistente:
'name' in person: True
'height' in person: False
Você também pode usar in com o método values() para verificar se um valor existe no dicionário.
Modifique o main.py:
person = {'name': 'Rose', 'age': 33}
print(f"'Rose' in person.values(): {'Rose' in person.values()}")
print(f"33 in person.values(): {33 in person.values()}")
print(f"'John' in person.values(): {'John' in person.values()}")
Execute:
python3 main.py
Saída:
'Rose' in person.values(): True
33 in person.values(): True
'John' in person.values(): False
Impressão Formatada (Pretty Printing) com pprint
Quando os dicionários são grandes, imprimi-los diretamente pode resultar em uma linha longa e de difícil leitura. O módulo pprint fornece uma capacidade de "impressão bonita" (pretty-print) para formatá-los de maneira mais legível.
Atualize o main.py:
import pprint
wife = {'name': 'Rose', 'age': 33, 'has_hair': True, 'hair_color': 'brown', 'height': 1.6, 'eye_color': 'brown'}
pprint.pprint(wife)
Execute o script:
python3 main.py
A saída é formatada de forma organizada, com as chaves ordenadas alfabeticamente:
{'age': 33,
'eye_color': 'brown',
'hair_color': 'brown',
'has_hair': True,
'height': 1.6,
'name': 'Rose'}
Mesclando Dicionários
Você pode mesclar dois dicionários usando o operador de desempacotamento de dicionário ** (disponível no Python 3.5+). Se houver chaves sobrepostas, o valor do segundo dicionário será usado.
Atualize o main.py com o seguinte código:
dict_a = {'a': 1, 'b': 2}
dict_b = {'b': 3, 'c': 4}
dict_c = {**dict_a, **dict_b}
print(dict_c)
Execute o script:
python3 main.py
A saída é um novo dicionário contendo todos os itens de ambos. Note que o valor para a chave 'b' é 3, que vem de dict_b.
{'a': 1, 'b': 3, 'c': 4}
Resumo
Parabéns por completar este laboratório sobre dicionários Python!
Neste laboratório, você aprendeu as operações fundamentais para trabalhar com uma das estruturas de dados mais poderosas do Python. Você cobriu:
- Criação, Acesso e Modificação: Usando
{}para criar dicionários e o operador de subscrito[]para adicionar, atualizar e recuperar dados. - Iteração: Percorrendo chaves, valores e pares chave-valor usando os métodos
keys(),values()eitems(). - Operações Seguras: Usando
get()para evitarKeyErroresetdefault()para adicionar itens condicionalmente. - Remoção de Itens: Usando
pop(),popitem(), a palavra-chavedeleclear()para remover itens. - Operações Utilitárias: Verificando a pertinência com o operador
in, formatando a saída compprinte mesclando dicionários com o operador de desempacotamento**.
Dominar os dicionários é um passo crucial para se tornar um programador Python proficiente. Continue praticando esses conceitos para construir aplicações mais complexas e eficientes.
