Entendendo Dicionários no Python 3

Introdução

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

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

A dictionary looks like this:

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

Além das chaves, há também 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áveis. 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}

Olhando para 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 posteriores, 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 no seu computador ou servidor. Se você não tiver um ambiente de programação configurado, pode consultar os guias de instalação e configuração para um ambiente de programação local ou para um ambiente de programação no seu servidor apropriado para o 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 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 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 da mesma forma usando o mesmo formato:

sammy['followers']
# Retorna 987

sammy['online']
# Retorna Verdadeiro

Ao fazer uso dos pares 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 integrados:

• 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 observar 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 através de 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 jogo 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 poderíamos 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 através de 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 em 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 loop for. Por exemplo, podemos imprimir cada uma das chaves e valores de um dicionário dado, e então 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 loop for acima iterou sobre os itens dentro do dicionário sammy e imprimiu as chaves e valores linha por linha, com informações para facilitar a compreensão pelos humanos.

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

Modificando Dicionários

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

Adicionando e Alterando Elementos do 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 nomes_de_usuário:

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 nomes_de_usuário 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. Neste caso, faremos referência a uma chave existente e passaremos 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 ganhou mais seguidores hoje, então precisamos atualizar o valor inteiro passado para a chave 'followers'. Usaremos 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 aumentou do valor inteiro de 305 para 342.

Podemos usar este método para adicionar pares chave-valor aos 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 usernames associados:

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

# Configurar 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 username para o nome associado
        username = input()

        # Atribuir valor de username à 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 semelhante à 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 específico, assim que você sair do programa com CTRL + C, perderá todos os seus dados a menos que implemente uma maneira de lidar com a leitura e gravação 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 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}

Pela 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 valor dado 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 ocorrer na saída.

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

Excluindo Elementos de Dicionário

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

Para remover um par chave-valor de um dicionário, usaremos 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 usando a plataforma online para jogar, então removeremos o item associado à chave 'points'. Em seguida, vamos imprimir 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 de dicionário em Python. 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 “Entendendo Tipos de Dados” (Understanding Data Types).

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