En Python, les méthodes keys() et items() des dictionnaires dict peuvent être utilisées pour effectuer des opérations d’ensemble sur des clés et des paires clé-valeur. Par exemple, vous pouvez générer un dictionnaire composé d’éléments (clés et valeurs) communs à plusieurs dictionnaires.
Cet article décrit le contenu suivant.
- Les méthodes keys() et items() de dict
- Extraire les clés communes à plusieurs dictionnaires : Intersection &
- Extrayez toutes les clés de plusieurs dictionnaires : Union |
- Extraire les clés contenues dans un seul dictionnaire parmi plusieurs : Différence symétrique ^
Utilisez les deux dictionnaires suivants comme exemples.
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'b': 2, 'c': 4, 'd': 5}
Les méthodes keys() et items() de dict
Le dictionnaire a des méthodes keys() et items().
keys() renvoie la vue des clés, items() renvoie la vue des tuples clé-valeur (clé, valeur).
print(list(d1.keys()))
# ['a', 'b', 'c']
print(type(d1.keys()))
# <class 'dict_keys'>
print(list(d1.items()))
# [('a', 1), ('b', 2), ('c', 3)]
print(type(d1.items()))
# <class 'dict_items'>
Ce sont respectivement dict_keys et dict_items, et prennent en charge les opérations d’ensemble comme set.
Le dictionnaire a également une méthode de valeurs qui renvoie une vue des valeurs, mais les opérations d’ensemble ne sont pas prises en charge car les valeurs peuvent se chevaucher.
Dans ce qui suit, des exemples d’opérations d’ensemble utilisant les méthodes keys() et items() sont présentés.
Les clés communes à plusieurs dictionnaires peuvent être extraites avec la méthode keys() et l’opérateur &.
intersection_keys = d1.keys() & d2.keys()
print(intersection_keys)
# {'c', 'b'}
Le résultat d’une opération d’ensemble est de type ensemble. Il en va de même pour les exemples suivants.
print(type(intersection_keys))
# <class 'set'>
Dans le cas de items(), les éléments ayant à la fois des clés et des valeurs en commun sont extraits. Les éléments avec uniquement la clé ou uniquement la valeur en commun sont exclus.
intersection_items = d1.items() & d2.items()
print(intersection_items)
# {('b', 2)}
Vous pouvez générer un nouveau dictionnaire en passant un ensemble de tuples (clé, valeur) (= le résultat de l’opération d’ensemble de items()) à dict().
intersection_dict = dict(d1.items() & d2.items())
print(intersection_dict)
# {'b': 2}
print(type(intersection_dict))
# <class 'dict'>
Toutes les clés de plusieurs dictionnaires, c’est-à-dire les clés contenues dans au moins un des plusieurs dictionnaires, peuvent être extraites avec la commande | opérateur.
union_keys = d1.keys() | d2.keys()
print(union_keys)
# {'d', 'a', 'b', 'c'}
Dans le cas de items(), les éléments avec des clés communes mais des valeurs différentes sont extraits séparément.
union_items = d1.items() | d2.items()
print(union_items)
# {('d', 5), ('c', 4), ('a', 1), ('b', 2), ('c', 3)}
Comme dans cet exemple, s’il y a des éléments avec une clé commune mais des valeurs différentes, un seul d’entre eux est retenu lors de la génération d’un dictionnaire à partir de l’ensemble. Il n’est pas possible de spécifier quelle valeur doit être conservée.
union_dict = dict(d1.items() | d2.items())
print(union_dict)
# {'d': 5, 'c': 3, 'a': 1, 'b': 2}
Les clés contenues dans un seul des multiples dictionnaires peuvent être extraites avec l’opérateur ^.
symmetric_difference_keys = d1.keys() ^ d2.keys()
print(symmetric_difference_keys)
# {'d', 'a'}
Dans le cas de items(), comme avec le | , les éléments avec des clés communes mais des valeurs différentes sont extraits séparément.
symmetric_difference_items = d1.items() ^ d2.items()
print(symmetric_difference_items)
# {('d', 5), ('c', 4), ('a', 1), ('c', 3)}
Comme dans cet exemple, s’il y a des éléments avec une clé commune mais des valeurs différentes, un seul d’entre eux est retenu lors de la génération d’un dictionnaire à partir de l’ensemble. Il n’est pas possible de spécifier quelle valeur doit être conservée.
symmetric_difference_dict = dict(d1.items() ^ d2.items())
print(symmetric_difference_dict)
# {'d': 5, 'c': 3, 'a': 1}
Vous pouvez également utiliser l’opérateur – pour obtenir la différence définie.
difference_keys = d1.keys() - d2.keys()
print(difference_keys)
# {'a'}
difference_items = d1.items() - d2.items()
print(difference_items)
# {('c', 3), ('a', 1)}
difference_dict = dict(d1.items() - d2.items())
print(difference_dict)
# {'c': 3, 'a': 1}