12 - Dictionnaires

Les exercices se font dans Thonny, dans le fichier 12_dictionnaires.py.

Cours associé : 12 - Dictionnaires .

Exercice 0 : QCM – vérification des prérequis

Pour chaque question, une seule réponse est correcte.

1. Quelle structure Python associe des clés à des valeurs ?

• A. Une liste
• B. Un tuple
• C. Un dictionnaire
• D. Un ensemble (set)

Correction publiée après la séance.

2. Comment accéder à la valeur associée à la clé 'nom' dans d = {'nom': 'Alice', 'age': 17} ?

• A. d[0]
• B. d['nom']
• C. d.nom
• D. d(nom)

Correction publiée après la séance.

3. Que se passe-t-il si on écrit d['note'] = 15 avec d = {'nom': 'Alice'} ?

• A. Erreur car la clé 'note' n’existe pas
• B. La paire 'note': 15 est ajoutée au dictionnaire
• C. Le dictionnaire est remplacé par {'note': 15}
• D. Rien ne se passe

Correction publiée après la séance.

4. Quels types Python peuvent servir de clé dans un dictionnaire ?

• A. Uniquement les chaînes de caractères
• B. Uniquement les entiers
• C. Tout type immuable (int, str, tuple, etc.)
• D. N’importe quel type, y compris les listes

Correction publiée après la séance.

Exemple travaillé : créer et parcourir un dictionnaire

Problème : on dispose des notes de trois élèves et on veut calculer la moyenne de la classe.

Étape 1. Créer le dictionnaire :

notes = {"Alice": 14, "Bob": 12, "Clara": 16}

Étape 2. Parcourir et afficher :

for nom, note in notes.items():
    print(f"{nom} : {note}/20")

Étape 3. Calculer la moyenne :

total = 0
for note in notes.values():
    total += note
moyenne = total / len(notes)
print(f"Moyenne : {moyenne}")  # 14.0

Méthodes utiles :

• d.keys() → les clés ;
• d.values() → les valeurs ;
• d.items() → les paires (clé, valeur) ;
• cle in d → teste si une clé existe.

Exercice 1

Soit le dictionnaire :

d = {'nom': 'Dupuis', 'prenom': 'Jacque', 'age': 30}

• Corriger l’erreur dans le prénom ‘Jacques’ à l’aide d’une instruction.

  Indice

  On modifie une valeur en l’affectant à sa clé : d[clé] = nouvelle_valeur.

• Afficher la liste des clés du dictionnaire.

  Indice

  Les méthodes keys(), values() et items() donnent les clés, les valeurs et les paires ; list(...) les transforme en liste.

• Afficher la liste des valeurs du dictionnaire.

• Afficher la liste des paires clé/valeur du dictionnaire.

• Écrire une instruction qui affiche la phrase « Jacques Dupuis a 30 ans ».

  Indice

  On lit une valeur grâce à sa clé, par exemple d['nom'], et on construit la phrase avec une f-string.

Correction publiée après la séance.

Exercice 2

1. Créer un dictionnaire eleves associant des prénoms et des âges (pour environ cinq personnes).

   Indice

   Un dictionnaire s’écrit entre accolades, avec des paires clé: valeur séparées par des virgules : {"Léa": 16, ...}.

2. Donner deux façons différentes d’itérer sur le dictionnaire et d’afficher les paires sous le format "prenom a age ans".

   Indice

   Une boucle for peut parcourir les clés du dictionnaire, ou bien ses paires grâce à la méthode items().

Correction publiée après la séance.

Exercice 3

Écrire une fonction qui prend en entrée une chaîne de caractères et retourne un dictionnaire indiquant, pour chaque mot, sa fréquence dans la chaîne fournie.

def frequences_mots(chaine):
    freq = {}
    for mot in chaine.split():
        if mot in freq:
            freq[mot] = ...
        else:
            freq[mot] = ...
    return freq

Correction publiée après la séance.

Exercice 4

On dispose d’un dictionnaire associant à des noms de commerciaux d’une société le nombre de ventes qu’ils ont réalisées. Par exemple :

ventes = {"Dupont": 14, "Hervy": 19, "Geoffroy": 15, "Layec": 21}

1. Écrire une fonction qui prend en entrée un tel dictionnaire et renvoie le nombre total de ventes dans la société.

   Indice

   Parcourir les valeurs avec ventes.values() et les additionner dans un accumulateur.

2. Écrire une fonction qui prend en entrée un tel dictionnaire et renvoie le nom du vendeur ayant réalisé le plus de ventes. Si plusieurs vendeurs sont ex-aequo sur ce critère, la fonction devra retourner le nom de l’un d’entre eux.

   Indice

   Parcourir les paires avec ventes.items() et garder le nom associé au plus grand nombre de ventes rencontré, comme dans une recherche de maximum.

   Code à copier puis compléter

   def meilleur_vendeur(ventes):
       meilleur = ""
       max_ventes = -1
       for nom, nb in ventes.items():
           if nb > ...:
               max_ventes = ...
               meilleur = ...
       return meilleur
   

Correction publiée après la séance.

Exercice 5

1. Écrire une fonction dico_vers_liste qui convertit un dictionnaire en une liste de tuples (sans utiliser la fonction items()).

   Indice

   Parcourir les clés du dictionnaire et ajouter à la liste le tuple (clé, mon_dico[clé]).

2. Écrire une fonction liste_vers_dico qui convertit une liste de tuples en dictionnaire.

   Indice

   Partir d’un dictionnaire vide, puis, pour chaque tuple (clé, valeur) de la liste, faire d[clé] = valeur.

Correction publiée après la séance.

Exercice 6

Écrire une fonction qui prend en entrée une chaîne de caractères comprenant, sur chaque ligne, trois champs séparés par des caractères ';' (un numéro d’étudiant, un nom et un prénom) et renvoie un dictionnaire dont les clés sont les numéros d’étudiants et les valeurs sont, pour chaque numéro d’étudiant, une chaîne correspondant à la concaténation des prénom et nom de la personne. On pourra tester la fonction avec la chaîne suivante :

chaine_etudiants = """213615200;BESNIER;JEAN
213565488;DUPOND;MARC
214665555;DURAND;JULIE"""

def dico_etudiants(chaine):
    d = {}
    for ligne in chaine.split("\n"):
        numero, nom, prenom = ligne.split(...)
        d[...] = prenom + " " + nom
    return d

Correction publiée après la séance.

Exercice 7

Écrire une fonction qui prend en entrée un dictionnaire associant à un nom une liste de notes et qui renvoie la liste des noms des personnes qui ont la moyenne la plus élevée (s’il y a des ex-aequo, cette liste contiendra plusieurs éléments, sinon, elle n’en contiendra qu’un) et la moyenne correspondante. On pourra utiliser le dictionnaire suivant pour tester la fonction ainsi écrite :

notes = {"Tom": [8, 10, 12], "Mila": [10, 9], "Alex": [], "Lina": [12, 10, 8]}

Exercice 8 - Salles du lycée

Le dictionnaire suivant décrit quelques salles d’un lycée. La clé est le nom de la salle ; la valeur est un tuple qui contient, dans cet ordre, le bâtiment, le nombre de places et un booléen qui indique si la salle a un vidéoprojecteur.

salles = {
    "A101": ("A", 30, True),
    "A102": ("A", 36, False),
    "B12": ("B", 24, True),
    "B14": ("B", 35, True),
    "C3": ("C", 18, False),
    "Amphi": ("C", 120, True),
}

Le nom d’une salle donne directement toutes ses informations :

print(salles["B14"])

('B', 35, True)

1. Écrire un programme qui affiche la liste des bâtiments, chacun une seule fois.

   Indice

   Chaque valeur est un tuple (batiment, places, projecteur). Parcourir les valeurs avec salles.values() et n’ajouter le bâtiment à une liste que s’il n’y figure pas déjà (not in).

2. Une classe de 35 élèves doit voir une vidéo. Écrire un programme qui affiche le nom de chaque salle qui a au moins 35 places et un vidéoprojecteur.

   Indice

   Parcourir les paires avec for nom, infos in salles.items():. Le nombre de places est infos[1] et la présence d’un vidéoprojecteur infos[2].

3. Écrire une fonction salles_batiment(batiment) qui renvoie la liste des noms des salles situées dans ce bâtiment. Par exemple, salles_batiment("B") renvoie ["B12", "B14"].

   Indice

   Même parcours qu’à la question 2, en gardant les noms des salles dont le bâtiment, infos[0], est celui demandé. Une liste vide est une réponse correcte quand aucune salle ne convient.

4. Écrire une fonction places_batiment(batiment) qui renvoie le nombre total de places des salles de ce bâtiment. Par exemple, places_batiment("A") renvoie 66.

Correction publiée après la séance.

Exercice 9 - Le foyer des lycéens

À la récréation, le foyer des lycéens vend quelques en-cas. Pour tenir la caisse, l’association écrit un petit programme Python.

Les tarifs sont rangés dans un dictionnaire tarifs : chaque clé est le nom d’un produit (str), et la valeur associée son prix en centimes (int). Compter en centimes évite les erreurs d’arrondi des flottants : en Python, 0.1 + 0.2 ne vaut pas exactement 0.3, alors que 10 + 20 vaut exactement 30.

Question 1

Écrire l’instruction qui crée le dictionnaire tarifs correspondant à cette table :

Question 2

Écrire une fonction en_vente(produit, tarifs) qui renvoie True si produit figure dans tarifs, et False sinon. Par exemple, en_vente("Compote", tarifs) renvoie True et en_vente("Pizza", tarifs) renvoie False.

Question 3

Écrire une fonction prix_moyen(tarifs) qui renvoie le prix moyen, en centimes, des produits vendus. On suppose que tarifs contient au moins un produit. Avec la table de la question 1, prix_moyen(tarifs) renvoie 100.0.

Question 4

Un élève dispose d’une somme comprise entre mini et maxi centimes. Écrire une fonction entre(mini, maxi, tarifs) qui renvoie la liste des produits dont le prix est compris entre mini et maxi, bornes incluses. Par exemple :

entre(85, 130, tarifs)

['Croissant', 'Pain au chocolat', 'Barre de céréales']

Question 5

Une commande est elle aussi un dictionnaire : chaque clé est le nom d’un produit, et la valeur associée le nombre d’exemplaires demandés. Écrire le dictionnaire commande d’un élève qui demande deux croissants, un jus d’orange et trois compotes.

Question 6

Écrire une fonction commande_possible(commande, tarifs) qui renvoie True si tous les produits de la commande sont en vente, et False sinon. Par exemple, commande_possible({"Croissant": 1, "Pizza": 2}, tarifs) renvoie False.

Question 7

Écrire une fonction montant(commande, tarifs) qui renvoie le prix total de la commande, en centimes. On suppose que tous les produits de la commande sont en vente. Avec la commande de la question 5 :

montant(commande, tarifs)

610

L’élève doit donc payer 6,10 €.

Correction publiée après la séance.

Exercice 10 - Tuples comme clés de dictionnaire (géographie)

Les tuples, étant immuables, peuvent servir de clés de dictionnaire. On utilise cette propriété pour associer des données à des coordonnées GPS :

villes = {
    (48.86, 2.35): "Paris",
    (43.30, 5.37): "Marseille",
    (45.76, 4.84): "Lyon",
    (43.60, 1.44): "Toulouse",
}

1. Comment accéder au nom de la ville située aux coordonnées (45.76, 4.84) ?

   Indice

   La clé du dictionnaire est le tuple des coordonnées : on l’écrit entre crochets, comme n’importe quelle clé.

2. Écrire une fonction ville_plus_proche(lat, lon, villes) qui, étant donné une latitude et une longitude, renvoie le nom de la ville la plus proche (en utilisant la distance euclidienne comme approximation).

   Indice

   Parcourir les paires avec items() : chaque clé est un tuple de coordonnées, à déballer. Calculer la distance au point donné et garder le nom de la ville la plus proche, comme dans une recherche de minimum.

   Code à copier puis compléter

   from math import sqrt
   
   def ville_plus_proche(lat, lon, villes):
       plus_proche = None
       dist_min = -1
       for coord, nom in villes.items():
           lat_v, lon_v = coord
           d = sqrt((lat - lat_v) ** 2 + (lon - lon_v) ** 2)
           if dist_min == -1 or d < ...:
               dist_min = ...
               plus_proche = ...
       return plus_proche
   

3. Tester avec les coordonnées (44.0, 3.0). Quelle est la ville la plus proche ?

   Indice

   Appeler ville_plus_proche(44.0, 3.0, villes) et afficher le résultat.

Correction publiée après la séance.