Les dictionnaires en Python

Les Dictionnaires

Dans de nombreux problèmes algorithmiques, il est indispensable de pouvoir associer une information à une autre. Les listes offrent un accès rapide par indice, mais ne permettent pas d'associer directement une valeur à une clé choisie librement.

Création d'un dictionnaire

d1 = {}                              # dictionnaire vide
d2 = dict()                          # dictionnaire vide (constructeur)
d3 = {"clé1": val1, "clé2": val2}   # création avec initialisation
d4 = dict([("clé1", val1), ...])    # depuis une liste de tuples
d5 = {k: expr for k in iterable}    # compréhension de dictionnaire

Exemple n°1 — Différentes créations

# Création directe
etudiant = {"nom": "Ahmed", "age": 19, "note": 16.25}
print(etudiant)

# Depuis une liste de tuples
personnes = dict([("ahmed", 18), ("sara", 17), ("ismail", 20)])
print(personnes)

# Par compréhension — table des carrés
carres = {i: i**2 for i in range(1, 6)}
print(carres)

# Fonction mathématique représentée comme dictionnaire
f_carree = {x: x**2 for x in range(1, 5)}
print(f"f(2) = {f_carree[2]}")   # f(2) = 4

{'nom': 'Ahmed', 'age': 19, 'note': 16.25}
{'ahmed': 18, 'sara': 17, 'ismail': 20}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
f(2) = 4

Accès, Ajout et Modification

Accès à une valeur

On accède à une valeur en utilisant la clé entre crochets d[clé], comme l'indexation dans une liste — mais avec une clé quelconque au lieu d'un entier.

Exemple n°2 — Accès par clé

personnes = {"ahmed": 18, "sara": 17, "ismail": 20}

print(personnes["ahmed"])    # 18
print(personnes["ismail"])   # 20

18
20

print(personnes["ikram"])   # ❌ KeyError: 'ikram'

Accès sécurisé — méthode get()

d.get(clé)                  # retourne None si clé absente
d.get(clé, valeur_défaut)   # retourne valeur_défaut si clé absente

Exemple n°3 — get() vs accès direct

personnes = {"ahmed": 18, "sara": 17, "ismail": 20}

# Clé présente
print(personnes.get("sara"))               # 17

# Clé absente — retourne None
print(personnes.get("ikram"))              # None

# Clé absente — retourne la valeur par défaut
print(personnes.get("ikram", "inconnu"))   # inconnu

# Usage typique : compter les occurrences
texte = "algorithme"
compteur = {}
for c in texte:
    compteur[c] = compteur.get(c, 0) + 1
print(compteur)

17
None
inconnu
{'a': 1, 'l': 1, 'g': 1, 'o': 1, 'r': 1, 'i': 1, 't': 1, 'h': 1, 'm': 1, 'e': 1}

Ajout et modification

La même syntaxe d[clé] = valeur sert à la fois pour ajouter une nouvelle paire et modifier une valeur existante.

Exemple n°4 — Ajout et modification

personnes = {"ahmed": 18, "sara": 17, "ismail": 20}
print(f"Initial  : {personnes}")

# Modification d'une clé existante
personnes["sara"] = 19
print(f"Modifié  : {personnes}")

# Ajout d'une nouvelle clé
personnes["ikram"] = 18
print(f"Ajouté   : {personnes}")

# setdefault() — ajoute seulement si la clé est absente
personnes.setdefault("karim", 21)    # ajouté
personnes.setdefault("ahmed", 99)    # ignoré (ahmed existe déjà)
print(f"Après setdefault : {personnes}")

Initial  : {'ahmed': 18, 'sara': 17, 'ismail': 20}
Modifié  : {'ahmed': 18, 'sara': 19, 'ismail': 20}
Ajouté   : {'ahmed': 18, 'sara': 19, 'ismail': 20, 'ikram': 18}
Après setdefault : {'ahmed': 18, 'sara': 19, 'ismail': 20, 'ikram': 18, 'karim': 21}

Parcours des dictionnaires

Python fournit trois méthodes de vue pour parcourir un dictionnaire. Ces vues sont dynamiques : elles reflètent les modifications du dictionnaire en temps réel.

Exemple n°5 — Les quatre formes de parcours

personnes = {"ahmed": 18, "sara": 17, "ismail": 20}

# 1. Parcours implicite des clés
print("── Clés (implicite) ──")
for nom in personnes:
    print(nom, end="  ")

# 2. keys()
print("\n── keys() ──")
for nom in personnes.keys():
    print(f"{nom:10} → {personnes[nom]}")

# 3. values()
print("── values() ──")
for age in personnes.values():
    print(age, end="  ")

# 4. items() — le plus élégant
print("\n── items() ──")
for nom, age in personnes.items():
    print(f"l'âge de {nom:8} est {age}")

── Clés (implicite) ──
ahmed  sara  ismail
── keys() ──
ahmed      → 18
sara       → 17
ismail     → 20
── values() ──
18  17  20
── items() ──
l'âge de ahmed    est 18
l'âge de sara     est 17
l'âge de ismail   est 20

Opérations et méthodes utiles

Exemple n°6 — Opérations courantes

personnes = {"ahmed": 18, "sara": 17, "ismail": 20}

# Taille
print(f"Taille       : {len(personnes)}")

# Test d'appartenance
print(f"ahmed in d   : {'ahmed' in personnes}")
print(f"ikram in d   : {'ikram' in personnes}")

# Suppression avec del
del personnes["ahmed"]
print(f"Après del    : {personnes}")

# Suppression avec pop
age = personnes.pop("sara")
print(f"pop('sara')  : {age}  →  {personnes}")

# Suppression sécurisée avec pop + valeur par défaut
val = personnes.pop("inconnu", "absent")
print(f"pop sécurisé : {val}")

# Vider le dictionnaire
personnes.clear()
print(f"Après clear  : {personnes}")

Taille       : 3
ahmed in d   : True
ikram in d   : False
Après del    : {'sara': 17, 'ismail': 20}
pop('sara')  : 17  →  {'ismail': 20}
pop sécurisé : absent
Après clear  : {}

Exemple n°7 — Fusion de dictionnaires

d1 = {"a": 1, "b": 2}
d2 = {"b": 9, "c": 3}   # clé "b" en conflit

# Fusion → nouveau dictionnaire (d2 écrase d1 sur les conflits)
d_fusion = d1 | d2
print(f"d1 | d2  = {d_fusion}")

# Fusion en place
d1 |= d2
print(f"d1 |= d2 = {d1}")

# Méthode update() (compatible Python < 3.9)
d3 = {"x": 10, "y": 20}
d3.update({"y": 99, "z": 30})
print(f"update() = {d3}")

d1 | d2  = {'a': 1, 'b': 9, 'c': 3}
d1 |= d2 = {'a': 1, 'b': 9, 'c': 3}
update() = {'x': 10, 'y': 99, 'z': 30}

Compréhension de dictionnaires

{clé: valeur for variable in iterable}
{clé: valeur for variable in iterable if condition}

Exemple n°8 — Compréhensions de dictionnaires

# Table des carrés
carres = {x: x**2 for x in range(1, 6)}
print(f"Carrés    : {carres}")

# Inverser un dictionnaire (clé ↔ valeur)
original = {"a": 1, "b": 2, "c": 3}
inverse  = {v: k for k, v in original.items()}
print(f"Inversé   : {inverse}")

# Filtrer les étudiants admis (note >= 10)
notes = {"Ahmed": 16, "Sara": 8, "Ismail": 12, "Ikram": 9}
admis = {nom: n for nom, n in notes.items() if n >= 10}
print(f"Admis     : {admis}")

# Normaliser des notes sur 20
normalises = {nom: round(n * 20 / max(notes.values()), 2)
              for nom, n in notes.items()}
print(f"Normalisé : {normalises}")

Carrés    : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
Inversé   : {1: 'a', 2: 'b', 3: 'c'}
Admis     : {'Ahmed': 16, 'Ismail': 12}
Normalisé : {'Ahmed': 20.0, 'Sara': 10.0, 'Ismail': 15.0, 'Ikram': 11.25}