EXERCICES Dictionnaires

Exercice 1 :
On considère
mots=['eddard','catelyn','robb','sansa','arya','brandon','rickon','theon','rorbert','cersei','tywin','jaime','tyrion','shae'
,'bronn','lancel','joffrey','sandor','varys','renly','a']
Ecrire une fonction mots_lettre_position qui retourne tous les mots de la liste qui ont un « y » en seconde
position :
def mots_lettre_position(liste,lettre,position):
resultat = []
for mot in liste:
if len(mot) > position and mot[position] == lettre:
resultat.append(mot)
return resultat

Exercice 2 :
Soit le dictionnaire : d={'nom' : 'Dupuis', 'prenom' : 'Jacque', 'age' : 30}
a. Corriger l’erreur dans le prénom, la bonne valeur est ’Jacques’. d["prenom"] = "Jacques"
b. Afficher la liste des clés du dictionnaire. d.keys()
c. Afficher la liste des valeurs du dictionnaire. d.values()
d. Afficher la liste des couples clé/valeur du dictionnaire. d.items()
e. Faire un programme qui permet d’écrire la phrase « Jacques Dupuis a 30 ans ».
print(d["prenom"], d["nom"], "a", d["age"], "ans")

Exercice 3 :

dico = {"Au":{"Te/Tf":(2970, 1063),

"N/M atomique":(79, 196.967)
},
"Ga":{"Te/Tf":(2237, 29.8),
"N/M atomique":(31, 69.72)
}
}

Exercices dictionnaires Page 1 sur 3

Exercice 4 :

On vous donne la fonction points(mot) ci-dessous, incomplète, selon les spécifications suivantes :

 points(mot) prend en paramètre une chaîne de caractère composée de lettres majuscules;

 points(mot) renvoie un entier égal au nombre de points au scrabble de ce mot.

def points(mot):

scrabble={"A":1,"B":3,"C":3,"D":2,"E":1,"F":4,"G":2,"H":4,"I":1,"J":8,"K":10,"L":1,"M":2
,"N":1,"O":1,"P":3,"Q":8,"R":1,"S":1,"T":1,"U":1,"V":4,"W":10,"X":10,"Y":10,"Z":10}

Compléter la fonction points(mot).

Exercice 5 :
On vous donne ci-dessous la fonction incomplète occurences(L) avec les spécifications suivantes :

def occurrences(liste):
dict={}

 La fonction occurences(L) prend en paramètre une liste

 La fonction occurences(L) renvoie un dictionnaire dont les clés sont les éléments de la liste et les valeurs le
nombre de fois que l'élément apparaît.

On vous donne également l’algorithme de la fonction occurences(L) :créer un dictionnaire vide

Parcourir la liste.
Pour chaque valeur de la liste,
si elle est dans le dictionnaire
ajouter 1 à sa valeur,
sinon
créer un dans le dictionnaire un nouvel élément : (valeur : 1).
Renvoyer le dictionnaire

def occurences(L):
dict = {}
L = []
for i in L:
if i in dict:
L[i] += 1
else:
dict[valeur] = 1

Exemple : occurrences([1,3,2,1,4,1,2,1]) peut retourner le dictionnaire {1:4,2:2,3:1,4:1}.

Exercices dictionnaires Page 2 sur 3

Exercice 6 :

Les réponses correctes d'un QCM sont stockées dans un dictionnaire nommé reponses_valides. Les clés sont des chaînes
de caractères de la forme "Q1". Les valeurs possibles sont des chaînes de caractères correspondant aux quatre réponses
"a","b","c","d".

Exemple : reponses_valides = {"Q1":"c","Q2":"a","Q3":"d","Q4":"c","Q5":"b"}

Les réponses données par Bob sont stockées dans le dictionnaire reponses_Bob dont voici un exemple possible :

reponses_Bob = {"Q1":"b","Q2":"a","Q3":"d","Q5":"a"}

Lorsque Bob n'a pas répondu à une question, il n'y a pas de clef correspondant au nom de l'exercice.

La notation d'un QCM est la suivante : 3 points par réponse correcte, -1 point par réponse incorrecte et 0 si l'on n'a pas
répondu.

Compléter la fonction incomplète correction_QCM_Bob(reponses_Bob,reponses_valides) qui, à partir des

dictionnaires reponses_Bob et reponses_valides passées en paramètres renvoie le nombre de points obtenus au QCM par
Bob.
def correction_QCM_Bob(reponses_Bob,reponses_valides):

Exercice 7 : (difficile, à faire ensemble après avoir étudier la fonction enumerate() )

Exercices dictionnaires Page 3 sur 3

Exercice 8 : (difficile, à faire lorsque le reste est traité)

Les dictionnaires constituent un outil très élégant pour construire des histogrammes.

Supposons par exemple que nous voulions établir l'histogramme qui représente la fréquence d'utilisation de
chacune des lettres de l'alphabet dans un texte donné. L'algorithme permettant de réaliser ce travail est
extraordinairement simple si on le construit sur base d'un dictionnaire :

Nous commençons par créer un dictionnaire vide : lettres. Ensuite, nous allons remplir ce dictionnaire en
utilisant les caractères de l'alphabet en guise de clés. Les valeurs que nous mémoriserons pour chacune de ces
clés seront les fréquences des caractères correspondants dans le texte. Afin de calculer celles-ci, nous
effectuons un parcours de la chaîne de caractères texte. Pour chacun de ces caractères, nous interrogeons le
dictionnaire à l'aide de la méthode get(), en utilisant le caractère en guise de clé, afin d'y lire la fréquence
déjà mémorisée pour ce caractère. Si cette valeur n'existe pas encore, la méthode get() doit renvoyer une
valeur nulle. Dans tous les cas, nous incrémentons la valeur trouvée, et nous la mémorisons dans le
dictionnaire à l'emplacement qui correspond à la clé (c'est-à-dire au caractère en cours de traitement).

Pour fignoler notre travail, nous pouvons encore souhaiter afficher l'histogramme dans l'ordre alphabétique.
Pour ce faire, nous pensons immédiatement à la méthode sort(), mais celle-ci ne peut s'appliquer qu'aux
listes. Qu'à cela ne tienne ! Nous avons vu comment nous pouvions convertir un dictionnaire en une liste de
tuples :

A vous :

1. Vous avez à votre disposition un fichier texte quelconque (pas trop gros). Écrivez un script qui compte
les occurrences de chacune des lettres de l'alphabet dans ce texte (on ne tiendra pas compte du
problème des lettres accentuées)..
2. Modifiez le script ci-dessus afin qu'il établisse une table des occurrences de chaque mot dans le texte.
Conseil : dans un texte quelconque, les mots ne sont pas seulement séparés par des espaces, mais
également par divers signes de ponctuation. Pour simplifier le problème, vous pouvez commencer par
remplacer tous les caractères non-alphabétiques par des espaces, et convertir la chaîne résultante en
une liste de mots à l'aide de la méthode split().
3. Vous avez à votre disposition un fichier texte quelconque (pas trop gros). Écrivez un script qui analyse
ce texte, et mémorise dans un dictionnaire l'emplacement exact de chacun des mots (compté en
nombre de caractères à partir du début). Lorsqu'un même mot apparaît plusieurs fois, tous ses
emplacements doivent être mémorisés : chaque valeur de votre dictionnaire doit donc être une liste
d'emplacements.

Exercices dictionnaires Page 4 sur 3