Vantagem

Ready to put your newfound language skills into use? Get 40% off CodeCrafter's real-world proficiency projects!

Resgate seu desconto
Trilhas
/
Python
Python
/
Programa
/
Métodos de dicionário
Mé

Métodos de dicionário em Python

2 exercícios

Sobre Métodos de dicionário

A classe dict do Python oferece muitos métodos úteis para trabalhar com dicionários. Alguns foram apresentados no conceito de dict. Aqui veremos mais alguns, além de algumas técnicas para iterar sobre dicionários e manipulá-los.

  • <dict>.setdefault() adiciona chaves automaticamente sem lançar um KeyError.
  • <dict>.fromkeys(<iterable>, <default value>) cria um novo dict a partir de qualquer número de iteráveis.
  • <dict>.keys(), <dict>.values() e <dict>.items() fornecem iteradores convenientes.
  • sorted(<dict>.items()) pode reordenar facilmente as entradas de um dict.
  • <dict_one>.update(<dict_two>) atualiza um dict com os valores sobrepostos de outro dict.
  • <dict> | <other_dict> e <dict> |= <other_dict> mesclam ou atualizam dois dicts por meio de operadores.
  • reversed(<dict>.keys()), reversed(<dict>.values()) ou reversed(<dict>.items()) produzem visões invertidas.
  • <dict>.popitem() remove e retorna um par key, value.

setdefault() para inserção sem erros

O conceito de dicionário já mostrou que <dict>.get(<key>, <default value>) retorna um value existente ou o default value se uma key não for encontrada no dicionário, evitando assim um KeyError. Isso funciona bem em situações nas quais você prefere não ter tratamento de erro extra, mas não pode confiar que uma key procurada estará presente.

Para uma operação de inserção igualmente "segura" (sem KeyError), existe o método <dict>.setdefault(<key>, <default value>). <dict>.setdefault(<key>, <default value>) retornará o value se a key for encontrada no dicionário. Se a chave não for encontrada, ele vai inserir o par (key, default value) e retornar o default value para uso.

>>> palette_I = {'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd'}

# Looking for the value associated with key "Rock Brown".The key does not exist, 
# so it is added with the default value, and the value is returned.
>>> palette.setdefault('Rock Brown', '#694605')
'#694605'

# The (key, default value) pair has now been added to the dictionary.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Rock Brown': '#694605'}

fromkeys() para preencher um dicionário a partir de um iterável

Para preencher rapidamente um dicionário com várias keys e valores padrão, o método de classe fromkeys(<iterable>, <default value>) vai iterar sobre um iterável de keys e criar um novo dict. Todos os values serão definidos com o default value fornecido:

>>> new_dict = dict.fromkeys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'], 'fill in hex color here')

{'Grassy Green': 'fill in hex color here',
 'Purple Mountains Majesty': 'fill in hex color here',
 'Misty Mountain Pink': 'fill in hex color here'}

Remover e retornar um par (chave, valor) com .popitem()

.popitem() remove e retorna um único par (key, value) de um dicionário. Os pares são retornados na ordem último a entrar, primeiro a sair (LIFO). Se o dicionário estiver vazio, chamar popitem() vai lançar um KeyError:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}
>>> palette_I.popitem()
('Misty Mountain Pink', '#f9c5bd')

>>> palette_I.popitem()
('Purple Mountains Majesty', '#8076a3')

>>> palette_I.popitem()
('Grassy Green', '#9bc400')

# All (key, value) pairs have been removed.
>>> palette_I.popitem()
Traceback (most recent call last):
  line 1, in <module>
    palette_I.popitem()
KeyError: 'popitem(): dictionary is empty'

Iterar sobre as entradas de um dicionário por meio de visões

Os métodos .keys(), .values() e .items() retornam visões iteráveis de um dicionário.

Essas visões podem ser usadas para percorrer as entradas facilmente sem alterá-las. As visões também são dinâmicas: quando os dados do dicionário subjacente mudam, o view object associado refletirá a mudança:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

# Using .keys() returns a list of keys.
>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'])

# Using .values() returns a list of values.
>>> palette_I.values()
dict_values(['#9bc400', '#8076a3', '#f9c5bd'])

# Using .items() returns a list of (key, value) tuples.
>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', '#8076a3'), ('Misty Mountain Pink', '#f9c5bd')])

# Views are dynamic.  Changing values in the dict 
# changes all of the associated views.
>>> palette_I['Purple Mountains Majesty'] = (128, 118, 163)
>>> palette_I['Deep Red'] = '#932432'

>>> palette_I.values()
dict_values(['#9bc400', (128, 118, 163), '#f9c5bd', '#932432'])

>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink', 'Deep Red'])

>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', (128, 118, 163)), ('Misty Mountain Pink', '#f9c5bd'), ('Deep Red', '#932432')])

Mais sobre .keys(), .values() e .items()

No Python 3.7+, os dicts preservam a ordem em que as entradas são inseridas, permitindo a iteração primeiro a entrar, primeiro a sair (FIFO) ao usar .keys(), .values() ou .items().

No Python 3.8+, as visões também são reversíveis. Isso permite iterar sobre chaves, valores ou pares (key, value) na ordem último a entrar, primeiro a sair (LIFO) usando reversed(<dict>.keys()), reversed(<dict>.values()) ou reversed(<dict>.items()):

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}
>>> for item in palette_II.items():
...     print(item)
...
('Factory Stone Purple', '#7c677f')
('Green Treeline', '#478559')
('Purple baseline', '#161748')

>>> for item in reversed(palette_II.items()):
...     print(item)
...
('Purple baseline', '#161748')
('Green Treeline', '#478559')
('Factory Stone Purple', '#7c677f')

Combinar dicionários com .update()

<dict_one>.update(<dict_two>) pode ser usado para combinar dois dicionários. Esse método pega os pares (key,value) de <dict_two> e os escreve em <dict_one>:

>>> palette_I = {'Grassy Green': '#9bc400',
                 'Purple Mountains Majesty': '#8076a3',
                  'Misty Mountain Pink': '#f9c5bd'}
>>> palette_II = {'Factory Stone Purple': '#7c677f',
                  'Green Treeline': '#478559',
                  'Purple Baseline': '#161748'}

>>> palette_I.update(palette_II)

# Note that new items from palette_II are added.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Factory Stone Purple': '#7c677f', 'Green Treeline': '#478559', 'Purple Baseline': '#161748'}

Onde as chaves dos dois dicionários se sobrepõem, o value em dict_one será sobrescrito pelo value correspondente de dict_two:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd', 
                 'Factory Stone Purple': '#7c677f', 
                 'Green Treeline': '#478559', 
                 'Purple baseline': '#161748'}
                   
>>> palette_III = {'Grassy Green': (155, 196, 0), 
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> palette_I.update(palette_III)

# Overlapping values in palette_I are replaced with 
# values from palette_III
>>> palette_I
{'Grassy Green': (155, 196, 0),
  'Purple Mountains Majesty': (128, 118, 163), 
  'Misty Mountain Pink': (249, 197, 189), 
  'Factory Stone Purple': '#7c677f', 
  'Green Treeline': '#478559', 'Purple baseline': '#161748'}

Mesclar ou atualizar dicionários usando os operadores de união (| e |=)

O Python 3.9 introduz uma forma diferente de mesclar dicts: os operadores de union. dict_one | dict_two vai criar um novo dicionário, composto pelos pares (key, value) de dict_one e dict_two. Quando os dois dicionários compartilham chaves, os valores de dict_two têm precedência.

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}

>>> new_dict = palette_I | palette_II
>>> new_dict
...
{'Grassy Green': '#9bc400',
 'Purple Mountains Majesty': '#8076a3',
 'Misty Mountain Pink': '#f9c5bd',
 'Factory Stone Purple': '#7c677f',
 'Green Treeline': '#478559',
 'Purple baseline': '#161748'}

dict_one |= other se comporta de forma semelhante a <dict_one>.update(<other>), mas, nesse caso, other pode ser tanto um dict quanto um iterável de pares (key, value):

>>> palette_III = {'Grassy Green': (155, 196, 0),
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> new_dict |= palette_III
>>> new_dict
...
{'Grassy Green': (155, 196, 0),
'Purple Mountains Majesty': (128, 118, 163),
'Misty Mountain Pink': (249, 197, 189),
'Factory Stone Purple': '#7c677f',
'Green Treeline': '#478559',
'Purple baseline': '#161748'}

Ordenar um dicionário

Os dicionários não têm um método de ordenação embutido. No entanto, é possível ordenar uma visão de dict usando a função embutida sorted() com .items(). A visão ordenada pode então ser usada para criar um novo dicionário. A menos que uma chave de ordenação seja especificada, a ordenação padrão é feita sobre as keys do dicionário.

# Default ordering for a dictionary is last in, first out (LIFO).
>>> color_palette = {'Grassy Green': '#9bc400', 
                    'Purple Mountains Majesty': '#8076a3', 
                    'Misty Mountain Pink': '#f9c5bd', 
                    'Factory Stone Purple': '#7c677f', 
                    'Green Treeline': '#478559', 
                    'Purple baseline': '#161748'}
 
 
# The default sort order for a dictionary uses the keys.
>>> sorted_palette = dict(sorted(color_palette.items()))
>>> sorted_palette
{'Factory Stone Purple': '#7c677f',
 'Grassy Green': '#9bc400',
 'Green Treeline': '#478559',
 'Misty Mountain Pink': '#f9c5bd',
 'Purple Mountains Majesty': '#8076a3',
 'Purple baseline': '#161748'}


# A sort key can be provided in the form
# of an anonymous function (lambda). 
>>> value_sorted_palette = dict(sorted(color_palette.items(), key=lambda color: color[1]))
>>> value_sorted_palette
{'Purple baseline': '#161748',
 'Green Treeline': '#478559',
 'Factory Stone Purple': '#7c677f',
 'Purple Mountains Majesty': '#8076a3',
 'Grassy Green': '#9bc400',
 'Misty Mountain Pink': '#f9c5bd'}

Transpor chaves e valores de um dicionário

Trocar chaves e valores de forma confiável em um dicionário dá um pouco de trabalho, mas pode ser feito com um loop usando dict.items() ou em uma compreensão de dicionário. A troca segura pressupõe que as chaves e os valores do dict sejam ambos hashable.

color_reference = {'Purple Mountains Majesty': '#8076a3',
                   'Misty Mountain Pink': '#f9c5bd',
                   'Factory Stone Purple': '#7c677f',
                   'Green Treeline': '#478559',
                   'Purple baseline': '#161748'}

# Creating a new dictionary to hold the swapped entries.
>>> swapped_color_reference = {}

# Iterating through the dictionary, using values as keys.
>>> for key, value in color_reference.items():
...     swapped_color_reference[value] = key

>>> swapped_color_reference
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

 
# A dictionary comprehension can also be used to swap entries.
>>> swapped = {value: key for key, value in
               color_reference.items()}
>>> swapped
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

Se os valores armazenados no dict não forem únicos, verificações extras se tornam necessárias antes que a troca de chave e valor possa acontecer:

# Things become more complicated if there are duplicates in 
# potential key values.This dict is arranged by hex, RGB, and HSL
# keys, but values repeat.
>>> extended_colors = {'#8076a3': 'Purple Mountains Majesty',
                       (128, 118, 163): 'Purple Mountains Majesty',
                       (21, 28, 0, 36): 'Purple Mountains Majesty',
                       '#f9c5bd': 'Misty Mountain Pink',
                       (249, 197, 189): 'Misty Mountain Pink',
                       (0, 21, 24, 2): 'Misty Mountain Pink',
                       '#7c677f': 'Factory Stone Purple',
                       (124, 103, 127): 'Factory Stone Purple',
                       (2, 19, 0, 50): 'Factory Stone Purple',
                       '#478559': 'Green Treeline',
                       (71, 133, 89): 'Green Treeline',
                       (47, 0, 33, 48): 'Green Treeline'}
                                
# New empty dictionary for holding swapped entries.
>>> consolidated_colors = {}

# Iterating over (key, value) pairs using .items()
>>> for key, value in extended_color_reference.items():
...    if value in consolidated_colors: # <--Check if key has already been created.
...        consolidated_colors[value].append(key)
...    else:
...        consolidated_colors[value] = [key]  # <--Create a value list with the former key in it.

>>> consolidated_colors
{'Purple Mountains Majesty': ['#8076a3', (128, 118, 163), (21, 28, 0, 36)],
 'Misty Mountain Pink': ['#f9c5bd', (249, 197, 189), (0, 21, 24, 2)],
 'Factory Stone Purple': ['#7c677f', (124, 103, 127), (2, 19, 0, 50)],
 'Green Treeline': ['#478559', (71, 133, 89), (47, 0, 33, 48)]}

Para uma explicação detalhada sobre dicionários e métodos para trabalhar com eles, o tutorial oficial e a referência oficial da biblioteca são ótimos pontos de partida.

O Real Python e o Finxter também têm artigos bem completos sobre dicionários em Python.

Para saber mais sobre ordenação, veja o Sorting HOW TO na documentação do Python.

Saiba mais

Editar via GitHub O link abre em uma nova janela ou aba

Aprenda Métodos de dicionário

A prática está bloqueada

Desbloqueie mais 3 exercícios para praticar Métodos de dicionário