Parcourir les dictionnaires

Les dictionnaires Python stockent des données sous forme de paires clé-valeur, et vous aurez régulièrement besoin de les parcourir — pour afficher chaque entrée, filtrer des données, transformer des valeurs ou construire de nouvelles structures. Ce chapitre couvre toutes les techniques standard pour itérer sur un dictionnaire, explique quelle méthode utiliser dans chaque situation, et met en évidence l'erreur la plus fréquente : modifier un dictionnaire pendant qu'on l'itère.

Si vous débutez avec les dictionnaires, lisez d'abord Python Dictionaries. Pour la syntaxe générale des boucles, consultez Python For Loops.

Parcourir les clés

Lorsque vous utilisez une boucle for directement sur un dictionnaire, Python itère par défaut sur ses clés.

Parcourir les clés d'un dictionnaire

person = {"name": "Alice", "age": 30, "city": "Berlin"}

for key in person:
    print(key)

Résultat :

name
age
city

Appeler .keys() est équivalent et rend l'intention plus explicite :

Une fois que vous disposez de la clé, vous pouvez rechercher sa valeur dans la boucle :

person = {"name": "Alice", "age": 30, "city": "Berlin"}

for key in person:
    print(key, "->", person[key])

Résultat :

name -> Alice
age -> 30
city -> Berlin

Quand utiliser .keys()

Utilisez la forme simple for key in d lorsque vous n'avez besoin que des clés. Utilisez d.keys() explicitement lorsque vous souhaitez tester l'appartenance ("name" in d.keys()) ou passer la vue à une autre fonction. Pour un simple test d'appartenance, if "name" in d est toutefois plus rapide.

Parcourir les valeurs

Utilisez .values() lorsque vous n'avez besoin que des valeurs et que les clés ne vous intéressent pas.

Parcourir les valeurs d'un dictionnaire

scores = {"math": 92, "science": 87, "english": 95}

for score in scores.values():
    print(score)

Résultat :

92
87
95

Un cas d'utilisation courant est le calcul d'un résumé sur toutes les valeurs :

scores = {"math": 92, "science": 87, "english": 95}

total = sum(scores.values())
average = total / len(scores)
print(f"Average score: {average:.1f}")

Résultat :

Average score: 91.3

Parcourir les paires clé-valeur avec .items()

.items() retourne chaque entrée sous forme de tuple (key, value). Vous pouvez déstructurer le tuple directement en deux variables. Il s'agit de la méthode d'itération la plus polyvalente, celle que vous utiliserez le plus souvent.

Parcourir les paires clé-valeur

person = {"name": "Alice", "age": 30, "city": "Berlin"}

for key, value in person.items():
    print(f"{key}: {value}")

Résultat :

name: Alice
age: 30
city: Berlin

Filtrer pendant le parcours

Combinez une boucle for avec une condition if pour traiter uniquement les entrées qui vous intéressent.

Afficher uniquement les articles en stock

inventory = {"apples": 5, "bananas": 0, "oranges": 3, "grapes": 0}

print("In stock:")
for item, qty in inventory.items():
    if qty > 0:
        print(f"  {item}: {qty}")

Résultat :

In stock:
  apples: 5
  oranges: 3

Trier les entrées d'un dictionnaire

Python 3.7+ garantit que les dictionnaires conservent l'ordre d'insertion. Si vous avez besoin d'un ordre différent, triez les clés ou les éléments avant la boucle — le dictionnaire lui-même n'est pas modifié.

Trier par clé (ordre alphabétique)

book = {"banana": 7, "apple": 3, "cherry": 12}

for fruit in sorted(book):
    print(f"{fruit}: {book[fruit]}")

Résultat :

apple: 3
banana: 7
cherry: 12

Trier par valeur

Passez une fonction key à sorted() pour contrôler le critère de tri.

book = {"banana": 7, "apple": 3, "cherry": 12}

for fruit, count in sorted(book.items(), key=lambda item: item[1], reverse=True):
    print(f"{fruit}: {count}")

Résultat :

cherry: 12
banana: 7
apple: 3

Utiliser enumerate() lors du parcours

Enveloppez .items() dans enumerate() pour obtenir un index courant en plus de chaque paire clé-valeur.

colors = {"red": "#FF0000", "green": "#00FF00", "blue": "#0000FF"}

for index, (name, hex_code) in enumerate(colors.items()):
    print(f"{index}: {name} -> {hex_code}")

Résultat :

0: red -> #FF0000
1: green -> #00FF00
2: blue -> #0000FF

Compréhensions de dictionnaire

Une compréhension de dictionnaire construit un nouveau dictionnaire à partir d'un existant en une seule expression. La syntaxe ressemble aux compréhensions de liste, mais utilise des accolades et un deux-points entre la clé et la valeur.

Appliquer une réduction de 10 % à chaque prix

prices = {"apple": 1.20, "banana": 0.50, "orange": 0.80}

discounted = {item: round(price * 0.9, 2) for item, price in prices.items()}
print(discounted)

Résultat :

{'apple': 1.08, 'banana': 0.45, 'orange': 0.72}

Vous pouvez ajouter une condition de filtre à la fin :

Conserver uniquement les étudiants ayant obtenu 90 ou plus

students = {
    "Alice": {"grade": "A", "score": 95},
    "Bob":   {"grade": "B", "score": 82},
    "Carol": {"grade": "A", "score": 91},
}

top_students = {name: info for name, info in students.items() if info["score"] >= 90}
print(top_students)

Résultat :

{'Alice': {'grade': 'A', 'score': 95}, 'Carol': {'grade': 'A', 'score': 91}}

Parcourir les dictionnaires imbriqués

Lorsque les valeurs sont elles-mêmes des dictionnaires (voir Nested Dictionaries), accédez aux entrées internes avec un second indice ou une seconde boucle.

Afficher tous les champs de chaque étudiant

students = {
    "Alice": {"grade": "A", "score": 95},
    "Bob":   {"grade": "B", "score": 82},
    "Carol": {"grade": "A", "score": 91},
}

for name, info in students.items():
    print(f"{name}: grade={info['grade']}, score={info['score']}")

Résultat :

Alice: grade=A, score=95
Bob: grade=B, score=82
Carol: grade=A, score=91

Modifier un dictionnaire pendant le parcours — l'erreur classique

Vous ne pouvez pas ajouter ou supprimer des clés d'un dictionnaire pendant que vous l'itérez. Python lève immédiatement une RuntimeError :

d = {"a": 1, "b": 2, "c": 3}

# This raises RuntimeError: dictionary changed size during iteration
for key in d:
    if d[key] == 2:
        del d[key]

La méthode sûre consiste à collecter d'abord les clés à supprimer, puis à les effacer après la boucle :

Suppression sécurisée après le parcours

config = {"debug": True, "verbose": True, "timeout": 30}

keys_to_remove = [k for k, v in config.items() if v is True]
for k in keys_to_remove:
    del config[k]

print(config)

Résultat :

{'timeout': 30}

Le même principe s'applique à l'ajout de clés : collectez les nouvelles paires, puis mettez à jour le dictionnaire avec update() ou par affectation directe après la boucle.

Choisir la bonne méthode

Pour l'ensemble complet des opérations sur les dictionnaires, consultez Python Dictionary Methods et Copy Dictionaries.

Pratique