Dictionnaires

Consignes

Dans ce TP, les différents exercices sont indépendants.

Enregistrez chaque fichier dans le dossier [Dictionnaires] sous le nom donné à l'exercice : dictionnaire.py, titanic.py, scrabble.py, occurence.py...

Exercice n°1 : Dictionnaire Français / Anglais

On souhaite réaliser un dictionnaire Français / Anglais, afin que l'utilisateur demande un mot en français et l'ordinateur répond par la traduction anglaise du mot.

Le dictionnaire Python contiendra donc des paires de clé/valeur définies telles que :

  • La clé est un mot en français.

  • La valeur est la traduction anglaise du mot associé à sa clé.

Question

  1. Créer un dictionnaire dico_fr_en de 10 éléments permettant cette traduction.

  2. Rédiger une fonction traduction() qui prend comme argument le terme français et renvoie le terme anglais.

  3. Enrichir le programme avec une question à l'utilisateur pour connaître le mot à traduire. Le programme doit afficher l'ensemble des mots français disponibles.

Indice

Question 1 : Pour créer ce dictionnaire, il faut utiliser la syntaxe vue en cours :

1
dico_fr_en = {
2
    "bonjour": "hello",
3
    "ordinateur": "computer",
4
    ...
5
}

Indice

Question 2 : Le terme français est utilisé en tant que clé, il faut donc vérifier que cette clé existe avant de la réupérer.

Indice

Question 3 : On doit utiliser la fonction input() pour demander un mot à l'utilisateur. Pour consulter l'ensemble des mots disponibles, on devra parcourir le dictionnaire.

Solution

1
dico_fr_en = {
2
    "bonjour": "hello",
3
    "ordinateur": "computer",
4
    "lycée": "high school",
5
    "au-revoir": "goodbye",
6
    "pardon": "sorry",
7
    "bienvenue": "welcome",
8
    "nouveau": "new",
9
    "heure": "hour",
10
    "année": "year",
11
    "mois": "month",
12
    "jour": "day"
13
}
14
15
16
def traduction(mot_fr):
17
    assert mot_fr in dico_fr_en, f"Le mot {mot_fr} n'est pas présent dans le dictionnaire"
18
    return dico_fr_en[mot_fr]
19
20
21
print(traduction("lycée"))
22
23
# Affichage des mots
24
print("Les mots disponibles sont :")
25
for mot in dico_fr_en:
26
    print(f"- {mot}")
27
28
# Demande utilisateur
29
mot = input("Choisissez un mot à traduire en anglais : ")
30
mot_en = traduction(mot)
31
print(f"Le mot {mot} se traduit {mot_en} en anglais.")
32
33
# On a bien une erreur due à l'assert.
34
print(traduction("absent"))
Exercice n°2 : Scrabble
On dispose du dictionnaire suivant, dans lequel chaque lettre de l'alphabet (en majuscules) est associé au nombre de points qui lui est attribué au scrabble :
1
scrabble = {'A': 1, 'B': 3, 'C': 3, 'D': 2, 'E': 1, 'F': 4, 'G': 2, 'H': 4,
2
            'I': 1, 'J': 8, 'K': 10, 'L': 1, 'M': 2, 'N': 1, 'O': 1,
3
            'P': 3, 'Q': 8, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 4,
4
            'W': 10, 'X': 10, 'Y': 10, 'Z': 10}
Télécharger ce fichier qui sera à compléter selon les questions ci-dessous.
scrabble.py [py]
Question
  1. Compléter la définition de la fonction valeur_mot(mot) qui prend en paramètre une chaîne de caractères constituée de lettres majuscules et qui renvoie le nombre de points que rapporterait ce mot au scrabble.
  2. Compléter la définition de la fonction meilleure_lettre() qui prend en paramètre un tableau dont les éléments sont des lettres majuscules et qui renvoie celle ayant la plus forte valeur au scrabble.
    En cas d'égalité, c'est la lettre ayant l'indice le plus élevé dans le tableau qui est renvoyée.
Indice
Question 1 : Le nombre de points d'un mot se calcule grâce à la somme des points de chaque lettre du mot. Il faut donc parcourir toutes les lettres du mot et consulter sa valeur dans le dictionnaire.
Indice
Question 2 : Simple parcours de liste où on regarde chaque éléments dans notre dictionnaire scrabble. La spécificité est que la meilleure lettre doit être sauvegardée dans une variable, et on compare sa valeur à chaque nouvelle lettre dans la liste.
Cela ressemble à la fonction indice_min sauf que :
  • on ne veut pas le minimum mais le maximum ;
  • on ne regarde pas la valeur de l'élément, mais sa valeur via le dictionnaire ;
  • on ne renvoie pas l'indice mais l'élément (la lettre).
Solution
1
scrabble = {'A': 1, 'B': 3, 'C': 3, 'D': 2, 'E': 1, 'F': 4, 'G': 2, 'H': 4,
2
            'I': 1, 'J': 8, 'K': 10, 'L': 1, 'M': 2, 'N': 1, 'O': 1,
3
            'P': 3, 'Q': 8, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 4,
4
            'W': 10, 'X': 10, 'Y': 10, 'Z': 10}
5
6
7
def valeur_mot(mot):
8
    """
9
    Renvoie le nombre de points du mot passé en paramètre
10
    :param mot: une chaîne de caractères constituée de lettres majuscules
11
    :return: nombre de points de ce mot au scrabble
12
    >>> valeur_mot("PYTHON")
13
    20
14
    >>> valeur_mot("JAVASCRIPT")
15
    24
16
    """
17
    score = 0
18
    for lettre in mot:
19
        score += scrabble[lettre]
20
    return score
21
22
23
def meilleure_lettre(liste):
24
    """
25
    Renvoie la lettre qui a le plus forte valeur dans le mot.
26
    :param liste: liste NON VIDE de caractères
27
    :return: caractère de liste ayant la plus forte valeur au scrabble
28
    >>> meilleure_lettre(['B', 'A', 'K', 'D'])
29
    'K'
30
    >>> meilleure_lettre(['A', 'E', 'I'])
31
    'I'
32
    """
33
    # Cette variable enregistre la meilleure lettre. Par défaut, c'est la première de la liste
34
    maximum = liste[0]
35
    for lettre in liste:
36
        # Supérieur ou égal, car en cas d'égalité, on renvoie la dernière rencontrée ayant la plus grande valeur.
37
        if scrabble[lettre] >= scrabble[maximum]:
38
            maximum = lettre
39
    return maximum
40
41
##----- Programme principal et tests -----##
42
if __name__ == '__main__':
43
    import doctest
44
    doctest.testmod()
Exercice n°3 : Titanic
Le Titanic appareille de Southampton (Angleterre) le mercredi 10 avril à 12 h 15.
Six heures plus tard, à 18 h 15, il fait escale dans la rade de Cherbourg. Il y débarque 24 passagers et en embarque 274, amenés par les transbordeurs Nomadic et Traffic. Il appareille à 20 h 10.
Le Titanic fait route vers l'Irlande. Il arrive à Queenstown (aujourdhui Cobh) le 11 avril à 11 h 30. Il débarque 7 passagers et en embarque 120. À 13 h 30, le paquebot appareille et entame sa traversée de l'Atlantique vers New York.
Le 14 avril, à 23 h 40 (heure locale, GMT-3), il percute un iceberg au large de Terre-Neuve. Il sombre le 15 avril à 2 h 20, causant la mort de 1 524 personnes.
(source wikimanche)
On souhaite analyser les données de bord du Titanic lors de cette aventure. On dispose d'une liste Python avec des informations sur les passagers. Chaque élément de la liste est un passager représenté par un dictionnaire. En voici un extrait :
1
passagers = [
2
    {'PassengerId': 1,
3
     'Survived': False,
4
     'Pclass': 3,
5
     'Name': 'Braund, Mr. Owen Harris',
6
     'Sex': 'male',
7
     'Age': 22.0,
8
     'SibSp': 1,
9
     'Parch': 0,
10
     'Ticket': 'A/5 21171',
11
     'Fare': 7.25,
12
     'Embarked': 'S'
13
    },
14
    {'PassengerId': 2,
15
     'Survived': True,
16
     'Pclass': 1,
17
     'Name': 'Cumings, Mrs. John Bradley (Florence Briggs Thayer)',
18
     'Sex': 'female',
19
     'Age': 38.0,
20
     'SibSp': 1,
21
     'Parch': 0,
22
     'Ticket': 'PC 17599',
23
     'Fare': 71.2833,
24
     'Cabin': 'C85',
25
     'Embarked': 'C'
26
    },
27
    ...
28
]
Télécharger ce fichier dans le même dossier que votre code Python.
donnees_titanic.py [py]
Le fichier ci-dessus contient la liste non-exhaustive de 891 passagers. En raison de sa taille importante, son ouverture peut faire planter votre logiciel de programmation. Pensez donc à enregistrer votre travail régulièrement !
En cas d'absence d'information, la clé n'est pas présente ! Vous devez donc vous assurer que la clé existe avant de récupérer sa valeur.
Afin d'importer ces données, ajouter le code suivant dans votre fichier titanic.py :
1
from donnees_titanic import passagers
Désormais, la variable passagers contient cette liste de dictionnaires.
Question
  1. Rédiger un programme qui :
    • affiche le nombre de passagers dans la liste (891) ;
    • vérifie que le passager 54 est :
      Faunthorpe, Mrs. Lizzie (Elizabeth Anne Wilkinson) agée de 29 ans, embarquée à Southampton en classe 2 et a survécu au naufrage ;
    • affiche le nombre de survivants (342).
  2. Sachant qu'il y a trois classes (1, 2 et 3), écrire un programme qui affiche le pourcentage de survivants par classe.
  3. Sachant qu'un passager embarqué à Cherbourg est représenté par la valeur 'C' associée à la clé 'Embarked', écrire un programme qui donne le nombre de survivants embarqués à Cherbourg (18%).
Indice
Question 1 :
  • Le nombre de passagers correspond au nombre d'éléments dans notre liste passagers.
  • Pour chercher un passager, on doit parcourir tous les éléments de la liste et vérifier pour chaque élément (qui est donc un dictionnaire) si la valeur de clé 'PassengerId' vaut 54, auquel cas on peut afficher les informations.
  • De même, il faut parcourir toutes les données, en stockant dans une variable (initialement initialisée à zéro) le nombre de survivants.
Indice
Question 2 : Il faut encore parcourir tous les passagers, et stocker dans des variables le nombre de passagers par classe et le nombre de survivants par classe. Ensuite, un simple calcul de pourcentage, et le tour est joué !
Indice
Question 3 : Et c'est encore pareil ! Il faut parcourir tous les passagers, et stocker dans des variables le nombre de passagers embarqués à Cherbourg et le nombre de survivants embarqués à Cherbourg.
Solution
1
from donnees_titanic import passagers
2
3
4
# Question 1
5
6
print(f"Il y a {len(passagers)} passagers dans cette liste.")
7
8
id_recherche = 54
9
for passager in passagers:
10
    if passager['PassengerId'] == id_recherche:
11
        print(passager)
12
13
nb_surviants = 0
14
for passager in passagers:
15
    if passager['Survived']:
16
        nb_surviants += 1
17
print(f"Il y a {nb_surviants} survivants dans cette liste.")
18
19
20
# Question 2
21
22
nb_surviants_par_classe = [0, 0, 0, 0]
23
nb_passagers_par_classe = [0, 0, 0, 0]
24
# Par simplicité, la classe 1 sera à l'indice 1, idem pour la classe 2 et la classe 3.
25
for passager in passagers:
26
    if 'Pclass' in passager and 'Survived' in passager:
27
        nb_passagers_par_classe[passager['Pclass']] += 1
28
        if passager['Survived']:
29
            nb_surviants_par_classe[passager['Pclass']] += 1
30
print("Les pourcentages de survie sont :")
31
for classe in [1, 2, 3]:
32
    print(f"- Classe {classe} : {nb_surviants_par_classe[classe] * 100 // nb_passagers_par_classe[classe]}%")
33
34
35
# Question 3
36
37
nb_passager_cherbourg = 0
38
nb_survivants_cherbourg = 0
39
for passager in passagers:
40
    if 'Embarked' in passager:
41
        if passager['Embarked'] == 'C':
42
            nb_survivants_cherbourg += 1
43
        nb_passager_cherbourg += 1
44
print(f"{nb_survivants_cherbourg * 100 // nb_passager_cherbourg}% des passagers embarqués à Cherbourg ont survécu.")
Exercice bonus : Compter des occurrences
On souhaite écrire un programme qui compte les occurences de mots dans un texte afin de connaître les mots les plus fréquents.
Question
  1. Compléter la définition de la fonction occurences(sequence) en respectant les spécifications.
  2. Compléter la définition de la fonction compte_mots(phrase) en respectant les spécifications.
  3. Télécharger le texte du « Petit Chaperon Rouge » ci-dessous dans le même dossier que le code Python.
    Dans le programme principal, importer ce texte puis écrire les instructions nécessaires pour afficher, dans la console, chaque mot de ce texte suivi de son nombre d'occurrences dans le texte.
  4. Compléter la définition de la fonction compte_tous_mots(phrase) en respectant ses spécifications.
    Appliquer ensuite, dans le programme principal, cette fonction au texte du « Petit Chaperon Rouge ».
  5. Compléter la définition de la fonction plus_frequent(dico, longueur) qui prend en paramètre un dictionnaire dont les clés sont des chaînes de caractères et un entier strictement positif longueur.
    Cette fonction renvoie un tableau constitués des chaînes de caractères de taille la longueur spécifiée et associées à la plus grande valeur dans le dictionnaire.
Télécharger ce fichier dans le même dossier que votre code Python.
Petit_Chaperon_Rouge_Sans_Ponctuation.txt [txt]
Indice
Question 2 : La méthode .split() pourrait vous aider.
Cf cette page pour plus de détails...
Indice
Question 3 : Si f est le nom d'une variable faisant référence à un fichier texte, alors f.read() renvoie le contenu de ce fichier texte sous la forme d'une unique chaîne de caractères.
On utilisera le code f = open('nom_du_fichier') pour obtenir cette variable.
Indice
Question 5 : C'est un algorithme de recherche du maximum légèrement modifié :
  • lorsqu'on rencontre un nouveau maximum, on ré-initialise le tableau ;
  • lorsqu'on rencontre un mot de même « valeur », on l'incorpore au tableau.
Solution
1
def occurrences(sequence):
2
    """
3
    Compte les occurences dans une liste
4
    :param sequence: Une séquence ordonnée (tuple, list ou str)
5
    :return: dictionnaire tel que :
6
            - les clefs sont les valeurs de la séquence
7
            - les valeurs sont les occurrences de ces clefs dans la séquence
8
    >>> occurrences([4, 2, 3, 4, 1, 4, 3, 4])
9
    {4: 4, 2: 1, 3: 2, 1: 1}
10
    >>> occurrences("abracadrabra")
11
    {'a': 5, 'b': 2, 'r': 3, 'c': 1, 'd': 1}
12
    """
13
    dico = {}
14
    for valeur in sequence:
15
        if valeur in dico:
16
            # Si la valeur est déjà dans le dico, on incrémente
17
            dico[valeur] += 1
18
        else:
19
            # Sinon on l'ajoute
20
            dico[valeur] = 1
21
    return dico
22
23
24
def compte_mots(phrase):
25
    """
26
    Compte les occurences de mots dans une chaîne de caractères
27
    :param phrase: une chaîne de caractère comportant des espaces
28
    :return: dict – dictionnaire tel que :
29
            - les clés sont les mots de la chaine
30
            - les valeurs sont les occurrences des mots
31
    >>> compte_mots("a b a c ab")
32
    {'a': 2, 'b': 1, 'c': 1, 'ab': 1}
33
    """
34
    # On découpe la phrase à chaque espace (méthode split)
35
    liste = phrase.split()
36
    # On se sert de la fonction précédente
37
    return occurrences(liste)
38
39
40
def compte_tous_mots(phrase):
41
    """
42
    Compte le nombre de mots selon la taille dans une chaîne de caractères
43
    :param phrase: une chaîne de caractère comportant des espaces
44
    :return: dict – dictionnaire tel que :
45
            - les clés sont des entiers (longueurs possibles pour un mot)
46
            - les valeurs sont les occurrences des mots ayant cette longueur
47
    >>> compte_tous_mots("a b a c ab")
48
    {1: 4, 2: 1}
49
    """
50
    dico_mots = compte_mots(phrase)
51
    dico_taille = {}
52
53
    for mot, nombre in dico_mots.items():
54
        taille = len(mot)
55
        if taille in dico_taille:
56
            # Si la taille du mot est déjà dans le dico, on ajoute son nombre d'occurences
57
            dico_taille[taille] += nombre
58
        else:
59
            # Sinon on le rajoute
60
            dico_taille[taille] = nombre
61
62
    return dico_taille
63
64
def plus_frequent(dico, longueur):
65
    """
66
    Renvoie les mots les plus fréquents de la longueur donnée. En cas d'égalité en fréquence, on renverra tous les mots
67
    de cette égalité.
68
    :param dico: dictionnaire de chaines avec leur occurence
69
    :param longueur: longueur à regarder pour trouver les mots
70
    :return: string – chaine de taille longueur ayant
71
             l'occurence la plus grande.
72
    >>> plus_frequent({'a': 3, 'b': 2, 'c': 3, 'ab': 5}, 1)
73
    ['a', 'c']
74
    """
75
    # Intitialisation à une liste vide et une fréquence nulle
76
    maximum = []
77
    frequence_maximum = 0
78
79
    for mot in dico:
80
        # Vérification de la contrainte de longueur
81
        if len(mot) == longueur:
82
            # Vérification de la fréquence du mot
83
            if dico[mot] > frequence_maximum:
84
                # Si plus grand, on remet à zéro
85
                maximum = [mot]
86
                frequence_maximum = dico[mot]
87
            elif dico[mot] == frequence_maximum:
88
                # Si égalité, on ajoute dans notre liste de maximums
89
                maximum.append(mot)
90
            # Sinon, on ne fait rien
91
92
    return maximum
93
94
95
##----- Programme principal et tests -----##
96
if __name__ == '__main__':
97
    import doctest
98
    doctest.testmod()
99
    
100
    # Importation du fichier du "Petit Chaperon Rouge"
101
    f = open("Petit_Chaperon_Rouge_Sans_Ponctuation.txt")
102
    texte = f.read()
103
104
    # Question 3
105
    dico = compte_mots(texte)
106
    for mot, nombre in dico.items():
107
        print(f"{mot} -> {nombre}")
108
109
    # Question 4
110
    print(compte_tous_mots(texte))
111
112
    # Question 5
113
    for longueur in range(13, 0, -1):
114
        print(f"Mot(s) de longueur {longueur} les plus fréquents : {plus_frequent(dico, longueur)}.")