Niveau : Intermédiaire

Chapitre 13 : Les Dictionnaires

Clé-valeur, get, pop, items, Clés uniques

1. Quoi : Les Dictionnaires

Un dictionnaire (dict) est une collection non ordonnée (avant Python 3.7) et muable d'éléments stockés sous forme de paires clé-valeur.

• Paire clé-valeur : Chaque élément d'un dictionnaire est composé d'une clé unique et de la valeur qui lui est associée.
• Clé unique : Les clés doivent être uniques et de type immuable (ex: str, int, tuple). Elles servent à accéder rapidement à leur valeur correspondante.
• Muable : Vous pouvez ajouter, modifier et supprimer des paires clé-valeur.
• Ordonné (depuis Python 3.7) : Les dictionnaires conservent l'ordre d'insertion des éléments.

2. Pourquoi : Stocker des données structurées

Les dictionnaires sont parfaits pour représenter des objets du monde réel ou des données structurées où chaque information a une étiquette.

• Un utilisateur : clé "nom", valeur "Alice"; clé "age", valeur 30.
• Un produit : clé "id", valeur 123; clé "price", valeur 19.99.
• Des données de configuration.

Ils permettent un accès quasi instantané aux valeurs via leurs clés, ce qui est beaucoup plus efficace que de chercher dans une liste.

3. Comment : Création et Manipulation

A. Création

On crée un dictionnaire avec des accolades {}, en séparant les paires clé-valeur par des virgules. La clé et la valeur sont séparées par deux-points :.

# Un dictionnaire représentant un utilisateur
user = {
    "name": "Alice",
    "age": 30,
    "is_admin": False,
    "city": "Paris"
}

# Un dictionnaire vide
empty_dict = {}

B. Accès aux valeurs

• Avec des crochets [] : Simple et direct. Lève une erreur KeyError si la clé n'existe pas.
• Avec la méthode .get(key, default) : Plus sûr. Retourne None (ou une valeur par défaut spécifiée) si la clé n'existe pas, sans lever d'erreur.

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

# Accès direct
print(user["name"])  # "Alice"
# print(user["country"]) # ❌ Lèvera une KeyError

# Accès sécurisé avec .get()
print(user.get("age")) # 30
print(user.get("country")) # None (pas d'erreur)
print(user.get("country", "Unknown")) # "Unknown" (valeur par défaut)

✅ Bonne pratique : Utilisez .get() lorsque vous n'êtes pas sûr si une clé existe.

C. Ajout et Modification

L'assignation via une clé permet à la fois d'ajouter une nouvelle paire et de modifier une paire existante.

user = {"name": "Alice"}

# Modifier une valeur existante
user["name"] = "Alicia"

# Ajouter une nouvelle paire clé-valeur
user["age"] = 31
user["city"] = "Lyon"

print(user) # {'name': 'Alicia', 'age': 31, 'city': 'Lyon'}

D. Suppression d'éléments

• del dict[key] : Supprime la paire clé-valeur. Lève une KeyError si la clé n'existe pas.
• .pop(key, default) : Supprime la paire et retourne la valeur. Plus sûr, car on peut fournir une valeur par défaut si la clé n'existe pas.

user = {"name": "Bob", "age": 40, "city": "New York"}

# Supprimer avec del
del user["city"]

# Supprimer et récupérer la valeur avec .pop()
removed_age = user.pop("age")
print(f"Removed age: {removed_age}") # Removed age: 40

# Essayer de supprimer une clé qui n'existe pas (sans erreur)
removed_country = user.pop("country", "Not found")
print(f"Removed country: {removed_country}") # Removed country: Not found

print(user) # {'name': 'Bob'}

E. Itération sur les dictionnaires

Il y a trois manières principales d'itérer.

user = {"name": "Charles", "age": 25}

# 1. Itérer sur les clés (comportement par défaut)
print("--- Keys ---")
for key in user:
    print(key)

# 2. Itérer sur les valeurs
print("--- Values ---")
for value in user.values():
    print(value)

# 3. Itérer sur les paires clé-valeur (le plus courant et le plus utile)
print("--- Items ---")
for key, value in user.items():
    print(f"{key} -> {value}")

F. Fonctions et Opérateurs Utiles

• len(dict) : Retourne le nombre de paires clé-valeur.
• key in dict : Vérifie si une clé existe dans le dictionnaire (très rapide).

user = {"name": "David", "age": 28}

print(len(user)) # 2
print("age" in user) # True
print("email" in user) # False

✅ Bonne pratique : key in dict est la manière "pythonic" de vérifier l'existence d'une clé.

Exercices :

Exercice 13 - Comptage de la Fréquence des Mots

Objectif

Cet exercice a pour but de vous faire utiliser un dictionnaire pour compter la fréquence d'apparition de chaque mot dans une phrase. C'est un problème classique en traitement de texte.

Énoncé

1. Créez un nouveau fichier Python nommé word_frequency.py.

2. Initialisez la variable suivante :

   text = "this is a simple sentence with simple words this is not complex"

3. Préparez le texte :

   • Pour pouvoir compter les mots, vous devez d'abord transformer la chaîne de caractères en une liste de mots. Utilisez la méthode .split() des chaînes de caractères, qui sépare la chaîne par les espaces.

   words = text.split()

4. Initialisez un dictionnaire vide nommé frequency_counter qui stockera les mots comme clés et leur fréquence comme valeurs.

5. Écrivez une boucle for qui itère sur votre liste words.

   • À l'intérieur de la boucle, pour chaque word :
     • Vérifiez si le mot est déjà une clé dans votre frequency_counter.
     • S'il y est, incrémentez sa valeur (son compteur) de 1.
     • S'il n'y est pas, ajoutez-le au dictionnaire avec une valeur de 1.
   • Astuce : La méthode .get(key, 0) est parfaite ici. frequency_counter.get(word, 0) retournera la valeur actuelle du mot s'il existe, ou 0 s'il n'existe pas.

6. Après la boucle, affichez le dictionnaire de fréquences.

Résultat Attendu

La sortie de votre script doit être (l'ordre peut varier si vous utilisez une version de Python antérieure à 3.7) :

Word Frequencies:
{'this': 2, 'is': 2, 'a': 1, 'simple': 2, 'sentence': 1, 'with': 1, 'words': 1, 'not': 1, 'complex': 1}

Bonus (Optionnel)

Affichez les résultats de manière plus lisible, un mot par ligne, trié par ordre alphabétique des mots.

• Astuce : Vous pouvez obtenir une liste triée des clés d'un dictionnaire avec sorted(my_dict).

Résultat Attendu (avec bonus)

Word Frequencies (sorted):
 - a: 1
 - complex: 1
 - is: 2
 - not: 1
 - sentence: 1
 - simple: 2
 - this: 2
 - with: 1
 - words: 1

Cliquez ici pour voir un exemple de code de solution

# word_frequency.py

text = "this is a simple sentence with simple words this is not complex"

# 1. Préparation du texte
words = text.split()

# 2. Initialisation du dictionnaire
frequency_counter = {}

# 3. Boucle et comptage
for word in words:
    # La méthode .get(word, 0) retourne la valeur actuelle si 'word' est dans le dict,
    # sinon elle retourne 0. On ajoute ensuite 1 au résultat.
    # C'est une manière très concise de gérer les deux cas (clé existante ou non).
    frequency_counter[word] = frequency_counter.get(word, 0) + 1

# 4. Affichage du résultat
print("Word Frequencies:")
print(frequency_counter)


# --- BONUS ---
print("\nWord Frequencies (sorted):")
# On récupère les clés, on les trie, puis on itère sur cette liste triée
for word in sorted(frequency_counter):
    # On accède à la valeur correspondante dans le dictionnaire original
    count = frequency_counter[word]
    print(f" - {word}: {count}")