Aller au contenu

TD - Dictionnaires⚓︎

Exercice 1 : Création dictionnaire

Lesquelles des définitions suivantes sont valides pour un dictionnaire ?

dico1 = {1: "un", "deux": 2, 3.0: "trois", "trois": 3, (4, 8): [4, 5, 6, 7]}
cinq = 6
dico2 = {cinq: "6", "sept": [8], [9]: 10.0}
dico3 = dict([(1,(2,3)), ((4,5), 6), ("sept", "huit"), (9.0, "dix" + str(11) + str(12))])
dico4 = dict([("un", 2.0), (3, dico1), ("dico2", dico3), (dico3, "dico3")])
dico5 = dict([("un", 2.0), (3, dico1), ("dico2", dico3), ("Jean-Paul Sartre")])

Exercice 2 : Création/Manipulation dictionnaire

Voici un bout de code travaillant sur un dictionnaire :

d = {}
d['Cours'] = "NSI"
d['Salle'] = "214"
d['Contenu'] = ['Valeurs et affectation',
                'Boucles',
                'Fonctions', 
                'Itérables et mutabilité',
                'Dictionnaires et Ensembles']
d['Langage'] = 'Javascript'
d['Langage'] = 'Python'
del d['Salle']
  1. Combien d\'entrées y a-t-il dans d ? Vérifier avec un bout de code.
  2. Ecrire un bout de code qui affiche le contenu du cours, un point par ligne.

Exercice 3 : Lecture programme

Qu'affiche le programme ci-dessous sur la console si on entre la valeur 14 ?

d = {}
for i in range(100):
    d[i] = list(range(i))
nb = int(input())
if nb in d:
    print(d[nb])

Exercice 4 : Erreurs

Donnez la ou les erreurs dans le code suivant:

d = {}
d['123'] = 1
d[[1,2,3]] = 2
d[(12, 3)] = 3
d[123] = 4
print(d['0123'])

Exercice 5 : Parcours d'un dictionnaire

Voici une fonction qui prend en paramètre un dictionnaire qui associe des entiers à une liste d'entiers.

def fonction_secrete(d):
    cpt = 0
    for n in d:
        flag = False
        for x in d[n]:
            flag = flag or (x % 2 == 0)
        if flag:
            cpt += n
    return cpt
  1. Que renvoie fonction_secrete(d = { 1 : [1, 3], 2 : [5, 7], 9 : [4, 6, 5], 6 : [5, 3, 2]})?
  2. Ecrire une fonction qui prend en entrée un dictionnaire (exactement comme la fonction précédente) et qui compte le nombre total des nombres pairs dans les valeurs du dictionnaire.
  3. Modifier la fonction pour que, en prenant un autre paramètre k, elle renvoie le nombre total des nombres divisibles par k.

Vous pouvez utiliser les deux cases ci-dessous et tester avec le dictionnaire dico_secret donné.

dico_secret = {1: [1, 2, 3, 4, 5],
            2: [2, 4, 6, 8, 10],
            3: [3, 6, 9, 12, 15],
            42: [1, 2, 3, 6, 7, 14, 21, 42],
            -5: [4, 4, 4, 4, 5, 5, 5, 5]}

Exercice 6 : Copie de dictionnaires

Qu'affiche le programme suivant:

d1 = {'a': 0 , 'b': 1} 
d2 = d1 
d2['a'] += 1 
print(d1, d2)

Comment affecter une copie du dictionnaire d1 dans le dictionnaire d2 ?

Exercice 7 : Dictionnaires et listes

Qu'affiche le programme ci-dessous ?

d = {}
lst = [1, 2, 3, 4, 5]
d['a'] = lst
d['b'] = lst
d['c'] = d['a']
d['d'] = lst * 1
lst[0] = 5
d['c'][1] = 3
d['d'][2] = 10
print(d['a'], d['b'], d['c'], d['d'])

Exercice 8 : Dictionnaires et fonctions

Quelle sont les valeurs associées aux variables d et e à la fin de l'exécution du code ci-dessous ?

def init(d, e):
    e = {}
    for x in d:
        e[x] = d[x]
        d[x] = 0

d = {'a': 'bbb', 'b': 15, (12, 4): []}
e = [1, 2, 3]
init(d, e)

Exercice 9 : Fréquences

Écrivez une fonction freqChaine qui prend une chaîne de caractères en paramètre et renvoie un dictionnaire contenant pour chaque lettre de la chaîne son nombre d'occurrences. Par exemple :

>>> freq_chaine('abbabba!')
{'a': 3, 'b': 4, '!': 1}

Exercice 10 : Compteur pour les triples

On vous donne une liste d\'entiers. Composer une fonction qui renvoie un dictionnaire qui associe chaque nombre avec son nombre d\'occurrences, mais seulement pour les nombres divisibles par 3.

Vous pouvez tester votre fonction sur la liste suivante.

liste_de_triples = [1, 2, 3, 4, 5, 6, 7, 8, 9, 42, 42, 42, 42]

Exercice 11 : Conversions

  1. Écrire, sans utiliser la méthode items(), une fonction dict_vers_list(dico) recevant en paramètre un dictionnaire et renvoyant une liste de ses couples (cle, valeur).
  2. Écrire, sans utiliser la fonction dict(), une fonction list_vers_dict(lst) recevant en paramètre une liste de couples (cle, valeur) et renvoyant le dictionnaire correspondant.

Exercice 12 : Fusion de dictionnaires

On manipule des dictionnaires dont les valeurs sont toutes des entiers. Écrire une fonction somme(d1, d2) recevant deux dictionnaires de ce type et renvoyant un dictionnaire où chaque clé apparaissant dans d1 ou dans d2 (mais pas les deux) est associée à la valeur correspondante, et chaque clé commune à d1 et d2 à la somme des valeurs associées. La fonction ne doit pas avoir d'effet secondaire.

Exemple :

>>> somme({'a': 1, 'b': 2, 'c': 1}, {'b': 4, 'e': 2})
{'a': 1, 'b': 6, 'c': 1, 'e': 2}

Exercice 13 : Inversion de dictionnaire

Écrire une fonction inverse_dict(dico) renvoyant un nouveau dictionnaire dont les clés sont les valeurs de dico et les valeurs sont les listes de clés correspondantes. On supposera que toutes les valeurs de dico sont immutables. La fonction ne doit pas avoir d'effet secondaire.

Exemple :

>>> inverse_dict({'a': 1, 'b': 2, 'c': 1})
{1: ['a', 'c'], 2: ['b']}

Exercice 14 : Compte Mots

Compter le nombre d\'occurrences de chaque mot dans un texte, et renvoyer un dictionnaire avec les mots comme les clés et le nombre d\'occurrences comme valeurs. La fonction doit être appelée compte_mots. Supposons qu\'on l\'exécute sur le code suivant.

texte = '''Le terme Python est un nom vernaculaire ambigu désignant en 
français plusieurs espèces de serpents appartenant à différents genres des 
familles des Pythonidae et des Loxocemidae. Python est aussi un langage de
programmation maîtrisé par tous les élèves de NSI du lycée Condorcet.'''

dico = compte_mots(texte)
print("Le mot Python est présent", dico['Python'], "fois")
print("Le mot NSI est présent", dico['NSI'], "fois")

Le résultat suivant doit être affiché :

Le mot Python est présent 2 fois
Le mot NSI est présent 1 fois

Indication : Vous pouvez utiliser la constante string.punctuation et les fonctions replace et split pour manipuler les chaînes de caractères

Exercice 15 : Fermeture de classe

Le secrétariat a une liste des élèves de NSI, avec les classes correspondantes. Suite à des difficultés de faire les emplois du temps, on veut regrouper les élèves dans une même classe. Composer une fonction ferme_classe pour mettre à jour ces informations. Votre fonction prendra trois argument : un dictionnaire qui enregistre les anciennes informations, le nom de la classe fermant, et le nom de la classe accueillant ces élèves. La fonction doit renvoyer un nouveau dictionnaire comme liste mise à jours. Vous pouvez tester votre fonction sur les données suivantes :

locaux = {'AIT DJOUDI OUFELLA Juba':'1ERE3','BEDREDDINE-CHAUBARD Mathys':'1ERE2','BEN SASSI Bibros':'1ERE5', 'BENKHALED Amine' : '1ERE2', 'CERIT Ceren' : '1ERE5'}

Exercice 16 : Faire un dictionnaire avec un dictionnaire !"

On vous fournit un dictionnaire (par exemple, le grand Larousse) sous forme de dict en Python, et vous allez écrire un programme qui fait la recherche d\'un mot dans ce dictionnaire. Pour cela, vous allez écrire des fonctions qui reçoivent en paramètre le dictionnaire fourni et la requête de l\'utilisateur (un mot exprimé sous forme de chaîne de caractères) et renvoient la définition du mot recherché.

  1. Écrire une fonction recherche_mot_complet(dico, m) qui prend un dictionnaire dico et un mot complet m et qui renvoie l\'entrée du dictionnaire concernant le mot recherché. Si le mot n\'existe pas dans dico, alors on renvoie une chaîne vide.
  2. Écrire une fonction recherche_mot_partiel(dico, m) qui prend le dictionnaire dico et un mot partiel m et qui renvoie un petit dictionnaire contenant tous les mots commençant par m accompagnés de leur définition. Quand rien n\'est trouvé, la fonction doit renvoyer un dictionnaire vide. Vous pourrez vous servir de la méthode find des chaînes de caractères.

Voici un exemple d\'utilisation de ces fonctions :

d = {'chercheur': "une personne dont personne ne sait ce qu'elle fait",
    'étudiant': "une personne qui ne sait pas ce qu'elle fait",
    'ingénieur': "une personne qui pense qu'elle sait ce qu'elle fait",
    'enseignant': "une personne qui sait que l'ingénieur ne sait pas ce qu'il fait",
    'enseignement': "une procédure pour convertir un étudiant en un non-étudiant",
    'étudier': "une forme d'enrichissement, principalement en cafféine"}

print('étudiant -->', recherche_mot_complet(d, 'étudiant'))
print('secrétariat -->', recherche_mot_complet(d, 'secrétariat'))
print('ensei -->', recherche_mot_partiel(d, 'ensei'))
print('cher -->', recherche_mot_partiel(d, 'cher'))
print('mat -->', recherche_mot_partiel(d, 'mat'))

Voici le résultat attendu :

étudiant --> une personne qui ne sait pas ce qu'elle fait
secrétariat -->
ensei --> {'enseignant': "une personne qui sait que l'ingénieur ne sait pas ce qu'il fait", 'enseignement': 'une procédure pour convertir un étudiant en un non-étudiant'}
cher --> {'chercheur': "une personne dont personne ne sait ce qu'elle fait"}
mat --> {}