Méthodes de dictionnaire en

À propos de Méthodes de dictionnaire

La classe dict de Python fournit de nombreuses méthodes utiles pour manipuler les dictionnaires. Certaines ont été présentées dans le concept sur les dict. On en couvre ici quelques autres, ainsi que quelques techniques pour parcourir et manipuler les dictionnaires.

• <dict>.setdefault() ajoute automatiquement des clés sans lever de KeyError.
• <dict>.fromkeys(<iterable>, <default value>) crée un nouveau dict à partir d'un nombre quelconque d'itérables.
• <dict>.keys(), <dict>.values() et <dict>.items() fournissent des itérateurs pratiques.
• sorted(<dict>.items()) permet de réordonner facilement les entrées d'un dict.
• <dict_one>.update(<dict_two>) met à jour un dict avec les valeurs communes d'un autre dict.
• <dict> | <other_dict> et <dict> |= <other_dict> fusionnent ou mettent à jour deux dict grâce à des opérateurs.
• reversed(<dict>.keys()), reversed(<dict>.values()) ou reversed(<dict>.items()) produisent des vues inversées.
• <dict>.popitem() supprime et renvoie une paire (key, value).

setdefault() pour une insertion sans erreur

Le concept sur les dictionnaires a déjà montré que <dict>.get(<key>, <default value>) renvoie une value existante ou la default value si une key ne figure pas dans le dictionnaire, ce qui évite un KeyError. C'est bien pratique quand on préfère se passer d'une gestion d'erreur supplémentaire, mais qu'on ne peut pas compter sur la présence de la key recherchée.

Pour une insertion tout aussi « sûre » (sans KeyError), il existe la méthode <dict>.setdefault(<key>, <default value>). <dict>.setdefault(<key>, <default value>) renvoie la value si la key se trouve dans le dictionnaire. Si la clé n'est pas trouvée, elle insère la paire (key, default value) et renvoie la default value à utiliser.

>>> 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() pour remplir un dictionnaire à partir d'un itérable

Pour remplir rapidement un dictionnaire avec différentes keys et des valeurs par défaut, la méthode de classe fromkeys(<iterable>, <default value>) parcourt un itérable de keys et crée un nouveau dict. Toutes les values sont définies à la default value fournie :

>>> 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'}

Supprime et renvoie une paire (key, value) avec .popitem()

.popitem() supprime et renvoie une seule paire (key, value) d'un dictionnaire. Les paires sont renvoyées dans l'ordre dernier entré, premier sorti (Last-in-First-out, LIFO). Si le dictionnaire est vide, appeler popitem() lève un 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'

Parcours les entrées d'un dictionnaire grâce aux vues

Les méthodes .keys(), .values() et .items() renvoient des vues itérables d'un dictionnaire.

Ces vues permettent de parcourir facilement les entrées sans les modifier. Les vues sont aussi dynamiques : quand les données sous-jacentes du dictionnaire changent, l'objet view object associé reflète le changement :

>>> 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')])

Pour en savoir plus sur .keys(), .values() et .items()

À partir de Python 3.7, les dicts conservent l'ordre dans lequel les entrées sont insérées, ce qui permet une itération premier entré, premier sorti (FIFO) avec .keys(), .values() ou .items().

À partir de Python 3.8, les vues sont aussi réversibles. Cela permet de parcourir les clés, les valeurs ou les paires (key, value) dans l'ordre dernier entré, premier sorti (LIFO) en utilisant 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')

Combine des dictionnaires avec .update()

<dict_one>.update(<dict_two>) permet de combiner deux dictionnaires. Cette méthode prend les paires (key,value) de <dict_two> et les écrit dans <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'}

Quand des clés se recoupent dans les deux dictionnaires, la value de dict_one est écrasée par la value correspondante 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'}

Fusionne ou mets à jour des dictionnaires avec les opérateurs d'union (| et |=)

Python 3.9 introduit un autre moyen de fusionner des dicts : les opérateurs d'union. dict_one | dict_two crée un nouveau dictionnaire, constitué des paires (key, value) de dict_one et de dict_two. Quand les deux dictionnaires partagent des clés, les valeurs de dict_two l'emportent.

>>> 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 comporte comme <dict_one>.update(<other>), mais ici, other peut être soit un dict, soit un itérable de paires (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'}

Trie un dictionnaire

Les dictionnaires n'ont pas de méthode de tri intégrée. Cependant, il est possible de trier une vue de dict avec la fonction intégrée sorted() appliquée à .items(). La vue triée peut ensuite servir à créer un nouveau dictionnaire. Sauf si une clé de tri est précisée, le tri par défaut porte sur les keys du dictionnaire.

# 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'} 

Transpose les clés et les valeurs d'un dictionnaire

Échanger les clés et les valeurs d'un dictionnaire de façon fiable demande un peu de travail, mais on peut y arriver avec un loop qui utilise dict.items(), ou dans une compréhension de dictionnaire. Un échange sûr suppose que les clés et les valeurs du dict soient toutes deux hachables.

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'}

Si les valeurs stockées dans le dict ne sont pas uniques, des vérifications supplémentaires s'imposent avant de pouvoir échanger clés et valeurs :

# 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)]}  

Pour une explication détaillée des dictionnaires et des méthodes pour les manipuler, le tutoriel officiel et la référence officielle de la bibliothèque sont d'excellents points de départ.

Real Python et Finxter proposent aussi des articles très complets sur les dictionnaires Python.

Pour en savoir plus sur le tri, consulte le guide Sorting HOW TO de la documentation Python.