Dicionários no Python

Opa Dev!

Neste post vamos falar sobre algo EXTREMAMENTE importante na vida do dev Python: os famosos Dicionários!

Eles são estruturas muito flexíveis, que possibilita a adição de (quase) tudo!

Garanto que você vai sair daqui um craque em Dicionários, combinado?

Então já deixa o café pronto e BORA!

Vá Direto ao Assunto…

• Introdução
• Criando dicionários
• Acessando itens
• Obtendo chaves e valores
• Adicionando e atualizando itens
• Excluindo elementos no dicionário
• Limpando dicionário
• Copiando Dicionário
• O método dict.setdefault()
• Criando Dicionários a partir de lista de valores
• Operador de “desempacotamento”
• Dicionários como args e kwargs
• Juntando dicionários com **

Introdução

Os dicionários são coleções de itens e seus elementos são armazenados de forma não ordenada.

Seus elementos contém uma chave e valor, isto é:

• Uma chave que vai servir para indexar (posicionar) determinado elemento no dicionário.
• Um valor que contém… Bem, um valor Este valor aceita diversos tipos: listas, outros dicionários, inteiros, strings e etc.

Sua sintaxe básica é: {'chave': 'valor'}. Utiliza-se {} para delimitar o dicionário e a chave é separada do valor por dois pontos :.

Exemplo de sua sintaxe:

1
2
3

dicio = {'chave': 'valor'}

print(type(dicio))

Quando utilizar type() e a saída for essa abaixo, pode ter certeza que é um dicionário!

1

<class 'dict'>

Criando dicionários

Agora vamos ver 6 maneiras de criar um mesmo dicionário!

O modo mais simples de criar um dicionário:

1

dicio_2 = {'primeiro': 1, 'segundo':  2, 'terceiro': 3}

Também podemos utilizar a função dict do próprio Python (built-in function), passando as chaves e valores como parâmetros:

1

dicio = dict(primeiro=1, segundo=2, terceiro=3)

Utilizando a função zip para concatenar a chave:valor em um elemento do objeto dict:

1

dicio_3 = dict(zip(['primeiro', 'segundo', 'terceiro'], [1, 2, 3]))

Utilizando uma lista de tuplas com itens simbolizando chave e valor em um objeto dict:

1

dicio_4 = dict([('primeiro', 1), ('segundo', 2), ('terceiro', 3)])

Com Dict Comprehensions!

Não sabe o que é? Nós temos um Post completissimo sobre Dict Comprehensions!

Veja como:

1

dicio_6 = {name: idx + 1 for idx, name in enumerate(('primeiro', 'segundo', 'terceiro'))}

Por mais estranho que pareça, podemos tentar transformar uma variável do tipo dicionário em dicionário.

1

dicio_5 = dict({'primeiro': 1, 'segundo':  2, 'terceiro': 3})

Todos esses exemplos tem o mesmo resultado, que esta sendo mostrado abaixo:

1

{'primeiro': 1, 'segundo': 2, 'terceiro': 3}

Acessando itens

Para acessar o valor de um dicionário podemos utilizar sua chave. Exemplo:

1
2
3

pessoa = {'nome': 'Pythonico', 'altura': 1.65, 'idade': 21}

print(pessoa['nome'])

Saída com o valor da chave especificada:

1

Pythonico

Dicionários também contam com um método chamado get() que fornecerá o mesmo resultado:

1

print(pessoa.get('nome'))

A saída será a mesma, o resultado: Pythonico

Uma coisa interessante sobre esse método é que você pode definir um valor default, para o caso da chave não ser encontrada, exemplo:

1

print(pessoa.get('peso', 'Chave não encontrada'))

Como não existe nenhuma chave chamada 'peso', ele retorna:

1

Chave não encontrada

Obtendo chaves e valores

Se você deseja obter todas as chaves de um dicionário, use o método keys():

1
2
3

computador = {'CPU': 'Intel', 'RAM': '8gb', 'SSD': '250bg'}

print(computador.keys())

A saída é um objeto do tipo dict_keys que equivale a uma lista com todas as chaves:

1

dict_keys(['CPU', 'RAM', 'SSD'])

Para obter apenas os valores das chaves em seu dicionário:

1
2
3

notas = {'Mat': 5, 'Por': 7, 'His': 8}

print(notas.values())

A saída será uma lista com os valores de cada chave:

1

dict_values([5, 7, 8])

Percorrendo os elementos de um Dicionário

Podemos percorrer os elementos de um Dicionário a partir de suas chaves dict.keys() ou a partir de seus valores dict.values().

Percorrendo elementos com a função dict.keys():

1
2
3
4

computador = {'CPU': 'Intel', 'RAM': '8gb', 'SSD': '250bg'}

for chave in computador.keys():
  print(f'Chave = {chave} e Valor = {computador[chave]}')

A saída será:

1
2
3

Chave = CPU e Valor = Intel
Chave = RAM e Valor = 8gb
Chave = SSD e Valor = 250bg

Percorrendo elementos com a função dict.values():

1
2
3
4

notas = {'Mat': 5, 'Por': 7, 'His': 8}

for valor in notas.values():
    print(f'Valor: {valor}')

A saída será:

1
2
3

Valor: 5
Valor: 7
Valor: 8

Percorrendo as chaves e valores de um Dicionário

Uma maneira de obter chaves e valores é utilizando o método dict.items().

Veja como:

1
2
3

frutas = {'pera': 10, 'uva': 2, 'maça': 55}

print(frutas.items())

A saída equivale a uma lista com elementos organizados em tuplas, sendo:

• O primeiro elemento da tupla a chave do dicionário e
• O segundo elemento, o valor presente naquela chave.

Veja:

1

dict_items([('pera', 10), ('uva', 2), ('maça', 55)])

Podemos acessar essse valores utilizando o loop for, para percorrer esses dados:

1
2

for chave, valor in frutas.items():
    print(f"Chave = {chave} - Valor = {valor}")

Uma maneira segura de acessar um elemento de um dicionário é verificando primeiro se a chave existe.

Exemplo:

1
2
3
4
5
6
7
8
9

dicio_cores = {'amarelo': 10, 'vermelho': 2, 'cinza': 55}

# Verificando se chave existe
if 'amarelo' in dicio_cores:
    print(f"Como a cor desejada existe: {dicio_cores['amarelo']}")

# Verificando se valor existe
if 10 in dicio_cores.values():
    print('O valor desejado existe')

A saída será:

1
2

Como a cor desejada existe: 10
O valor desejado existe

Adicionando e atualizando itens

A maneira mais simples de adicionar um item a um dicionario é criar uma nova chave e atribuir um valor. Assim:

1
2
3
4
5

dicio = {'nome': 'Erick'}

dicio['idade'] = 20

print(dicio)

Resultando na adição da chave e valor especificada acima:

1

{'nome': 'Erick', 'idade': 20}

O método update() tanto pode criar, como atualizar dados:

1
2
3
4
5
6
7
8
9
10

dicio = {'nome': 'Erick'}

# Atualiza o elemento de chave 'nome'
dicio.update({'nome':'Matheus'})

# Cria os elementos de chave 'idade' e 'tamanho'
dicio.update({'idade':18})
dicio.update(tamanho=1.60)

print(dicio)

Saída:

1

{'nome': 'Matheus', 'idade': 18, 'tamanho': 1.60}

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Excluindo elementos no dicionário

Você pode excluir um elemento do dicionário com a keyword del do Python, especificando sua chave:

1
2
3
4
5

pessoa = {'nome': 'Matheus', 'idade': 18, 'tamanho': 1.60}

del pessoa['tamanho']

print(pessoa)

Resultando na exclusão do dado especificado:

1

{'nome': 'Matheus', 'idade': 18}

Excluindo e retornando o elemento excluído

O método pop() remove o item cujo a chave foi especificada:

1
2
3
4
5
6

sacola = {'maça': 2, 'ovos': 6, 'farinha': 2}

ovos = sacola.pop('ovos')

print(ovos)
print(sacola)

Saída:

1
2

6
{'maça': 2, 'farinha': 2}

Veja que o dicionário resultante não possui mais a chave ['ovos']

Excluindo último item

O método popitem() também remove o último elemento do dicionário.

Contudo, diferente do método pop() que apenas retorna o valor daquele elemento, popitem() retorna o elemento todo, contendo chave e valor.

Veja usando o mesmo exemplo do método pop():

1
2
3
4
5
6

sacola = {'maça': 2, 'ovos': 6, 'farinha': 2}

farinha = sacola.popitem()

print(farinha)
print(sacola)

Veja que o retorno foi uma tupla e o último item foi removido:

1
2

('farinha', 2)
{'maça': 2, 'ovos': 6}

Limpando dicionário

Uma maneira de esvaziar um dicionário é utilizando o método clear(), dessa forma:

1
2
3
4

dicio = {'nome': 'F9', 'motor': 'v8', 'ano': 2019}
dicio.clear()

print(dicio)

O retorno é um dicionário vazio: {}.

Copiando Dicionário

Em Python, você não pode simplesmente digitar dict1 = dict2 para copiar um dicionário.

Dessa forma você esta apenas copiando a referência do dict1 ao dict2.

A maneira correta de criar uma cópia do dicionário é utilizando o método copy(), assim:

1
2
3
4
5
6

dicio = {"operacao": "web scraping", "dados": 250}

copia = dicio.copy()

print(copia)
print(dicio)

Resultando na cópia exata do dicionário

1
2

{'operacao': 'web scraping', 'dados': 250}
{'operacao': 'web scraping', 'dados': 250}

O método dict.setdefault()

O método dict.setdefault() retorna o valor da chave especificada, e, caso a chave não exista, a cria com o valor especificado.

Vamos ao exemplo:

1
2
3
4
5
6

dicio = {'coleta': 'scrapy', 'dados': 200}

set_dados = dicio.setdefault('dados')

print(set_dados)
print(dicio)

Como a chave dados existe, ela é retornada:

1
2

200
{'coleta': 'scrapy', 'dados': 200}

Agora vamos adicionar apenas a chave sem valor, e outro com chave e valor:

1
2
3
4
5
6
7
8

dicio = {'coleta': 'scrapy', 'dados': 200}

set_data = dicio.setdefault('data')
set_teste = dicio.setdefault('teste', 1)

print(set_data)
print(set_teste)
print(dicio)

A saída resulta em:

1
2
3

None
1
{'coleta': 'scrapy', 'dados': 200, 'data': None, 'teste': 1}

O set_data que teve apenas atribuída uma chave, teve seu valor criado como None, enquanto set_teste teve o valor adicionado.

Criando Dicionários a partir de lista de valores

Com o método dict.fromkeys() é possível criar um dicionário a partir de uma lista de chaves e um valor, que será usado em todas as chaves.

Veja o exemplo:

1
2
3
4
5
6

chaves = ['chave1', 'chave2', 'chave3']
valor = 0

dicio = dict.fromkeys(chaves , valor)

print(dicio)

Veja que o valor 0 foi atribuído em todas as chaves:

1

{'chave1': 0, 'chave2': 0, 'chave3': 0}

Operador de “desempacotamento”

O Python introduziu em sua linguagem um operador de “unpacking”, ou operador de desempacotamento.

Para utilizar esse operador, devemos usar dois asteriscos antes da variável que vai ser descontruída (**variavel).

Pode ser utilizado em tuplas, listas e em nossos queridos dicionários.

No caso do Dicionário, o que ele faz é desconstruir cada elemento do dicionário em chave e valor, tentando casar o nome do argumento da função com a chave do dicionário.

Ficou confuso? Vamos ao exemplo!

Suponha a seguinte função:

1
2

def funcao(argumento):
    print(argumento)

Agora vamos chamá-la duas vezes, uma sem o operador de desempacotamento e outra com ele:

1
2
3
4

dicionario = {'argumento': 1}

funcao(dicionario)
funcao(**dicionario)

Agora veja a saída de cada um:

1
2

{'argumento': 1}
1

Na primeira chamada, sem o operador, a saída foi apenas o print daquilo que foi passado. No caso, um dicionário.

Já na segunda, o operador fez com que a função tentasse “encaixar” a chave argumento do dicionário (de valor 1) com o argumento da função.

Dessa forma, apenas o valor foi printado!

Dicionários como args e kwargs

Como vimos aqui em cima, dicionários podem ser passados como valores para funções.

Além disso, podemos usar o operador de desempacotamento para casar as chaves do dicionário com os argumentos da função:

1
2
3
4
5
6
7
8
9

regulagem = {'max': 10, 'meio': 5, 'min': 0}

def funcao(max, meio, min):
    print(max)
    print(meio)
    print(min)


funcao(**regulagem)

Resultando em:

1
2
3

10
5
0

Se caso você desconheça as chaves de um dicionário, basta adicionar em sua função o atributo kwargs (Keyword Arguments ou Argumentos Nomeados).

O atributo kwargs recebe todos os argumento que tenham sido passados com nome.

Exemplo: funcao(arg=1). Nesse caso, arg é um Argumento Nomeado e pode ser acessado pela variável kwargs.

Percorrendo o kwargs temos acesso às chaves, onde podemos, portanto, buscar os valores que desejamos através do método .get().

Veja o exemplo:

1
2
3
4
5
6
7
8
9

# Definição da Função recebendo kwargs
def funcao(**kwargs):
    # Percorrendo argumento nomeados
    for chave in kwargs:
        print(f"Acessando Chave '{chave}', valor = {kwargs.get(chave)}")

regulagem = {'max': 10, 'meio': 5, 'min': 0}

funcao(**regulagem)

Saída impressa pela função:

1
2
3

Acessando Chave 'max', valor = 10
Acessando Chave 'meio', valor = 5
Acessando Chave 'min', valor = 0

Já o argumento args possui os Argumentos Não-Nomeados.

Se necessario pegar apenas as chaves do dicionário, podemos utilizar args para isso e chamando a função passando um asterisco em nosso dicionário, da seguinte maneira:

1
2
3
4
5

def funcao(*args):
    for chave in args:
        print(chave)

funcao(*regulagem)

Veja que saída contém apenas as chaves:

1
2
3

max
meio
min

Juntando dicionários com **

Outra coisa que podemos fazer com o operador de desempacotamento é juntar dicionários.

Como esse operador desconstrói um dicionário em chave e valor, podemos utilizá-lo para juntar dicionários, da seguinte forma:

1
2
3
4
5
6
7

regulagem = {'max': 10, 'meio': 5, 'min': 0}
extra = {'passo': 2}

# Junção de dicionários com **
juncao_dicio = {**regulagem, **extra}

print(juncao_dicio)

Saída:

1

{'max': 10, 'meio': 5, 'min': 0, 'passo': 2}

Conclusão

Nesse Post vimos do básico ao avançado sobre Dicionários!

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 27/06/2021

Bora se conectar no LinkedIn!

Minhas redes: