Feuille 5 : Dictionnaires

Rappels de la syntaxe :

dico = {clé_a: valeur_a, clé_b: valeur_b, ...}

Exercice 1 : Les animaux de la ferme

L’inventaire des animaux d’une ferme est stocké dans un dictionnaire : d = {'poule': 12, 'chien':2, 'moutons':34}

1) Écrire l’instruction qui permet de récupérer le nombre de chiens de la ferme dans la variable nb_chiens.

2) La ferme accueille 5 chevaux. Écrire l’instruction qui permet de mettre à jour le dictionnaire.

3) Écrire l’instruction qui permet de stocker la liste des noms des animaux présents dans la variable l_animaux.

4) Écrire le code d’une fonction nb_animal(ch:str) -> int qui prend un nom d’animal en paramètre et renvoie le nombre de cet animal ou 0.

5) Écrire le code (plusieurs lignes) qui permet de connaitre le nombre total d’animaux de la ferme.

d = {'poule': 12, 'chien':2, 'moutons':34}

# Question 1)
nb_chiens = d['chien']

# Question 2)
d['cheval'] = 5

# Question 3)
l_animaux = list(d.keys())

# Question 4)
def nb_animal(ch:str) -> int:
    if animal in d:
        return d[animal]
    else:
        return 0

# Question 5)
nb_animaux = 0
for animal in d:
    nb_animaux = nb_animaux + d[animal]

Exercice 2 : Affichage propre

Écrire une fonction qui prend un dictionnaire en paramètre et affiche, ligne par ligne, toutes les paires clé/valeur de ce dictionnaire.

def affiche_v1(dico:dict):
for c, v in dico.items():
    print("clé : " + str(c) + " => valeur : " + str(v))

def affiche_v2(dico:dict):
for cle in dico:
    print("clé : " + str(cle) + " => valeur : " + str(dico[cle]))

Exercice 3 : Inversion clé/valeur

Écrire une fonction qui prend un dictionnaire en paramètre et renvoie un nouveau dictionnaire dans lequel les valeurs sont devenues les clés et les clés sont devenues les valeurs.

def inverse_v1(d:dict) -> dict:
    d2 = {}
    for c, v in d.items():
        d2[v] = c
    return d2

def inverse_v2(d:dict) -> dict:
    d2 = {}
    for c in d:
        d2[d[c]] = c
    return d2

Exercice 4 : Histogramme d’un texte

Écrire une fonction histo(ch: str) -> dict qui prend un texte en paramètre et renvoie un dictionnaire dont les clés sont les caractères du texte et les valeurs, le nombre d’occurrences de chaque caractère.

🖳 Exemple (en ligne de commande) :

>>> histo("bonjour")
{'b': 1, 'o': 2, 'n': 1, 'j': 1, 'u':1, 'r': 1}

def histo(chaine:str):
    dico = {}
    for lettre in chaine:
        if lettre in dico:
            dico[lettre] += 1
        else:
            dico[lettre] = 1
    return dico

Exercice 5 : Salaires de employers d'une entreprise

Les informations concernant les employers d'une entreprise sont stockées dans un dictionnaire dont un extrait est donné ci-dessous :

dic_employers = {
   'emp1': {'nom': 'Jhon', 'salaire': 2500},
   'emp2': {'nom': 'Emma', 'salaire': 3000},
   'emp3': {'nom': 'Victor', 'salaire': 1500}
}

1) Ecrire la ligen de code qui permet de modifier le salaire d'Emma pour qu'il devienne 3200.

2) Ecrire la ligne de code qui permet de calculer la moyenne des salaires des employers de l'entreprise.

Exercice 6 : Premier ou non !

1) Écrire la fonction diviseurs(n:int) -> list qui prend un nombre entier n en paramètre et renvoie une liste des diviseurs de n.

2) Écrire la fonction est_premier(n:int) -> bool qui prend un nombre entier n en paramètre et renvoie True si n est un nombre premier et False sinon.

3) Écrire la fonction dico_est_premier(n:int) -> dict qui prend un nombre entier n en paramètre et renvoie un dictionnaire dont les clés sont les entiers de 1 à n et les valeurs associées, des booléens indiquant si l’entier est premier.

🖳 Exemple (en ligne de commande) :

>>> dico_est_premier(7)
{1: False, 2: True, 3: True, 4: False, 5: True, 6: False, 7: True}

def diviseurs(n:int) -> list:
    return [i for i in range(1, n//2+1) if n % i == 0]

def est_premier(n:int) -> bool:
    if len(diviseurs(n)) == 2:
        return True
    else:
        return False

def dico_premiers(n:int) -> dict:
    dico = {}
    for i in range(1,n+1):
        dico[i] = est_premier(i)
    return dico

Exercice 7 : Codage

Le but de cet exercice est de coder un texte en faisant correspondre un caractère à un autre.

Pour cet exercice, dans le module random, seule la fonction randint est autorisée. On rappelle que la méthode pop(i) appliquée à une liste supprime et renvoie le i^ème élément de la liste.

On dispose de la variable liste_caracteres = ['a', 'b', 'c' ... '!', '.'] contenant tous les caractères avec lesquels on souhaite travailler.

1) Écrire la fonction creer_dico_pour_codage() -> dict qui renvoie un dictionnaire qui permet le codage d’une chaine de caractères en associant un caractère à un autre. Autrement dit, la fonction doit renvoyer un dictionnaire dont les clés sont les caractères de la liste liste_caracteres et les valeurs les caractères de la même liste dans un ordre différent.

2) Écrire une fonction qui prend une chaine de caractères et un dictionnaire de codage en paramètre et renvoie la chaine de caractères encodée.

3) Écrire une fonction qui prend une chaine de caractères encodée et un dictionnaire de codage en paramètre et renvoie la chaine de caractères décodée.

from random import randint

liste_caracteres = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
           'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
           's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '!', '.']

def dico_codage():
    l = list(liste_caracteres) # Créer une copie profonde de liste_c
    dico = {}
    for c1 in liste_caracteres:
        c2 = l.pop(randint(0, len(l)-1))
        dico[c1] = c2
    return dico

def encode(chaine, dico):
    chaine_codee = ""
    for c in chaine:
        chaine_codee = chaine_codee + dico[c]
    return chaine_codee

def decode(chaine_codee, dico):
    dico_inv = {}
    # Création du dictionnaire inversé
    for cle in dico:
        dico_inv[dico[cle]] = cle
    # Décodage de la chaine codée
    chaine_decodee = ""
    for c in chaine_codee:
        chaine_decodee = chaine_decodee + dico_inv[c]
    return chaine_decodee