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 implémenté dans un dictionnaire sous la forme suivante :

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

1) Écrire l’instruction qui permet de récupérer le nombre de chiens 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 d'obtenir la liste l_animaux des différentes espèces d'animaux.

4) Écrire la fonction nb_animal(dico:dict, ch:str)->int qui prend un dictionnaire et un nom d’animal en paramètres et renvoie le nombre de cet animal ou 0.

5) Écrire la fonction total() 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 des employés d'une entreprise

Les informations sur les employés d'une entreprise sont stockées dans le dictionnaire suivant :

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

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

2) Ecrire la fonction moy_salaires(dico:dict)->int qui prend un dictionnaire des employers d'une entreprise en paramètre et renvoie la moyenne des salaires des employers de l'entreprise.

dic_employes['emp2']['salaire'] = 3200

def moy_salaires(dico:dict)->int:
    som = 0
    for employe in dico:
        som = som + employe['salaire']
    return som / len(dico)

# Programme principal
dic_employes = { 'emp1': {'nom': 'Jhon', 'salaire': 2500},
                 'emp2': {'nom': 'Emma', 'salaire': 3000},
                 'emp3': {'nom': 'Victor', 'salaire': 1500} }
print(moy_salaires(dic_employes)

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

Exercice 8 : Tableaux contenant majoritairement des 0

Dans cet exercice on s'intéresse à la façon d'implémenter un tableau à deux dimensions contenant majoritairement des 0.

Implémentation n° 1 : Avec une liste de listes.

Implémentation n° 2 : Avec un dictionnaire dont les clés sont des tuples (coordonnées des cases du tableau) et les valeurs associés sont les valeurs du tableau. Dans cette implémentation, on ne met pas les cases qui contiennent des 0.

1 Donner les implémentations correspondant au tableau ci-dessus.

2 Écrire une fonction ll_to_dic(lili) qui prend une liste de listes correspondant à un tableau en paramètre et renvoie le dictionnaire équivalent.

3 Écrire une fonction dic_to_ll(dico) qui prend un dictionnaire correspondant à un tableau en paramètre et renvoie la liste de listes équivalente.