Dicionário Python – Tudo o que você precisa saber

Os dicionários Python são uma estrutura de dados incrivelmente útil que você encontrará com frequência em seus empreendimentos de programação. Sua capacidade exclusiva de mapear chaves para seus respectivos valores permite acesso rápido e eficiente e código simplificado ao gerenciar conjuntos de dados complexos.

Os dicionários Python são essencialmente uma implementação de matrizes associativas. Eles fornecem uma maneira flexível e eficiente de armazenar e manipular dados na forma de pares chave-valor.

Eles são muito versáteis e podem acomodar coleções mutáveis ​​e ordenadas sem permitir chaves duplicadas.

À medida que nos aprofundamos nos dicionários do Python neste artigo, você descobrirá que eles são ferramentas poderosas para organizar e acessar seus dados.

Portanto, certifique-se de se familiarizar com os meandros dos dicionários Python para liberar todo o seu potencial em seus projetos!

Índice

• Compreendendo os dicionários do Python
• Como criar um dicionário Python
  • Usando colchetes
  • Usando o Construtor Dict
• Como acessar os elementos do dicionário
  • Usando Chaves
  • Usando o Método Get
• Como modificar elementos do dicionário
  • Adicionando Novos Elementos
  • Atualizando Elementos Existentes
• Excluindo Elementos do Dicionário
  • Del Palavra-chave
  • Limpar método
• Quais são alguns métodos de dicionário comuns?
  • Chaves
  • valores
  • Unid
  • Atualizar
  • pop
  • Popitem
• Usando dicionários Python
  • Percorrer dicionários
  • O que são compreensões de dicionário?
  • O que são dicionários aninhados?
• Casos de uso do dicionário comum

Compreendendo os dicionários do Python

Um dicionário em Python é uma estrutura de dados poderosa e flexível que permite armazenar uma coleção de pares chave-valor. Pense em um dicionário como uma forma de mapear chaves para seus valores correspondentes, facilitando a recuperação de informações relacionadas a um identificador específico.

Para criar um dicionário, você pode usar chaves ( { } ) delimitando uma lista separada por vírgulas de pares chave-valor. Por exemplo:

your_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

Lembre-se de que os dicionários em Python são mutáveis, o que significa que você pode modificar seu conteúdo após a criação. Para adicionar ou atualizar um par chave-valor, basta usar a seguinte sintaxe:

your_dict["new_key"] = "new_value"

#You can also update an old key's value
your_dict["old_key"] = "new_value"

Quando se trata de acessar valores em um dicionário, você só precisa da chave:

value = your_dict["key1"]

Caso você tente acessar uma chave que não existe no dicionário, você encontrará um KeyError. Para evitar isso, você pode usar o método get():

value = your_dict.get("non_existent_key", "default_value")

Uma coisa que você deve lembrar é que um dicionário Python não pode conter chaves duplicadas. Cada chave deve ser exclusiva e de um tipo de dados imutável.

Por exemplo, você pode usar uma tupla, String, Integer ou até mesmo um Boolean para sua chave. No entanto, você não pode usar listas, dicionários ou conjuntos.

Não há tais restrições para valores. Você pode usar tipos de dados mutáveis ​​e imutáveis.

A remoção de um elemento de um dicionário é feita usando a palavra-chave del :

del your_dict["key1"]

Eles também fornecem vários métodos para iterar por meio de seu conteúdo. Por exemplo, você pode percorrer as chaves do dicionário, valores ou até mesmo ambos:

for key in your_dict.keys():
    print(key)

for value in your_dict.values():
    print(value)

for key, value in your_dict.items():
    print(key, value)

Agora você pode usar esses métodos e técnicas de dicionário para armazenar, recuperar e manipular dados com eficiência enquanto trabalha com Python .

Como criar um dicionário Python

Existem duas maneiras principais de criar dicionários Python: usando colchetes e o construtor dict() .

Usando colchetes

Um método que você pode usar para criar um dicionário é utilizando chaves ( {} ). Para inicializar um dicionário vazio, você pode simplesmente usar empty_dict = {} .

Para criar um dicionário com pares chave-valor, separe as chaves e os valores com dois pontos. Em seguida, separe cada par com uma vírgula:

python_dict = {
    'key1': 'value1',
    'key2': 'value2',
    'key3': 'value3'
}

Usando esse formato, você criou um dicionário Python com três pares chave-valor. Lembre-se que as chaves devem ser únicas enquanto os valores do dicionário podem ser duplicados.

Usando o Construtor Dict

Outro método para criar um dicionário Python é usar o construtor dict() . Para criar um dicionário vazio, simplesmente chame esta função sem nenhum argumento: empty_dict = dict() .

Para criar um dicionário usando o construtor dict() , você pode usar a seguinte sintaxe:

python_dict = dict(
    key1='value1',
    key2='value2',
    key3='value3'
)

Esse método também cria um dicionário Python com três elementos chave-valor. Observe que, ao contrário do método de colchetes, o construtor dict() não requer aspas em torno das chaves.

No entanto, os valores do dicionário ainda exigem aspas em torno deles

Agora que você está familiarizado com as duas maneiras de criar dicionários Python, pode começar a implementá-los em seu código e aproveitar seus recursos poderosos em seus aplicativos.

Como acessar os elementos do dicionário

Nesta seção, você aprenderá sobre diferentes maneiras de acessar elementos em um dicionário. Os dicionários armazenam dados em pares chave-valor e você pode acessar cada valor do dicionário usando suas respectivas chaves.

Abordaremos dois métodos populares: Usando chaves e o método get .

Usando Chaves

Uma das maneiras mais diretas de acessar os elementos do dicionário é usando as teclas. Para obter o valor de uma determinada chave de dicionário, basta colocar a chave entre colchetes ao lado do nome do dicionário:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict['name']

phone_value = mydict['phone-number']

Neste exemplo, name_value armazenaria a string 'John' . Observe que, se você tentar acessar uma chave inexistente, o Python gerará um KeyError .

Usando o Método Get

Uma alternativa para usar as chaves diretamente é o método get() , que permite acessar elementos do dicionário sem o risco de gerar um KeyError. Em vez disso, o método get retorna um valor padrão se a chave especificada não for encontrada:

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
name_value = my_dict.get('name', 'Key not found')
country_value = my_dict.get('country', 'Key not found')

Neste exemplo, name_value armazenaria a string ' John ' como antes, pois a chave ' name ' está presente no dicionário. No entanto, country_value armazenará o valor padrão ' Chave não encontrada ', pois a chave ' país ' não existe no dicionário.

O método get() fornece uma maneira mais flexível de acessar os elementos do dicionário, pois permite que você manipule as chaves ausentes normalmente. Você pode optar por usar qualquer um dos métodos, dependendo de seus requisitos e da possibilidade de encontrar chaves inexistentes.

Como modificar elementos do dicionário

Nesta seção, você aprenderá como modificar elementos em um dicionário Python. Existem duas operações principais para realizar isso: adicionar novos elementos e atualizar os existentes.

Ambos os métodos o ajudarão a manter a precisão e a utilidade do seu dicionário. Vejamos eles:

1. Adicionando Novos Elementos

Adicionar um novo elemento a um dicionário é simples. Para fazer isso, especifique o novo par chave-valor usando um operador de atribuição, como este:

your_dict = {"key1": "value1", "key2": "value2"}
your_dict["new_key"] = "new_value"

Depois de executar o trecho de código acima, seu dicionário incluirá o novo par:

{"key1": "value1", "key2": "value2", "new_key": "new_value"}

Você também pode adicionar vários pares chave-valor de uma só vez usando o método update() do dicionário

new_elements = {"key3": "value3", "key4": "value4"}
your_dict.update(new_elements)

Agora, seu dicionário conterá as seguintes entradas:

{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"}

1. Atualizando Elementos Existentes

Para atualizar o valor de um elemento existente, basta referenciar a chave e atribuir um novo valor a ela:

your_dict["key1"] = "updated_value1"

Essa alteração resultará no seguinte dicionário:

{"key1": "updated_value1", "key2": "value2", "key3": "value3", "key4": "value4"}

Se você precisar atualizar vários elementos de uma vez, use o método update() novamente. Para utilizá-lo, passe um novo dicionário contendo as modificações desejadas.

Por exemplo, vamos atualizar o dicionário your_dict com os valores do dicionário updates:

updates = {"key2": "updated_value2", "key4": "updated_value4"}
your_dict.update(updates)

Com essas atualizações aplicadas, o dicionário your_dict ficará assim:

{"key1": "updated_value1", "key2": "updated_value2", "key3": "value3", "key4": "updated_value4"}

Essas operações são ferramentas essenciais ao trabalhar, pois permitem manter suas estruturas de dados atualizadas e precisas.

Excluindo Elementos do Dicionário

Nesta seção, exploraremos duas maneiras comuns de excluir elementos de dicionário em Python: a palavra-chave del e o método clear() .

1. Del Palavra-chave

A palavra-chave del é usada para remover um par chave-valor específico de um dicionário. Ele opera no local e gera um KeyError se a chave não existir no dicionário. Para excluir um elemento, basta usar a seguinte sintaxe:

del my_dict[key]

Por exemplo, se você quiser deletar uma chave chamada “ brand ” de um dicionário chamado my_dict, você escreverá:

del my_dict["brand"]

Lembre-se de que é uma boa prática garantir que a chave exista no dicionário antes de usar a palavra-chave del. Você pode fazer isso verificando se a chave está no dicionário:

if "brand" in my_dict:
    del my_dict["brand"]

1. Limpar método

The clear() method is another way to delete dictionary elements. This method removes all dictionary keys and values in one operation, resulting in an empty dictionary.

To use the clear() method on your dictionary, simply call it. For example, if you have an existing dictionary named my_dict and you want to remove all its contents, you would write:

my_dict.clear()

In conclusion, you have learned two methods to delete elements from a Python dictionary: the del keyword for removing individual key-value pairs and the clear() method for emptying an entire dictionary.

What Are Some Common Dictionary Methods?

In this section, we will explore some common Python dictionary methods. These built-in methods will help you manipulate and modify dictionaries to suit your needs.

Keys

To retrieve all the keys from your dictionary, you can use the keys() method. This will return a view object containing all the dictionary’s keys.

For example:

your_dict = {'a': 1, 'b': 2, 'c': 3}
key_view = your_dict.keys()
print(key_view)
# Output: dict_keys(['a', 'b', 'c'])

Values

Similarly, the values() method allows you to obtain all the values stored in the dictionary. This is also presented as a view object.

For instance:

value_view = your_dict.values()
print(value_view)
# Output: dict_values([1, 2, 3])

Items

If you need to access both keys and values simultaneously, use the items() method. This returns a view object containing key-value pairs in the form of tuples.

Let’s look at an example:

item_view = your_dict.items()
print(item_view)
# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Update

The update() method allows you to modify your dictionary by adding or updating key-value elements. To use the method, you have to provide a dictionary as an argument.

To merge two dictionaries or update specific keys, use this method:

your_dict.update({'d': 4, 'e': 5})
print(your_dict)
# Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

Pop

Usando o método pop(), você pode remover um item específico do dicionário. Para usá-lo, forneça a chave a ser removida como argumento no método.

O método retornará o valor associado à chave especificada e o removerá do dicionário:

removed_value = your_dict.pop('a')
print(removed_value)
# Output: 1
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4, 'e': 5}

Popitem

O método popitem() remove o último par chave-valor do dicionário. Ele retorna uma tupla contendo a chave e o valor removidos. Por exemplo:

removed_item = your_dict.popitem()
print(removed_item)
# Output: ('e', 5)
print(your_dict)
# Output: {'b': 2, 'c': 3, 'd': 4}

Ao usar esses métodos, você pode gerenciar e manipular seus dicionários com eficiência para realizar uma variedade de tarefas.

Usando dicionários Python

Nesta seção, você aprenderá diferentes técnicas para trabalhar com dicionários, como fazer loop neles, usar compreensões de dicionário e trabalhar com dicionários aninhados.

Percorrer dicionários

Para percorrer um dicionário, você pode usar o método embutido items() para iterar em pares chave-valor. Isso permite que você execute operações em chaves e valores de maneira legível e eficiente.

Aqui está um exemplo:

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

for key, value in my_dict.items():
    print(key, value)

Como alternativa, você pode usar os métodos keys() e values() para iterar exclusivamente sobre as chaves ou valores do dicionário.

O que são compreensões de dicionário?

As compreensões de dicionário são uma maneira concisa de criar dicionários usando uma única linha de código. Eles são semelhantes às compreensões de lista, mas funcionam com dicionários.

Aqui está um exemplo de uma compreensão de dicionário que eleva ao quadrado os números de 1 a 5:

squared_numbers = {num: num**2 for num in range(1, 6)}

As compreensões de dicionário podem ser altamente valiosas para tarefas como filtrar dicionários ou transformar seus valores.

O que são dicionários aninhados?

Dicionários aninhados são dicionários que contêm outros dicionários como valores. Eles podem ser usados ​​para representar estruturas de dados hierárquicas complexas.

Aqui está um exemplo de um dicionário aninhado:

nested_dict = {
    "person1": {"name": "Alice", "age": 30},
    "person2": {"name": "Bob", "age": 24}
}

Para acessar um elemento em um dicionário aninhado, use indexação múltipla:

name_p1 = nested_dict["person1"]["name"]

Você pode editar ou manipular elementos nos dicionários aninhados conforme necessário. Lembre-se de acompanhar as chaves e os níveis de aninhamento ao trabalhar com dicionários aninhados complexos para evitar confusão ou erros.

Casos de uso do dicionário comum

Os dicionários Python são versáteis, permitindo que você organize e gerencie vários tipos de dados. Nesta seção, você explorará alguns casos de uso comuns para dicionários, que irão aprimorar sua compreensão e ajudá-lo a implementá-los de forma eficaz em seus projetos.

1. Armazenamento de dados chave-valor : Os dicionários são ideais para armazenar dados com chaves exclusivas e valores associados, como nomes de usuário e informações do usuário ou IDs de produto e detalhes do produto:

{
  "username1": {"name": "Alice", "email": "[email protected]"},
  "username2": {"name": "Bob", "email": "[email protected]"}
}

Um exemplo disso pode ser visto neste vídeo sobre Como construir um agregador de notícias do Google no LuckyTemplates usando Python.

https://youtu.be/InsDb_DR15E

Neste vídeo, usamos um dicionário para armazenar valores de dados obtidos de uma chamada da API do GoogleNews.

2. Contagem de ocorrências : você pode usar dicionários para contar as ocorrências de itens, como a frequência de palavras em um documento. Usando chaves para representar os itens exclusivos e valores para indicar a contagem, você pode gerenciar esses dados com eficiência.

Curiosidade, você pode fazer isso com a classe Counter no módulo Python Collections. Ele pega uma lista não ordenada e retorna um dicionário com cada elemento único como uma chave e sua frequência como seu respectivo valor.

3. Mapeamento de chaves para vários valores : Se você precisar armazenar vários valores para cada chave de dicionário, poderá usar listas ou conjuntos como valores em seu dicionário:

{
  "fruits": ["apple", "banana", "mango"],
  "vegetables": ["carrot", "broccoli", "spinach"]
}

4. Cache de resultados computados : Dicionários podem ser usados ​​para armazenar em cache resultados de operações caras. Isso é especialmente útil em técnicas de memoização e programação dinâmica, onde você armazena os resultados dos cálculos para evitar cálculos redundantes.

5. Criação de índices invertidos : Em casos como mecanismos de pesquisa, você pode exigir um índice invertido que mapeie cada termo de pesquisa para uma lista de recursos que contenham o termo. A utilização de dicionários permite que você armazene esses dados de forma eficiente:

{
  "python": ["resource1", "resource3"],
  "dictionary": ["resource2", "resource3", "resource4"]
}

Estes são apenas alguns exemplos para ilustrar o poder e a versatilidade dos dicionários Python. Ao entender esses casos de uso e seus aplicativos, você pode aproveitar todo o potencial dos dicionários para criar soluções eficientes para suas tarefas de programação!