Les Dictionnaires en Python

📚 Les Dictionnaires en Python

Introduction

Les dictionnaires constituent l’une des structures de données fondamentales de Python. Ils permettent de stocker des informations sous forme de paires clé-valeur, offrant un accès direct et performant aux données en temps constant O(1).

Contrairement aux listes qui utilisent des indices numériques, les dictionnaires utilisent des clés uniques pour identifier chaque valeur. Cette caractéristique les rend particulièrement adaptés pour représenter des objets réels, gérer des configurations, ou manipuler des données structurées.

Pourquoi les dictionnaires ?

• Recherche ultra-rapide par clé (temps constant)
• Structure intuitive proche du langage naturel
• Idéal pour modéliser des objets du monde réel
• Flexibilité dans les types de données stockées

Dans ce cours, vous apprendrez à créer, manipuler et optimiser l’utilisation des dictionnaires pour résoudre des problèmes réels de manière élégante et efficace.

---

1. Création et initialisation

1.1 Syntaxe de base

Un dictionnaire se crée avec des accolades {} et contient des paires clé-valeur séparées par des virgules.

# Dictionnaire avec des données initiales
personne = {
    "nom": "Riyad",
    "age": 30,
    "ville": "Paris"
}

# Dictionnaire vide (deux méthodes équivalentes)
dictionnaire_vide = {}
autre_vide = dict()

# Ajout dynamique d'éléments
dictionnaire_vide["cle1"] = "valeur1"
dictionnaire_vide["cle2"] = "valeur2"
print(dictionnaire_vide)

Résultat attendu :

{'cle1': 'valeur1', 'cle2': 'valeur2'}

Points clés :

• Les clés doivent être uniques et immuables (str, int, tuple)
• Les valeurs peuvent être de n’importe quel type
• Les dictionnaires sont mutables (modifiables)

---

2. Accès aux données

2.1 Accès direct

personne = {"nom": "Riyad", "age": 30, "ville": "Paris"}

nom = personne["nom"]
print(nom)

Résultat attendu :

Riyad

⚠️ Attention : Lève une exception KeyError si la clé n’existe pas.

2.2 Méthode get() (recommandée)

La méthode get() permet de récupérer une valeur avec une valeur par défaut si la clé n’existe pas.

# Avec valeur par défaut
profession = personne.get("profession", "Non spécifiée")
print(profession)

# Sans valeur par défaut (retourne None)
email = personne.get("email")
print(email)

Résultat attendu :

Non spécifiée
None

💡 Astuce : Utilisez toujours get() pour éviter les erreurs et rendre le code plus robuste.

---

3. Modification des données

3.1 Ajout d’éléments

personne = {"nom": "Riyad", "age": 30}
personne["ville"] = "Paris"
print(personne)

Résultat attendu :

{'nom': 'Riyad', 'age': 30, 'ville': 'Paris'}

3.2 Modification d’éléments existants

personne["age"] = 31
print(personne)

Résultat attendu :

{'nom': 'Riyad', 'age': 31, 'ville': 'Paris'}

Note : Si la clé existe, la valeur est écrasée. Sinon, elle est ajoutée.

---

4. Suppression d’éléments

4.1 Avec pop() (retourne la valeur)

personne = {"nom": "Riyad", "age": 30, "ville": "Paris"}

ville = personne.pop("ville")
print(f"Ville supprimée : {ville}")
print(personne)

Résultat attendu :

Ville supprimée : Paris
{'nom': 'Riyad', 'age': 30}

# Avec valeur par défaut (évite KeyError)
email = personne.pop("email", None)
print(f"Email : {email}")

Résultat attendu :

Email : None

4.2 Avec del (suppression directe)

personne = {"nom": "Riyad", "age": 30, "ville": "Paris"}
del personne["age"]
print(personne)

Résultat attendu :

{'nom': 'Riyad', 'ville': 'Paris'}

4.3 Avec clear() (vider complètement)

personne.clear()
print(personne)

Résultat attendu :

{}

---

5. Méthodes essentielles

5.1 Obtenir les clés avec keys()

personne = {"nom": "Riyad", "age": 30, "ville": "Paris"}

cles = personne.keys()
print(cles)
print(list(cles))

Résultat attendu :

dict_keys(['nom', 'age', 'ville'])
['nom', 'age', 'ville']

5.2 Obtenir les valeurs avec values()

valeurs = personne.values()
print(valeurs)
print(list(valeurs))

Résultat attendu :

dict_values(['Riyad', 30, 'Paris'])
['Riyad', 30, 'Paris']

5.3 Obtenir les paires avec items()

paires = personne.items()
print(paires)

# Itération élégante
for cle, valeur in personne.items():
    print(f"{cle}: {valeur}")

Résultat attendu :

dict_items([('nom', 'Riyad'), ('age', 30), ('ville', 'Paris')])
nom: Riyad
age: 30
ville: Paris

---

6. Compréhension de dictionnaire

6.1 Syntaxe de base

Créer des dictionnaires de manière concise avec une syntaxe élégante.

# Générer les carrés de 1 à 5
carres = {x: x**2 for x in range(1, 6)}
print(carres)

Résultat attendu :

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

6.2 Avec condition

# Filtrer les nombres pairs
carres_pairs = {x: x**2 for x in range(1, 6) if x % 2 == 0}
print(carres_pairs)

Résultat attendu :

{2: 4, 4: 16}

6.3 Transformation de données

personne = {"nom": "Riyad", "age": 30, "ville": "Paris"}

# Convertir toutes les valeurs en majuscules avec exclamation
personne_transform = {cle: str(valeur).upper() + "!" for cle, valeur in personne.items()}
print(personne_transform)

Résultat attendu :

{'nom': 'RIYAD!', 'age': '30!', 'ville': 'PARIS!'}

---

7. Dictionnaires imbriqués

7.1 Structure complexe

Les dictionnaires peuvent contenir d’autres dictionnaires pour représenter des structures complexes.

employes = {
    "emp001": {"nom": "Alice", "age": 30, "poste": "Développeuse"},
    "emp002": {"nom": "Bob", "age": 25, "poste": "Designer"},
    "emp003": {"nom": "Charlie", "age": 35, "poste": "Manager"}
}
print(employes)

Résultat attendu :

{'emp001': {'nom': 'Alice', 'age': 30, 'poste': 'Développeuse'}, 'emp002': {'nom': 'Bob', 'age': 25, 'poste': 'Designer'}, 'emp003': {'nom': 'Charlie', 'age': 35, 'poste': 'Manager'}}

7.2 Accès et modification

# Accès
poste_alice = employes["emp001"]["poste"]
print(poste_alice)

Résultat attendu :

Développeuse

# Modification
employes["emp003"]["age"] = 36
print(employes["emp003"])

Résultat attendu :

{'nom': 'Charlie', 'age': 36, 'poste': 'Manager'}

7.3 Parcours structuré

for id_emp, details in employes.items():
    print(f"\n{id_emp}:")
    for cle, valeur in details.items():
        print(f"  {cle}: {valeur}")

Résultat attendu :

emp001:
  nom: Alice
  age: 30
  poste: Développeuse

emp002:
  nom: Bob
  age: 25
  poste: Designer

emp003:
  nom: Charlie
  age: 36
  poste: Manager

---

8. Techniques avancées

8.1 Création avec dict()

# À partir de tuples
info = dict([("nom", "Alice"), ("age", 30), ("ville", "Paris")])
print(info)

# Avec paramètres nommés
config = dict(host="localhost", port=8080, debug=True)
print(config)

Résultat attendu :

{'nom': 'Alice', 'age': 30, 'ville': 'Paris'}
{'host': 'localhost', 'port': 8080, 'debug': True}

8.2 Fusion avec update()

personne = {"nom": "Alice", "age": 30}
nouvelles_infos = {"ville": "Paris", "age": 31}

personne.update(nouvelles_infos)
print(personne)

Résultat attendu :

{'nom': 'Alice', 'age': 31, 'ville': 'Paris'}

Note : Les clés existantes sont écrasées.

8.3 Création avec zip()

cles = ["nom", "age", "ville"]
valeurs = ["Alice", 30, "Paris"]

personne = dict(zip(cles, valeurs))
print(personne)

Résultat attendu :

{'nom': 'Alice', 'age': 30, 'ville': 'Paris'}

8.4 Fusion avec l’opérateur **

dict1 = {"nom": "Alice", "age": 30}
dict2 = {"ville": "Paris", "poste": "Développeuse"}

complet = {**dict1, **dict2}
print(complet)

Résultat attendu :

{'nom': 'Alice', 'age': 30, 'ville': 'Paris', 'poste': 'Développeuse'}

---

9. Bonnes pratiques

✅ À FAIRE

1. Toujours utiliser get() pour éviter les erreurs

# ✅ Sécurisé
age = personne.get("age", 0)

# ❌ Risqué
age = personne["age"]  # KeyError si la clé n'existe pas

2. Vérifier l’existence avant suppression

# ✅ Bon
if "ville" in personne:
    del personne["ville"]

# Ou avec pop
personne.pop("ville", None)

# ❌ Risqué
del personne["ville"]  # KeyError si la clé n'existe pas

3. Utiliser items() pour l’itération

# ✅ Pythonique et efficace
for cle, valeur in personne.items():
    print(f"{cle}: {valeur}")

# ❌ Moins efficace
for cle in personne.keys():
    print(f"{cle}: {personne[cle]}")

4. Préférer la compréhension pour les transformations

# ✅ Concis et lisible
carres = {x: x**2 for x in range(10)}

# ❌ Verbeux
carres = {}
for x in range(10):
    carres[x] = x**2

5. Donner des noms de clés descriptifs

# ✅ Clair et explicite
utilisateur = {
    "nom_complet": "Alice Dupont",
    "email_professionnel": "alice@entreprise.com",
    "date_inscription": "2024-01-15"
}

# ❌ Ambigu
utilisateur = {
    "n": "Alice Dupont",
    "e": "alice@entreprise.com",
    "d": "2024-01-15"
}

6. Utiliser des clés immuables

# ✅ Bon - str, int, tuple
config = {"nom": "Alice", 1: "valeur", (0, 1): "coords"}

# ❌ Mauvais - les listes ne peuvent pas être des clés
# config = {["nom"]: "Alice"}  # TypeError

❌ À ÉVITER

1. Ne jamais modifier pendant l’itération

# ❌ ERREUR RuntimeError
personne = {"nom": "Alice", "age": 30, "ville": "Paris"}
for cle in personne:
    if cle == "age":
        del personne[cle]  # Erreur !

# ✅ Solution - Créer une copie des clés
for cle in list(personne.keys()):
    if cle == "age":
        del personne[cle]

2. Ne pas utiliser de types mutables comme clés

# ❌ TypeError
# ma_liste = [1, 2, 3]
# d = {ma_liste: "valeur"}

# ✅ Utiliser un tuple
mon_tuple = (1, 2, 3)
d = {mon_tuple: "valeur"}

3. Toujours fournir une valeur par défaut avec get()

# ❌ Risque de None
age = personne.get("age")
resultat = age + 10  # TypeError si age est None

# ✅ Valeur par défaut
age = personne.get("age", 0)
resultat = age + 10  # Fonctionne toujours

4. Ne pas ignorer les KeyError sans gestion

# ❌ Peut planter
try:
    valeur = personne["cle_inexistante"]
except:
    pass  # Ignore silencieusement toutes les erreurs

# ✅ Utiliser get() ou vérifier l'existence
valeur = personne.get("cle_inexistante", "défaut")
# Ou
if "cle" in personne:
    valeur = personne["cle"]

🎯 Cas d’Usage

Quand utiliser un dictionnaire ?

• ✅ Compteurs et statistiques - Compter les occurrences d’éléments
• ✅ Cache et mémorisation - Stocker des résultats calculés
• ✅ Configuration - Paramètres d’application
• ✅ Indexation rapide - Recherche en O(1) au lieu de O(n)
• ✅ Représentation d’objets - Données structurées avec attributs nommés
• ✅ Mapping de données - Correspondances clé-valeur (traductions, conversions)

Quand NE PAS utiliser un dictionnaire ?

• ❌ Séquences ordonnées simples → Liste
• ❌ Collections d’éléments uniques → Set
• ❌ Données tabulaires complexes → pandas DataFrame
• ❌ Objets avec méthodes et comportements → Classes

---

📋 Évaluation des Connaissances

À quoi sert cette évaluation ?

Cette évaluation rapide (3 minutes) vous permet de vérifier votre compréhension des concepts abordés dans ce cours.

Instructions :

• 🕒 Temps limité : 3 minutes
• 🎯 Seuil de réussite : 80% (8/10)
• 💡 Les réponses seront expliquées à la fin

À vous de jouer ! 🚀

---

---

📝 Exercices pratiques

Exercice 1 : Carnet d'adresses

Énoncé : Créez un dictionnaire contacts contenant 3 personnes avec leur nom, téléphone et email. Affichez ensuite le téléphone de la deuxième personne.

Exemple d’exécution :

# Créez un dictionnaire avec 3 contacts
# Affichez le téléphone de Bob

Voir la solution

# Solution complète
contacts = {
    "Alice": {"telephone": "0601020304", "email": "alice@email.com"},
    "Bob": {"telephone": "0605060708", "email": "bob@email.com"},
    "Charlie": {"telephone": "0609101112", "email": "charlie@email.com"}
}

print(contacts["Bob"]["telephone"])

Résultat attendu :

0605060708

---

Exercice 2 : Compteur de mots

Énoncé : Écrivez un programme qui compte le nombre d’occurrences de chaque mot dans une phrase en utilisant un dictionnaire.

Exemple d’exécution :

phrase = "python est génial python est puissant"
# Comptez chaque mot

Voir la solution

# Solution complète
phrase = "python est génial python est puissant"
mots = phrase.split()
compteur = {}

for mot in mots:
    compteur[mot] = compteur.get(mot, 0) + 1

print(compteur)

Résultat attendu :

{'python': 2, 'est': 2, 'génial': 1, 'puissant': 1}

---

Exercice 3 : Filtrer un dictionnaire

Énoncé : À partir d’un dictionnaire de notes d’étudiants, créez un nouveau dictionnaire contenant uniquement les étudiants ayant une note supérieure ou égale à 10.

Exemple d’exécution :

notes = {"Alice": 15, "Bob": 8, "Charlie": 12, "Diana": 9}
# Filtrez les notes >= 10

Voir la solution

# Solution complète
notes = {"Alice": 15, "Bob": 8, "Charlie": 12, "Diana": 9}

notes_reussite = {nom: note for nom, note in notes.items() if note >= 10}

print(notes_reussite)

Résultat attendu :

{'Alice': 15, 'Charlie': 12}

---

Exercice 4 : Inverser un dictionnaire

Énoncé : Créez une fonction qui inverse les clés et valeurs d’un dictionnaire (les valeurs deviennent les clés et vice versa).

Exemple d’exécution :

original = {"a": 1, "b": 2, "c": 3}
# Inversez le dictionnaire

Voir la solution

# Solution complète
original = {"a": 1, "b": 2, "c": 3}

def inverser_dictionnaire(d):
    return {valeur: cle for cle, valeur in d.items()}

inverse = inverser_dictionnaire(original)
print(inverse)

Résultat attendu :

{1: 'a', 2: 'b', 3: 'c'}

---

Exercice 5 : Gestion d'inventaire

Énoncé : Créez un système d’inventaire avec les fonctions suivantes : ajouter un produit, modifier la quantité, supprimer un produit et afficher l’inventaire complet.

Exemple d’exécution :

inventaire = {}
# Ajoutez des produits
# Modifiez des quantités
# Affichez l'inventaire

Voir la solution

# Solution complète
inventaire = {}

def ajouter_produit(nom, quantite, prix):
    inventaire[nom] = {"quantite": quantite, "prix": prix}

def modifier_quantite(nom, nouvelle_quantite):
    if nom in inventaire:
        inventaire[nom]["quantite"] = nouvelle_quantite

def supprimer_produit(nom):
    if nom in inventaire:
        del inventaire[nom]

def afficher_inventaire():
    for produit, infos in inventaire.items():
        print(f"{produit}: {infos['quantite']} unités à {infos['prix']}€")

# Test
ajouter_produit("Pomme", 50, 2.5)
ajouter_produit("Banane", 30, 1.8)
modifier_quantite("Pomme", 45)
afficher_inventaire()

Résultat attendu :

Pomme: 45 unités à 2.5€
Banane: 30 unités à 1.8€

---

🎯 Points Clés à Retenir

1. Les dictionnaires sont rapides : Accès en temps constant O(1)
2. Utilisez get() : Évite les KeyError et rend le code robuste
3. Les clés sont uniques : Pas de doublons possibles
4. Privilégiez l’immutabilité : Utilisez des clés immuables (str, int, tuple)
5. La compréhension est puissante : Code concis et lisible

---

📚 Pour Aller Plus Loin

Modules Python liés :

• collections.defaultdict : Dictionnaires avec valeurs par défaut
• collections.Counter : Compteur spécialisé pour les occurrences
• collections.OrderedDict : Dictionnaires ordonnés (Python < 3.7)

Concepts avancés :

• JSON : Sérialisation et désérialisation de dictionnaires
• API REST : Manipulation de données JSON
• Bases de données NoSQL : Stockage de documents (MongoDB)

Continuez à pratiquer régulièrement ! 🐍✨

---

📢 Partagez cet article

LinkedIn Twitter Facebook WhatsApp

---

À propos de l'auteur

Riyad ODJOUADEExpert en cybersécurité & infrastructure

Je partage des guides techniques pratiques sur la cybersécurité, l'administration système et le développement web. Tous les contenus sont basés sur des expérimentations réelles.

LinkedIn GitHub Email

---

Dernière mise à jour : 02 Décembre 2025