Les dictionnaires en Python : le guide complet
Le dictionnaire (dict) est l’une des structures de données les plus utilisées en Python. Il stocke des paires clé → valeur et permet un accès quasi instantané à une donnée à partir de sa clé. Là où une liste vous force à retenir un index numérique, un dictionnaire vous laisse retrouver une information par un nom parlant.
Ce guide couvre, opération par opération, tout ce que vous aurez à faire avec un dictionnaire au quotidien : le créer, y accéder, l’alimenter, le parcourir, le transformer et le trier. Chaque section contient un exemple de code que vous pouvez exécuter tel quel.
Créer un dictionnaire
Avec des accolades
La syntaxe la plus courante utilise les accolades {}, avec des clés séparées de leurs valeurs par deux-points.
utilisateur = {
"nom": "Dupont",
"age": 34,
"actif": True,
}
print(utilisateur) # {'nom': 'Dupont', 'age': 34, 'actif': True}
Avec la fonction dict()
dict() accepte des arguments nommés, pratique quand les clés sont de simples identifiants.
config = dict(hote="localhost", port=5432, ssl=False)
print(config["port"]) # 5432
À partir d’une liste de paires
Si vous avez une liste de tuples (clé, valeur), dict() la convertit directement.
paires = [("fr", "Français"), ("en", "Anglais"), ("es", "Espagnol")]
langues = dict(paires)
print(langues["en"]) # Anglais
Un dictionnaire vide
scores = {} # dictionnaire vide
scores["alice"] = 10 # que l'on remplit ensuite
Attention : {} crée bien un dictionnaire vide, pas un ensemble (set). Pour un set vide, il faut utiliser set().
Accéder à une valeur
Par la clé
L’accès direct entre crochets renvoie la valeur associée. Si la clé n’existe pas, Python lève une KeyError.
utilisateur = {"nom": "Dupont", "age": 34}
print(utilisateur["nom"]) # Dupont
# print(utilisateur["email"]) # KeyError: 'email'
Avec get() pour éviter les erreurs
La méthode get() renvoie None (ou une valeur par défaut) au lieu de planter si la clé est absente. C’est la façon la plus sûre de lire une valeur incertaine.
print(utilisateur.get("email")) # None
print(utilisateur.get("email", "inconnu")) # inconnu
Vérifier la présence d’une clé
L’opérateur in teste l’existence d’une clé sans jamais lever d’exception.
if "age" in utilisateur:
print("On connaît l'âge")
Ajouter et modifier des éléments
Ajouter ou écraser une clé
L’affectation par crochets ajoute la clé si elle n’existe pas, ou remplace sa valeur si elle existe déjà.
panier = {"pommes": 3}
panier["bananes"] = 6 # ajout
panier["pommes"] = 5 # modification
print(panier) # {'pommes': 5, 'bananes': 6}
Fusionner avec update()
update() intègre les clés d’un autre dictionnaire (ou d’arguments nommés) en une seule opération.
base = {"a": 1, "b": 2}
base.update({"b": 20, "c": 3})
print(base) # {'a': 1, 'b': 20, 'c': 3}
Fusionner avec l’opérateur |
Depuis Python 3.9, l’opérateur | crée un nouveau dictionnaire fusionné, tandis que |= modifie en place.
d1 = {"x": 1}
d2 = {"y": 2}
fusion = d1 | d2 # {'x': 1, 'y': 2}
d1 |= d2 # d1 devient {'x': 1, 'y': 2}
Supprimer des éléments
Avec del
del retire une clé. Elle lève une KeyError si la clé est absente.
stock = {"stylo": 12, "cahier": 4, "gomme": 7}
del stock["gomme"]
print(stock) # {'stylo': 12, 'cahier': 4}
Avec pop() pour récupérer la valeur
pop() supprime la clé et renvoie sa valeur. Un second argument sert de valeur par défaut pour éviter l’erreur.
quantite = stock.pop("stylo")
print(quantite) # 12
absent = stock.pop("regle", 0) # 0 au lieu d'une KeyError
Avec popitem() pour retirer le dernier
popitem() retire et renvoie la dernière paire insérée, utile pour vider un dictionnaire comme une pile.
d = {"a": 1, "b": 2}
print(d.popitem()) # ('b', 2)
Tout vider avec clear()
stock.clear()
print(stock) # {}
Parcourir un dictionnaire
Boucler sur les clés
Une boucle for sur un dictionnaire itère par défaut sur ses clés.
notes = {"maths": 15, "français": 12, "histoire": 14}
for matiere in notes:
print(matiere)
Parcourir les valeurs avec values()
for note in notes.values():
print(note)
Parcourir clés et valeurs avec items()
items() renvoie des paires (clé, valeur) que l’on déballe directement dans la boucle. C’est la méthode la plus lisible.
for matiere, note in notes.items():
print(f"{matiere} : {note}/20")
Récupérer les clés dans une liste
Les objets renvoyés par keys(), values() et items() sont des vues dynamiques. Pour figer un instantané, convertissez-les en liste.
liste_matieres = list(notes.keys())
print(liste_matieres) # ['maths', 'français', 'histoire']
Les dictionnaires en compréhension
La dict comprehension construit un dictionnaire en une ligne, à partir d’un itérable.
Transformer une liste
nombres = [1, 2, 3, 4]
carres = {n: n ** 2 for n in nombres}
print(carres) # {1: 1, 2: 4, 3: 9, 4: 16}
Filtrer avec une condition
notes = {"maths": 15, "français": 8, "histoire": 14}
reussites = {m: n for m, n in notes.items() if n >= 10}
print(reussites) # {'maths': 15, 'histoire': 14}
Inverser clés et valeurs
langues = {"fr": "Français", "en": "Anglais"}
inverse = {v: k for k, v in langues.items()}
print(inverse) # {'Français': 'fr', 'Anglais': 'en'}
Méthodes utiles à connaître
setdefault() : lire ou initialiser
setdefault() renvoie la valeur d’une clé, et la crée avec une valeur par défaut si elle n’existe pas encore. Idéal pour construire des regroupements.
groupes = {}
for mot in ["python", "perl", "java", "javascript"]:
initiale = mot[0]
groupes.setdefault(initiale, []).append(mot)
print(groupes) # {'p': ['python', 'perl'], 'j': ['java', 'javascript']}
fromkeys() : créer depuis une liste de clés
fromkeys() génère un dictionnaire à partir d’une liste de clés, toutes associées à la même valeur.
champs = dict.fromkeys(["nom", "prenom", "email"], "")
print(champs) # {'nom': '', 'prenom': '', 'email': ''}
copy() : copier sans lier
L’affectation simple (b = a) crée deux noms pour le même dictionnaire. Pour une copie indépendante de premier niveau, utilisez copy().
a = {"x": 1}
b = a.copy()
b["x"] = 99
print(a["x"]) # 1 : a n'a pas bougé
len() : compter les paires
print(len({"a": 1, "b": 2, "c": 3})) # 3
Les dictionnaires imbriqués
Une valeur de dictionnaire peut être un autre dictionnaire, ce qui permet de modéliser des données structurées.
equipe = {
"alice": {"poste": "dev", "anciennete": 3},
"bob": {"poste": "design", "anciennete": 5},
}
# Accès en cascade
print(equipe["bob"]["poste"]) # design
# Modification en profondeur
equipe["alice"]["anciennete"] = 4
# Parcours imbriqué
for nom, infos in equipe.items():
print(f"{nom} occupe le poste de {infos['poste']}")
Pour un accès profond sans risque de KeyError, enchaînez les get() :
poste = equipe.get("carol", {}).get("poste", "N/A")
print(poste) # N/A
Trier un dictionnaire
Un dictionnaire conserve l’ordre d’insertion (depuis Python 3.7), mais on veut souvent le trier par clé ou par valeur. sorted() renvoie une liste triée que l’on repasse dans dict().
Trier par clé
stock = {"cahier": 4, "stylo": 12, "gomme": 7}
par_cle = dict(sorted(stock.items()))
print(par_cle) # {'cahier': 4, 'gomme': 7, 'stylo': 12}
Trier par valeur
Le paramètre key indique sur quel élément trier. Ici item[1] cible la valeur.
par_valeur = dict(sorted(stock.items(), key=lambda item: item[1]))
print(par_valeur) # {'cahier': 4, 'gomme': 7, 'stylo': 12}
Trier par valeur décroissante
top = dict(sorted(stock.items(), key=lambda item: item[1], reverse=True))
print(top) # {'stylo': 12, 'gomme': 7, 'cahier': 4}
En résumé
Le dictionnaire Python couvre un immense éventail de besoins : mémoriser une configuration, indexer des objets par identifiant, compter des occurrences, regrouper des données. Retenez trois réflexes qui reviennent sans arrêt : get() pour lire sans risque, items() pour parcourir proprement, et setdefault() pour construire des regroupements. Le reste s’articule autour de ces bases.