Aprenda a utilizar dicionários em Python: Guia completo
Neste guia completo, você aprenderá a criar, acessar e manipular dicionários em Python. Entenda as principais funções e como utilizá-las para resolver problemas comuns de programação.
O que é um dicionário?
Dicionários são uma estrutura formada por um conjunto de chave e valor, onde:
- Chave: É única em cada objeto e serve para mapear o valor, funciona como um identificador.
- Valor: É um dado que pode ser de qualquer tipo, como, por exemplo: inteiros , listas, textos, reais e até outros dicionários.
A estrutura de um dicionário é chamado normalmente de array associativo, em Python o tipo dicionário é denominado dict e sua sintaxe é normalmente como um conjunto onde chave e valor são separados por dois pontos(:) e colocados entre chaves({}), com vírgulas(,) separando cada conjunto.
{
"chave1": "valor1",
"chave2": "valor2"
}
Para que serve um dicionário?
Dicionários são extremamente versáteis, eles são mutáveis, ou seja, podemos alterá-los após definidos, inserindo, retirando ou alterando seus itens. Não existe início, fim ou ordem em um dicionário, então podemos adicionar dados e retirar sem nos preocupar em “quebrá-los”, até porque acessamos o seu valor por uma chave e não por sua posição como seria em uma lista.
Um exemplo de utilização de dicionários está logo abaixo onde se definiram algumas capitais do Brasil tendo como chave o nome do estado.
{"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
Como criar um dicionário?
Como se declara um dicionário é bem intuitivo, e já mostramos um exemplo acima, para defini-lo em Python basta associar o seu valor a alguma variável. Provavelmente você já viu um arquivo JSON em algum momento da sua vida, o dicionário é criado da mesma forma, definido entre duas chaves ({}) separando a chave e o valor com dois pontos (:):
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
Criando um dicionário com a função dict
Também podemos criar um dicionário com a função dict, temos algumas formas de fazer isso, pode ser uma lista que contém tuplas com as chaves e os valores em ordem mas também pode ser com uma lista de outras listas com os conjuntos.
capitais = dict([("São Paulo", "São Paulo"),
("Bahia", "Salvador"),
("Goiás", "Goiânia")])
capitais = dict([["São Paulo", "São Paulo"],
["Bahia", "Salvador"],
["Goiás", "Goiânia"]])
Caso as chaves sejam apenas textos simples, podemos montar um dicionário passando as chaves como argumentos da função dict, no nosso exemplo teremos que ajustar as chaves, pois utilizamos espaços e acentuação nos exemplos anteriores.
capitais = dict(sao_paulo = "São Paulo",
bahia = "Salvador",
goias = "Goiânia")
Criando um dicionário incrementalmente
Definir o dicionário das formas anteriores podem ser úteis, porém muitas vezes não temos todos os valores e chaves na hora de criação do dicionário, pois estes dados podem estar sendo consultados em um banco de dados ou dependem da interação do usuário.
Para resolver isso podemos criar um dicionário de forma incremental, iniciaremos vazio e iremos adicionando valores com o andamento do programa, observe o exemplo abaixo com os comentários explicando cada linha:
capitais = {} # Define um dicionário vazio
nome_do_estado = input("Nome do estado: ") # Ex: Tocantins
nome_da_capital = input("Nome da capital deste estado: ") # Ex: Palmas
capitais[nome_do_estado] = nome_da_capital # Insere o conjunto no dicionário
print(capitais)
# {'Tocantins': 'Palmas'}
Neste exemplo foi cadastrado apenas um valor, agora podemos elaborar algo semelhante, porém colocando a parte do código que define o conjunto e insere no dicionário dentro de um laço de repetição, para assim cadastrarmos vários valores até o usuário encerrar a interação.
capitais = {} # Define um dicionário vazio
while True:
nome_do_estado = input("Nome do estado: ") # Nome do estado
nome_da_capital = input("Nome da capital deste estado: ") # Nome da capital do estado
capitais[nome_do_estado] = nome_da_capital # Insere o conjunto no dicionário
opcao = int(input("DIGITE '1' PARA CADASTRAR OUTRO CONJUNTO E '0' PARA ENCERRAR: "))
if opcao == 0: # Verifica se o usuário deseja encerrar
break # Encerra o laço
print(capitais)
# {'Tocantins': 'Palmas', 'São Paulo': 'São Paulo'}
Tipo dos dados armazenado no dicionário
Podemos armazenar dados de todos os tipos do Python em um dicionário, e podemos inclusive armazenar diferentes tipos no mesmo dicionário, no exemplo abaixo criaremos um dicionário com os tipos básicos.
tipos = {'inteiro': 123,
'flutuante': 123.0,
'texto': '123',
'booliano': True,
'lista': [1, 2, 3],
'dicionário': {'chave': 'valor'}}
Podemos fazer a mesma coisa com as chaves, utilizar tipos diferentes no mesmo dicionário.
tipos = {1: 123,
1.2: 123.0,
'texto': '123',
True: True}
Limitações dos tipos utilizados nas chaves
Como visto no exemplo acima, onde foi utilizado inteiro, flutuante, texto e bool, podemos utilizar vários tipos como chave, além desses podemos utilizar também objetivos internos do Python como chaves, como int, float, hex entre outros.
tipos = {int: 123,
bool: 123.0}
Outra limitação é que o tipo do dado deve ser imutável, então não podemos utilizar dicionários e listas como chaves, mas por mais estranho que possa parecer podemos utilizar tuplas, afinal elas são imutáveis, caso tenha dificuldade em entender a diferença entre listas e tuplas veja este artigo.
tipos = {(1, 2): 123}
Acessando e utilizando os dados do dicionário
Existem várias formas de acessar os registros de um dicionário, o mais simples é pela chave, mas mesmo essa forma de resgatar o valor tem algumas variações e maneiras diferentes de serem feitas.
Acessando um registro pela chave
Uma forma simples de resgatar o registro é colocando a chave entre colchetes([]).
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais["Goiás"])
# Goiânia
Acessando um valor pela chave com o método get
Também podemos utilizar o método get que atingiremos um resultado semelhante.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais.get("Goiás"))
# Goiânia
Acessando um valor pela chave evitando erros
Um problema desses dois métodos mostrados acima é que caso não exista uma chave com esse nome irá acontecer um erro, para solucionar isso podemos utilizar o método get, porém passando um segundo argumento chamado default, dessa forma caso a chave não exista no dicionário esse valor default será retornado.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais.get("Goiás", "Não cadastrado"))
# Goiânia
print(capitais.get("Acre", "Não cadastrado"))
# Não cadastrado
Convertendo um dicionário em uma lista
Em alguns casos é interessante extrair todos os valores de um dicionário e trabalhar com eles como uma lista, podemos fazer isso de algumas formas e extrair listas diferentes.
Extraindo uma lista com as chaves de um dicionário
Para extrair apenas as chaves em um dicionário para uma lista podemos utilizar o método keys com a função list.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(list(capitais.keys()))
# ['São Paulo', 'Bahia', 'Goiás']
Extraindo uma lista com os valores de um dicionário
Também podemos querer fazer isso apenas com os valores, para isso utilizaremos o método values e a função list da mesma forma do exemplo anterior.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(list(capitais.values()))
# ['São Paulo', 'Salvador', 'Goiânia']
Extraindo uma lista com as chaves e os valores de um dicionário
Também podemos extrair às duas informações do conjunto, nesse caso utilizaremos o método items e a função list da mesma forma dos exemplos anteriores, porém nesse caso teremos uma lista de tuplas, onde cada tupla está ordenado com a chave e o valor.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(list(capitais.items()))
# [('São Paulo', 'São Paulo'), ('Bahia', 'Salvador'), ('Goiás', 'Goiânia')]
Atualizando itens
A maneira simples de se atualizar um dicionário é simplesmente atribuir um novo valor a uma chave já presente no objeto.
dicionario = {'teste': 1}
print(dicionario)
# {'teste': 1}
dicionario['teste'] = 2
print(dicionario)
# {'teste': 2}
Método update
O método update também é utilizado para atualizar dados de um dicionário. Ele tem uma propriedade muito interessante que é a capacidade de “juntar” dicionários atualizando os valores do dicionário em que tenha o método chamado ou até mesmo criando novas chaves caso ela só exista no dicionário que está sendo utilizado para atualizar os valores.
velho = {'a': 1, 'b': 2}
print(velho)
# {'a': 1, 'b': 2}
novo = {'a': 3, 'b': 4, 'c': 5}
velho.update(novo)
print(velho)
# {'a': 3, 'b': 4, 'c': 5}
Também podemos passar os registros para serem atualizados com uma lista de pares e valores, podendo os pares serem tuplas ou listas.
velho = {'a': 1, 'b': 2}
print(velho)
# {'a': 1, 'b': 2}
velho.update([('a', 3), ('b', 4), ('c', 5)])
print(velho)
# {'a': 3, 'b': 4, 'c': 5}
velho = {'a': 1, 'b': 2}
print(velho)
# {'a': 1, 'b': 2}
velho.update([['a', 3], ['b', 4], ['c', 5]])
print(velho)
# {'a': 3, 'b': 4, 'c': 5}
Outra forma de utilizar o método update é passando as chaves como argumentos, semelhante aquando utilizamos a função dict para criar o dicionário.
velho = {'a': 1, 'b': 2}
print(velho)
# {'a': 1, 'b': 2}
velho.update(a=3, b=4, c=5)
print(velho)
# {'a': 3, 'b': 4, 'c': 5}
Excluindo registros do dicionário
Como quase tudo em Python, existem algumas formas de remover um registro de um dicionário, caso queira apenas remover o valor basta atribuir um valor não representativo para essa chave(None).
Instrução del
Para excluir um registro de um dicionário a instrução del pode ser utilizada, basta fornecer o registro que deseja que seja deletado.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
del capitais["Bahia"]
print(capitais)
# {'São Paulo': 'São Paulo', 'Goiás': 'Goiânia'}
Método pop
Podemos utilizar o método pop, que elimina o valor associado a chave e retorna esse valor, propriedade bem útil em alguns casos onde elimina a necessidade de resgatar o valor antes de excluí-lo.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
valor = capitais.pop("Bahia")
print(valor)
# Salvador
print(capitais)
# {'São Paulo': 'São Paulo', 'Goiás': 'Goiânia'}
Método popitem
O método popitem exclui o último registro adicionado ao dicionário e retorna uma tupla com a chave e o valor, nessa ordem.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
valor = capitais.popitem()
print(valor)
# ('Goiás', 'Goiânia')
print(capitais)
# {'São Paulo': 'São Paulo', 'Goiás': 'Goiânia'}
Evitando erros
As 3 formas de excluir um registro do dicionário mostrado acima irá ocasionar um erro na hora de excluir um conjunto caso a chave não esteja presente no dicionário. Para evitar isso podemos utilizar o atributo default do método get, passando um valor que será retornado caso a chave não exista no objeto.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
valor = capitais.pop('Tocantins', 'Não encontrado')
print(valor)
# Não encontrado
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
Excluindo todos os registros de um dicionário
Caso precise limpar um dicionário, excluindo todos os seus registros, o método clear pode ser utilizado para isso.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
print(capitais)
# {'São Paulo': 'São Paulo', 'Bahia': 'Salvador', 'Goiás': 'Goiânia'}
capitais.clear()
print(capitais)
# {}
Percorrendo os registros de um dicionário
Para percorrer os registros de um dicionário com o for utilizar o método items é uma excelente escolha, pois com ele é possível interagir tanto com a chave como com o valor sem precisar acessar o dicionário novamente.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
for chave, valor in capitais.items():
print(f"{chave}: {valor}")
# São Paulo: São Paulo
# Bahia: Salvador
# Goiás: Goiânia
Caso queira apenas os valores, utilize o método values
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
for valor in capitais.values():
print(valor)
# São Paulo
# Salvador
# Goiânia
Caso queira apenas as chaves, utilize o método keys.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
for chave in capitais.keys():
print(chave)
# São Paulo
# Bahia
# Goiás
Por esse método você também pode acessar o valor associado à chave, basta utilizar alguma das formas de resgatar um registro apresentado anteriormente.
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador",
"Goiás": "Goiânia"}
for chave in capitais.keys():
print(f"{chave}: {capitais[chave]}")
# São Paulo: São Paulo
# Bahia: Salvador
# Goiás: Goiânia
Quantidade de chaves em um dicionário
Para “contar” quantas chaves estão presentes em um dicionário podemos utilizar a função len.
Como feito no exemplo abaixo:
capitais = {"São Paulo": "São Paulo",
"Bahia": "Salvador", "Goiás": "Goiânia"}
print(len(capitais))
Quando você usa um dicionário como argumento para len(), a função retorna o número de itens no dicionário:
No exemplo acima a saída será:
2
Será retornado 2, pois temos apenas as chaves São Paulo e Bahia registradas no dicionário.
Conclusão
Agora que você já sabe o básico sobre dicionários, que tal continuar estudando?
Além desses conteúdos aqui apresentados o Python tem algumas outras formas de interagir com dicionários com aplicações mais específicas, em breve elaborarei um artigo ainda mais completo que esse.
Caso queira aprender mais por agora, recomendo que dê uma olhada na documentação do Python, é bem completa e mostrará tudo que a linguagem tem a oferecer para lidar com dicionários.