Compreensão de Dicionários no Python 3

Introdução

O dicionário é o tipo de mapeamento incorporado do Python. Os dicionários mapeiam chaves para valores e esses pares chave-valor fornecem uma maneira útil de armazenar dados em Python.

Normalmente usados para manter dados relacionados, como as informações contidas em um ID ou perfil de usuário, os dicionários são construídos com chaves curvadas em ambos os lados { }.

A dictionary looks like this:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

Além das chaves curvadas, também há dois pontos (:) em todo o dicionário.

As palavras à esquerda dos dois pontos são as chaves. As chaves podem ser compostas por qualquer tipo de dados imutável. As chaves no dicionário acima são:

• 'username'
• 'online'
• 'followers'

Cada uma das chaves no exemplo acima são valores de string.

As palavras à direita dos dois pontos são os valores. Os valores podem ser compostos por qualquer tipo de dados. Os valores no dicionário acima são:

• 'sammy-shark'
• Verdadeiro
• 987

Cada um desses valores é uma string, Booleano, ou inteiro.

Vamos imprimir o dicionário sammy:

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': True}

Observando a saída, a ordem dos pares chave-valor pode ter mudado. No Python versão 3.5 e anteriores, o tipo de dado dicionário é desordenado. No entanto, no Python versão 3.6 e posterior, o tipo de dado dicionário permanece ordenado. Independentemente se o dicionário é ordenado ou não, os pares chave-valor permanecerão intactos, nos permitindo acessar dados com base em seu significado relacional.

Pré-requisitos

Você deve ter o Python 3 instalado e um ambiente de programação configurado em seu computador ou servidor. Se você não tiver um ambiente de programação configurado, você pode consultar os guias de instalação e configuração para um ambiente de programação local ou para um ambiente de programação em seu servidor apropriado para seu sistema operacional (Ubuntu, CentOS, Debian, etc.).

Acessando Elementos do Dicionário

Podemos chamar os valores de um dicionário referenciando as chaves relacionadas.

Acessando Itens de Dados com Chaves

Porque os dicionários oferecem pares de chave-valor para armazenar dados, eles podem ser elementos importantes em seu programa Python.

Se quisermos isolar o nome de usuário de Sammy, podemos fazer isso chamando sammy['username']. Vamos imprimir isso:

print(sammy['username'])

Output
sammy-shark

Os dicionários se comportam como um banco de dados, pois, em vez de chamar um número inteiro para obter um valor de índice específico como você faria com uma lista, você atribui um valor a uma chave e pode chamar essa chave para obter seu valor relacionado.

Ao invocar a chave 'username', recebemos o valor dessa chave, que é 'sammy-shark'.

Os valores restantes no dicionário sammy podem ser chamados de forma semelhante usando o mesmo formato:

sammy['followers']
# Retorna 987

sammy['online']
# Retorna Verdadeiro

Ao fazer uso dos pares de chave-valor dos dicionários, podemos referenciar chaves para recuperar valores.

Usando Métodos para Acessar Elementos

Além de usar chaves para acessar valores, também podemos trabalhar com alguns métodos embutidos:

• dict.keys() isola chaves
• dict.values() isola valores
• dict.items() retorna itens em um formato de lista de pares de tuplas (chave, valor)

Para retornar as chaves, usaríamos o método dict.keys(). Em nosso exemplo, isso usaria o nome da variável e seria sammy.keys(). Vamos passar isso para um método print() e examinar a saída:

print(sammy.keys())

Output
dict_keys(['followers', 'username', 'online'])

Recebemos uma saída que coloca as chaves dentro de um objeto de visualização iterável da classe dict_keys. As chaves são então impressas em um formato de lista.

Este método pode ser usado para consultar dicionários. Por exemplo, podemos dar uma olhada nas chaves comuns compartilhadas entre duas estruturas de dados de dicionário:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}
jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

for common_key in sammy.keys() & jesse.keys():
    print(sammy[common_key], jesse[common_key])

O dicionário sammy e o dicionário jesse são cada um um dicionário de perfil de usuário.

Seus perfis têm chaves diferentes, no entanto, porque Sammy tem um perfil social com seguidores associados, e Jesse tem um perfil de jogos com pontos associados. As 2 chaves que eles têm em comum são username e status online, que podemos encontrar quando executamos este pequeno programa:

Output
sammy-shark JOctopus
True False

Certamente podemos melhorar o programa para tornar a saída mais legível para o usuário, mas isso ilustra que dict.keys() pode ser usado para verificar em vários dicionários o que eles têm em comum ou não. Isso é especialmente útil para dicionários grandes.

Da mesma forma, podemos usar o método dict.values() para consultar os valores no dicionário sammy, que seria construído como sammy.values(). Vamos imprimir esses valores:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

print(sammy.values())

Output
dict_values([True, 'sammy-shark', 987])

Ambos os métodos keys() e values() retornam listas não ordenadas das chaves e valores presentes no dicionário sammy com os objetos de visualização dict_keys e dict_values, respectivamente.

Se estivermos interessados em todos os itens de um dicionário, podemos acessá-los com o método items():

print(sammy.items())

Output
dict_items([('online', True), ('username', 'sammy-shark'), ('followers', 987)])

O formato retornado disso é uma lista composta por pares de tuplas (chave, valor) com o objeto de visualização dict_items.

Podemos iterar sobre o formato de lista retornado com um laço for. Por exemplo, podemos imprimir cada uma das chaves e valores de um dicionário dado e, em seguida, torná-lo mais legível adicionando uma string:

for key, value in sammy.items():
    print(key, 'is the key for the value', value)

Output
online is the key for the value True
followers is the key for the value 987
username is the key for the value sammy-shark

O laço for acima iterou sobre os itens dentro do dicionário sammy e imprimiu as chaves e valores linha por linha, com informações para torná-lo mais fácil de entender pelos humanos.

Podemos usar métodos integrados para acessar itens, valores e chaves das estruturas de dados de dicionário.

Modificando Dicionários

Dicionários são uma estrutura de dados mutável, então você é capaz de modificá-los. Nesta seção, vamos abordar a adição e exclusão de elementos de dicionário.

Adicionando e Alterando Elementos de Dicionário

Sem usar um método ou função, você pode adicionar pares chave-valor aos dicionários usando a seguinte sintaxe:

dict[key] = value

Vamos ver como isso funciona na prática adicionando um par chave-valor a um dicionário chamado usernames:

usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

usernames['Drew'] = 'squidly'

print(usernames)

Output
{'Drew': 'squidly', 'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

Agora vemos que o dicionário foi atualizado com o par chave-valor 'Drew': 'squidly'. Como os dicionários podem ser desordenados, esse par pode ocorrer em qualquer lugar na saída do dicionário. Se usarmos o dicionário usernames posteriormente em nosso arquivo de programa, ele incluirá o par chave-valor adicional.

Além disso, essa sintaxe pode ser usada para modificar o valor atribuído a uma chave. Nesse caso, vamos referenciar uma chave existente e passar um valor diferente para ela.

Vamos considerar um dicionário drew que é um dos usuários em uma determinada rede. Vamos dizer que esse usuário obteve um aumento de seguidores hoje, então precisamos atualizar o valor inteiro passado para a chave 'followers'. Vamos usar a função print() para verificar se o dicionário foi modificado.

drew = {'username': 'squidly', 'online': True, 'followers': 305}

drew['followers'] = 342

print(drew)

Output
{'username': 'squidly', 'followers': 342, 'online': True}

Na saída, vemos que o número de seguidores saltou do valor inteiro de 305 para 342.

Podemos usar este método para adicionar pares de chave-valor a dicionários com entrada do usuário. Vamos escrever um programa rápido, usernames.py, que é executado na linha de comando e permite a entrada do usuário para adicionar mais nomes e nomes de usuário associados:

# Definir dicionário original
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

# Configurar um loop while para iterar
while True:

    # Solicitar ao usuário que insira um nome
    print('Enter a name:')

    # Atribuir à variável de nome
    name = input()

    # Verificar se o nome está no dicionário e imprimir feedback
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # Se o nome não estiver no dicionário...
    else:

        # Fornecer feedback        
        print('I don\'t have ' + name + '\'s username, what is it?')

        # Receber um novo nome de usuário para o nome associado
        username = input()

        # Atribuir o valor do nome de usuário à chave de nome
        usernames[name] = username

        # Imprimir feedback de que os dados foram atualizados
        print('Data updated.')

Vamos executar o programa na linha de comando:

python usernames.py

Quando executamos o programa, obteremos algo como a seguinte saída:

Output
Enter a name:
Sammy
sammy-shark is the username of Sammy
Enter a name:
Jesse
I don't have Jesse's username, what is it?
JOctopus
Data updated.
Enter a name:

Quando terminarmos de testar o programa, podemos pressionar CTRL + C para sair do programa. Você pode configurar um gatilho para encerrar o programa (como digitar a letra q) com uma instrução condicional para melhorar o código.

Isso mostra como você pode modificar dicionários interativamente. Com este programa em particular, assim que sair do programa com CTRL + C, você perderá todos os seus dados a menos que implemente uma maneira de lidar com a leitura e escrita de arquivos.

Também podemos adicionar e modificar dicionários usando o método dict.update(). Isso difere do método append() disponível em listas.

No dicionário jesse abaixo, vamos adicionar a chave 'followers' e atribuir a ela um valor inteiro com jesse.update(). Em seguida, vamos print() o dicionário atualizado.

jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

jesse.update({'followers': 481})

print(jesse)

Output
{'followers': 481, 'username': 'JOctopus', 'points': 723, 'online': False}

A partir da saída, podemos ver que adicionamos com sucesso o par chave-valor 'followers': 481 ao dicionário jesse.

Também podemos usar o método dict.update() para modificar um par chave-valor existente substituindo um determinado valor por uma chave específica.

Vamos alterar o status online de Sammy de True para False no dicionário sammy:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

sammy.update({'online': False})

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': False}

A linha sammy.update({'online': False}) faz referência à chave existente 'online' e modifica seu valor booleano de True para False. Quando chamamos print() no dicionário, vemos a atualização acontecer na saída.

Para adicionar itens aos dicionários ou modificar valores, podemos usar tanto a sintaxe dict[key] = value quanto o método dict.update().

Excluindo Elementos de Dicionários

Assim como é possível adicionar pares chave-valor e alterar valores dentro do tipo de dados dicionário, também é possível excluir itens dentro de um dicionário.

Para remover um par chave-valor de um dicionário, utilizaremos a seguinte sintaxe:

del dict[key]

Vamos pegar o dicionário jesse que representa um dos usuários. Diremos que Jesse não está mais utilizando a plataforma online para jogar jogos, então removeremos o item associado à chave 'points'. Em seguida, imprimiremos o dicionário para confirmar que o item foi excluído:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

del jesse['points']

print(jesse)

Output
{'online': False, 'username': 'JOctopus', 'followers': 481}

A linha del jesse['points'] remove o par chave-valor 'points': 723 do dicionário jesse.

Se quisermos limpar um dicionário de todos os seus valores, podemos fazer isso com o método dict.clear(). Isso manterá um dicionário dado no caso de precisarmos usá-lo posteriormente no programa, mas ele não conterá mais nenhum item.

Vamos remover todos os itens dentro do dicionário jesse:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

jesse.clear()

print(jesse)

Output
{}

A saída mostra que agora temos um dicionário vazio, sem pares chave-valor.

Se não precisarmos mais de um dicionário específico, podemos usar del para nos livrarmos dele completamente:

del jesse

print(jesse)

Ao executarmos uma chamada para print() após excluir o dicionário jesse, receberemos o seguinte erro:

Output
...
NameError: name 'jesse' is not defined

Porque os dicionários são tipos de dados mutáveis, eles podem ser adicionados, modificados, e ter itens removidos e limpos.

Conclusão

Este tutorial passou pela estrutura de dados do dicionário em Python. Os dicionários são compostos por pares chave-valor e fornecem uma maneira de armazenar dados sem depender de indexação. Isso nos permite recuperar valores com base em seu significado e relação com outros tipos de dados.

A partir daqui, você pode aprender mais sobre outros tipos de dados em nosso tutorial “Compreendendo Tipos de Dados“.

Você pode ver o tipo de dado dicionário usado em projetos de programação como web scraping com Scrapy.