> Créer, parcourir, modifier et trier un dictionnaire Python : toutes les opérations expliquées avec des exemples de code réels, des méthodes clés aux dictionnaires imbriqués.

*Source : https://coder-studio.com/tutoriels/dictionnaires-python/*

---

[// Python](https://coder-studio.com/tutoriels/)

# Les dictionnaires en Python : le guide complet

Par **Kévin Papot** · publié le 14 janvier 2026

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.

## À lire ensuite

-   [Les listes en Python : le guide complet](https://coder-studio.com/tutoriels/listes-python/)
-   [Manipuler les chaînes de caractères en Python](https://coder-studio.com/tutoriels/manipuler-chaines-python/)
-   [Les fonctions en Python](https://coder-studio.com/tutoriels/fonctions-python/)