Dictionnaires Python : créer, accéder, mettre à jour et itérer un dict

Un dictionnaire est une table de correspondance

Les listes sont indexées par position. Les dictionnaires sont indexés par clé — généralement une chaîne ou un nombre — et chaque clé correspond à une valeur. Ce seul changement ouvre une énorme catégorie de programmes : inventaires, configs, payloads JSON, profils utilisateurs, caches.

prices = {
    "apple": 0.50,
    "bread": 2.00,
    "milk": 1.20,
}

print(prices["apple"])
print(prices["bread"])

Les clés et les valeurs peuvent être à peu près n'importe quoi. Les clés doivent être hashables (donc : nombres, chaînes, tuples ; pas listes ni autres dicts). Les valeurs n'ont aucune restriction — un dict peut contenir n'importe quoi, y compris d'autres dicts ou listes.

Créer des dictionnaires

Plusieurs façons, chacune avec sa place :

# Littéral avec accolades
user = {"name": "Rosa", "age": 30, "city": "Lisbon"}
print(user)

# Dict vide, construit au fil du temps
counts = {}
counts["a"] = 1
counts["b"] = 2
print(counts)

# À partir d'une liste de paires (clé, valeur)
pairs = [("one", 1), ("two", 2), ("three", 3)]
mapping = dict(pairs)
print(mapping)

# Avec des arguments nommés
config = dict(host="localhost", port=8080, debug=True)
print(config)

Lire des valeurs

Deux façons, et le choix compte :

prices = {"apple": 0.50, "bread": 2.00}

# [] — indexation directe. KeyError si manquant.
print(prices["apple"])

# .get() — renvoie None (ou un défaut) si manquant.
print(prices.get("milk"))              # None
print(prices.get("milk", 0.00))        # 0.00

Choisis selon l'intention :

• Utilise [] quand la clé doit être là. Si elle n'y est pas, c'est un bug et tu veux l'erreur bruyante.
• Utilise .get() quand « pas présent » est un cas valide. Ça te permet d'écrire des valeurs par défaut sans try/except.

Ajouter, mettre à jour, supprimer

Affecter une clé la crée ou la met à jour :

prices = {"apple": 0.50, "bread": 2.00}

prices["milk"] = 1.20        # nouvelle clé
prices["apple"] = 0.60       # clé existante, écrasée

print(prices)

del prices["bread"]          # retire une clé ; KeyError si manquante
print(prices)

gone = prices.pop("apple")   # retire et renvoie ; accepte un défaut
print("was:", gone, "now:", prices)

# pop avec un défaut pour qu'il ne lève pas d'exception
prices.pop("missing", None)

update() fusionne un autre dict ou un itérable de paires :

settings = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

settings.update(overrides)
print(settings)

Les clés partagées dans overrides écrasent celles de settings.

Vérifier une clé

in vérifie les clés, pas les valeurs :

user = {"name": "Rosa", "age": 30}

print("name" in user)      # True
print("email" in user)     # False
print("Rosa" in user)      # False — c'est une valeur, pas une clé

Pour vérifier spécifiquement les valeurs, utilise user.values() :

print(30 in user.values())

Comment itérer un dictionnaire

Tu as trois vues sur lesquelles boucler :

scores = {"ada": 90, "rosa": 85, "malik": 78}

# Clés (le défaut)
for name in scores:
    print(name)

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

# Les deux — le cas courant
for name, score in scores.items():
    print(f"{name}: {score}")

.items() est ce que tu utiliseras la plupart du temps — ça te donne la paire, déballée, prête à l'emploi.

L'ordre d'itération en Python moderne (3.7+) correspond à l'ordre d'insertion. Un dict n'est pas un « sac magique » — si tu ajoutes a puis b puis c, l'itération te les renvoie dans cet ordre. C'est une garantie du langage sur laquelle tu peux compter.

Comment trier un dictionnaire

Les dictionnaires préservent l'ordre d'insertion, donc « trier » un dict veut vraiment dire construire un nouveau dict dont les clés sont insérées dans l'ordre voulu :

scores = {"rosa": 85, "ada": 90, "malik": 78}

# Trier par clé
by_key = dict(sorted(scores.items()))
print(by_key)

# Trier par valeur (croissant)
by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
print(by_value)

# Trier par valeur, décroissant
top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(top)

sorted() renvoie une liste de paires ; l'envelopper dans dict(...) reconstruit un dictionnaire avec le nouvel ordre. Si tu n'as besoin que des paires triées (pas d'un dict), saute l'appel externe à dict().

Comment fusionner deux dictionnaires

Python 3.9+ te donne l'opérateur | :

defaults = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

merged = defaults | overrides
print(merged)

Les valeurs du dict de droite gagnent en cas de collision de clés. .update() est l'équivalent sur place. Sur les anciennes versions de Python, utilise {**defaults, **overrides}.

Le motif setdefault

Un besoin courant : « si la clé est là, utilise sa valeur ; sinon, mets un défaut puis utilise-le. »

counts = {}

for word in ["one", "two", "one", "three", "two", "one"]:
    counts.setdefault(word, 0)
    counts[word] += 1

print(counts)

Ou, mieux, utilise collections.Counter :

from collections import Counter

words = ["one", "two", "one", "three", "two", "one"]
print(Counter(words))

Counter est une sous-classe de dict qui compte par défaut. C'est le bon choix dès que tu comptes des occurrences.

Compréhensions de dictionnaire

Parallèle aux compréhensions de liste, mais pour construire des dicts :

numbers = [1, 2, 3, 4, 5]
squares = {n: n * n for n in numbers}
print(squares)

# Inverser un dict (les clés deviennent valeurs et vice versa)
prices = {"apple": 0.50, "bread": 2.00}
lookup = {v: k for k, v in prices.items()}
print(lookup)

Mêmes règles que les compréhensions de liste, mais avec key: value entre les accolades.

Le dict, jumeau de JSON

Les dicts Python correspondent presque exactement aux objets JSON. Convertir entre les deux est un seul appel :

import json

data = {"name": "Rosa", "age": 30, "tags": ["python", "docs"]}

as_json = json.dumps(data)
print(as_json)

back = json.loads(as_json)
print(back)

C'est pourquoi les dicts apparaissent partout dans le travail web — tes requêtes et réponses d'API sont essentiellement de la manipulation de dict avec un peu de réseau entre les deux.

Un exemple pratique

Un petit programme de type config qui suit un profil utilisateur :

user = {
    "name": "Rosa",
    "email": "rosa@example.com",
    "preferences": {
        "theme": "dark",
        "notifications": True,
    },
    "tags": ["python", "docs"],
}

print(user["name"])
print(user["preferences"]["theme"])
print(user.get("last_login", "never"))

user["tags"].append("seo")
user["preferences"]["theme"] = "light"

print(user)

Dicts imbriqués, valeurs mutables, .get() avec un défaut — l'outillage de base pour toute donnée en forme d'enregistrement.

On avance

Listes, tuples, sets, dicts. Avec ces quatre collections en main, tu peux modéliser presque toute donnée que tu rencontreras au début. Ensuite, on apprendra la compréhension de liste — la façon compacte de Python de transformer une collection en une autre.