Comment parcourir un dictionnaire en Python

17 septembre 2021 Hibou Gourou

Comprendre comment parcourir un dictionnaire Python est précieux. Cette technique vous permet de lire, de manipuler et de sortir le contenu d'un dictionnaire. Le bouclage en Python est facile. Mais les débutants peuvent trouver cela un peu déroutant, surtout lorsqu'ils l'utilisent avec un itérable plus complexe tel qu'un dictionnaire.

Voici quelques-unes des façons dont vous pouvez gérer un dictionnaire Python à l'aide de boucles.

Parcourir les clés et les valeurs

Un dictionnaire en Python contient des paires clé-valeur. Vous pouvez parcourir ses clés en utilisant la méthode keys() :

 myDict = {"A" : 2, "B" : 5, "C" : 6}
 for i in myDict.keys():
 print("Key"+" "+i)
 Output:
 Key A
 Key B
 Key C

Cependant, le code ci-dessus est légèrement plus détaillé que nécessaire. Vous pouvez accéder aux clés en les appelant directement depuis myDict sans utiliser myDict.keys() .

C'est parce qu'une boucle Python for sélectionne les clés par défaut lorsqu'elle voit un dictionnaire. Vous pouvez donc écrire le code ci-dessus comme ceci à la place :

 for key in myDict:
 print("Key"+ " " +key)
 Output:
 Key A
 Key B
 Key C

Pour accéder aux valeurs, utilisez la méthode values() correspondante :

 myDict = {"A" : 2, "B" : 5, "C" : 6}
 for i in myDict.values():
 print(i)
 Output:
 2
 5
 6

De même, vous pouvez accéder directement aux valeurs à l'aide de leurs clés :

 for key in myDict:
 print(myDict[key])
 Output:
 2
 5
 6

En itérant dans un dictionnaire, vous pouvez accéder à ses clés et à ses valeurs en même temps. Vous pouvez le faire de deux manières.

La première méthode consiste à parcourir le dictionnaire et à accéder aux valeurs à l'aide de la méthode dict[key] . Imprimez ensuite chaque paire clé-valeur dans la boucle :

 for key in myDict:
 print(key, "|", myDict[key])
 Output:
 A | 2
 B | 5
 C | 6

Alternativement, vous pouvez accéder simultanément aux clés et aux valeurs à l'aide de la méthode items() :

 for key, value in myDict.items():
 print(key, "|", value)
 Output:
 A | 2
 B | 5
 C | 6

Parfois, vous souhaiterez peut-être afficher le résultat dans l'ordre inverse. Voici comment procéder à l'aide de la fonction sorted() :

 myDict = {"A" : 2, "B" : 5, "C" : 6}
 for key, value in sorted(myDict.items(), reverse=True):
 print(key, "|", value)
 Output:
 C | 6
 B | 5
 A | 2

Conversion d'un dictionnaire en liste

Convertir un dictionnaire en liste par itération est aussi simple que transformer une liste en dictionnaire .

Vous pouvez créer une liste contenant un tuple individuel pour chaque paire clé-valeur :

 myDict = {"A" : "MUO", "B" : "Google", "C" : "Python"}
 myList = []
 for key, value in myDict.items():
 myList.append((key, value))
 print(myList)
 Output: [('A', 'MUO'), ('B', 'Google'), ('C', 'Python')]

Ou vous pouvez convertir le dictionnaire en une liste imbriquée de paires clé-valeur :

 myDict = {"A" : "MUO", "B" : "Google", "C" : "Python"}
 myList = []
 for key, value in myDict.items():
 myList.append([key, value])
 print(myList)
 Output: [['A', 'MUO'], ['B', 'Google'], ['C', 'Python']]

Et si vous souhaitez transformer un dictionnaire en une liste étirée ou aplatie :

 myDict = {"A" : "MUO", "B" : "Google", "C" : "Python"}
 myList = []
 for key, value in myDict.items():
 myList+= key, value
 print(myList)
 Output: ['A', 'MUO', 'B', 'Google', 'C', 'Python']

Addition des valeurs dans un dictionnaire

Il est facile de sommer toutes les valeurs d'un dictionnaire à l'aide d'une boucle for :

 myDict = {"A":6, "B":7, "C":9}
 g = 0 # initilize a variable to store the running total
 for i in myDict.values():
 g += i # add each value to the total
 print(g)
 Output: 22

C'est un équivalent itératif à l'utilisation de la fonction sum() qui est elle-même un itérateur. Vous pouvez donc ajouter les valeurs en utilisant sum() au lieu de boucler comme vous l'avez fait ci-dessus :

 summedValues = sum(myDict.values())
 print(summedValues)
 Output: 22

Boucle dans un dictionnaire Python imbriqué

Un dictionnaire imbriqué peut être un peu déroutant à parcourir au début. Mais c'est aussi simple que d'en parcourir un régulier.

Le code ci-dessous, par exemple, affiche le contenu de chaque liste dans le dictionnaire :

 myDict = {"A" : [1, 2, 3], "B" : [4, 5, 6]}
 for i in myDict.keys():
 print(myDict[i])
 Output:
 [1, 2, 3]
 [4, 5, 6]

Comme c'est le cas dans un dictionnaire normal, boucler les éléments entiers génère toutes les paires clé-valeur dans des tuples individuels :

 myDict = {"A" : [1, 2, 3], "B" : [4, 5, 6]}
 for i in myDict.items():
 print(i)
 Output:
 ('A', [1, 2, 3])
 ('B', [4, 5, 6])

Connexes : Dictionnaire Python : comment l'utiliser pour écrire un meilleur code

Vous pouvez également voir des valeurs spécifiques dans un dictionnaire contenant d'autres dictionnaires. Mais gardez à l'esprit que les valeurs d'un dictionnaire complexe sont les éléments d'autres dictionnaires qu'il contient. Essentiellement, un dictionnaire complexe contient des clés parent et enfant.

Sortons les valeurs dans le dictionnaire complexe ci-dessous pour voir comment cela fonctionne :

 complexArray = {
 "Detail" : {
 "Name" : "Idowu",
 "Logs" : 20,
 "isAdmin" : True
 },
 "Activities" : {
 "Inputs" : 14,
 "Input Type" : "Video"
 }
 }
 for value in complexArray.values():
 print(value)
 Output:
 {'Name': 'Idowu', 'Logs': 20, 'isAdmin': True}
 {'Inputs': 14, 'Input Type': 'Video'}

En utilisant cet aperçu, vous pouvez imprimer des valeurs spécifiques du dictionnaire ci-dessus.

Pour afficher les valeurs de Detail , par exemple :

 for value in complexArray["Detail"].values():
 print(value)
 Output:
 Idowu
 20
 True

En utilisant une boucle for imbriquée, vous pouvez voir toutes les valeurs de toutes les clés enfants :

 for value in complexArray.values():
 for i in value.values(): # get the values of each key in the child dictionaries
 print(i)
 Output:
 Idowu
 20
 True
 14
 Video

Indépendamment de leur dictionnaire parent, l'itération ci-dessus génère toutes les valeurs enfants du dictionnaire imbriqué.

Modification des éléments du dictionnaire

Étant donné qu'un dictionnaire est modifiable, vous pouvez modifier son contenu à votre guise tout en le parcourant.

Par exemple, vous pouvez échanger les valeurs des clés et insérer la sortie dans un nouveau dictionnaire :

 myDict = {"A" : "MUO", "B" : "Google", "C" : "Python"}
 swappedDict = {}
 for key, value in myDict.items():
 swappedDict[value] = key
 print(swappedDict)
 Output: {'MUO': 'A', 'Google': 'B', 'Python': 'C'}

Vous pouvez également réaliser ce qui précède en utilisant la boucle for dans une compréhension de dictionnaire :

 swappedDict = {value:key for key, value in myDict.items()}
 print(swappedDict)
 Output: {'MUO': 'A', 'Google': 'B', 'Python': 'C'}

Vous pouvez également supprimer des éléments spécifiques d'un dictionnaire tout en le parcourant. C'est un moyen assez pratique pour supprimer les doublons.

L'exemple de code ci-dessous supprime les éléments dupliqués et en réinsère un après avoir parcouru le tableau :

 myDict = {"A" : "MUO", "B" : "Google", "C" : "Python", "C" : "Python"}
 for key in list(myDict.keys()):
 if key == 'C':
 del myDict[key]
 myDict[key]="Python"
 print(myDict)
 Output: {'A': 'MUO', 'B': 'Google', 'C': 'Python'}

Jouez avec les dictionnaires Python

Un dictionnaire Python est un outil essentiel pour gérer les données en mémoire. Ainsi, une compréhension de base de la structure des données du dictionnaire, y compris la façon de la parcourir et d'obtenir ce que vous voulez, vous aide dans des scénarios réels.

Et parce que vous pouvez personnaliser ce qui se passe dans une boucle Python, cela vous permet de manipuler votre sortie. Néanmoins, l'itération dans un dictionnaire Python est facile une fois que vous comprenez les concepts de base de la boucle Python.