Dictionnaires par clés et valeurs

Objectifs :

À la fin de cette séquence vous serez capable de manipuler un dictionnaire.

Un mini-projet

Créer un jeu appelé Le Pendu :
Le pendu est un jeu consistant à trouver un mot en devinant quelles sont les lettres qui le composent. Le jeu se joue traditionnellement à deux, avec un papier et un crayon, selon un déroulement bien particulier.
Déroulement du jeu :
Les deux joueurs dans cet exemple s'appellent Stéphane et Julien :

• Julien pense à un mot et dessine une rangée de tirets, chacun correspondant à une lettre de ce mot.
• Stéphane annonce une lettre.
• La lettre fait-elle partie du mot ?
  • Oui : Julien l'inscrit à sa place autant de fois qu'elle se trouve dans le mot.
  • Non : Julien dessine le premier trait du pendu.
• Le jeu se poursuit jusqu'à ce que :
  • Stéphane gagne la partie en trouvant toutes les lettres du mot et/ou en le devinant correctement.
  • Julien gagne la partie en complétant le dessin du pendu.

1. Définition et syntaxe

Un dictionnaire est un ensemble de couples clé – valeur séparés par des virgules. Cet ensemble étant encadré par des accolades. Un deux-points ( : ) sépare chaque clé de sa valeur associée.
Contrairement aux séquences (listes, chaines de caractères, tuples), un dictionnaire est une collection non ordonnée.
On accède aux valeurs d’un dictionnaire par des clefs.
Un dictionnaire est un objet itérable et mutable (on peut modifier un dictionnaire en place).

Les dictionnaires sont aussi souvent appelés tables de recherche ou tableaux associatifs.

Les dictionnaires sont l'une des structures de données les plus importantes et les plus fréquemment utilisées en informatique.

dico_info = {
            "ram" : "mémoire à accès aléatoire",
            "web": "ensemble de fichiers liés entre eux par des hyperliens et accessibles via l'Internet",
            "hyperlien": "chaîne de caractères qui constitue un lien vers une autre page",
            "cryptographie":"art du chiffrement",
            "algorithmique": "étude des algorithmes",
            "protocole":"ensemble de règles qui régissent la communications entre couches homologues"
            }
#ici une clé un mot et sa définition la valeur associée.

type(dico_info)

"ram" est une clé et "mémoire à accès aléatoire" est sa valeur associée.
"web" est une clé et "ensemble de pages web" est sa valeur associée...

2. Manipuler les dictionnaires

Un dictionnaire vide

d = {}

Nombre d'entrées (nombre d'items)

C'est le nombre de paires clé - valeur contenus dans le dictionnaire.

len(dico_info)

Accéder aux valeurs d'un dictionnaire

Les éléments d'un dictionnaire ne sont pas ordonnés. Autrement dit, un dictionnaire est affiché sans ordre particulier.
Une valeur est extraite d'un dictionnaire en spécifiant sa clé associée entre crochets ( [ ] )

# Quelle est la définition du mot algorithmique (quelle est la valeur associée à algorithmique) ?
dico_info["algorithmique"]

dico_info["web"]

Si on fait référence à une clé qui n'est pas dans le dictionnaire, il se produit une erreur, KeyError :

#Exemple :
dico_info["programmation"]

Test d'appartenance d'une clé à un dictionnaire

# Le mot hyperlien est-il dans dico_info
"hyperlien" in dico_info

"réseau" in dico_info

Attention : L'opérateur in ne fonctionne pas avec les valeurs !

"mémoire à accès aléatoire" in dico_info

Itérer sur les clés d'un dictionnaire

Itérer sur un dictionnaire revient à itérer sur les clés du dictionnaire.

#Parcourir les clés d'un dictionnaire
for mot in dico_info:
    print(mot)

Application 1 :

On donne le dictionnaire suivant :

annuaire = {('Martin','Olivier'):'0689514311',
            ('Nana','Hozier'):'0710342578', 
            ('Martin', 'Naïm'): '0666666665'
           }

Écrire un programme qui parcourt et affiche le prénom suivi du nom puis " a pour numéro de téléphone " et le numéro de téléphone du concerné.
Exemple :
Olivier Martin a pour numéro de téléphone 0689514311.

3. Un dictionnaire est un objet mutable

Ajouter une entrée au dictionnaire dico_info

dico_info["répertoire"] = "un ensemble de fichiers de l'ordinateur"

print(dico_info)

dico_info["variable booléenne"] = "une variable dont la valeur est soit 1 soit 0. "

Quel est le résultat de l'instruction suivante ?

d[[3,4]] = False

Remarques :

• Les valeurs d'un dictionnaire peuvent être de n’importe quel type contrairement aux clés qui doivent être des objets hachables (exemples d'objets hachables : les chaînes de caractères, les nombres).
• Dans un dictionnaire, chaque clé doit être unique.

Mettre à jour une entrée d'un dictionnaire

loisirs = {'claude':'foot',
           'noémie':'échec',
           'hassan':'gym'
          }

#On change le loisir de Claude
loisirs['claude'] = 'hand'  

loisirs

Cette instruction a simplement permis de remplacer la valeur ''foot'' par ''hand''.

Supprimer une clé (une entrée :clé:valeur) dans un dictionnaire

del loisirs['claude']

loisirs

Application 2 :

Écrire un programme qui répond au cahier des charges suivant.

4. Quelques méthodes des dictionnaires

Supprimer un dictionnaire

d = {1: "un", 2: "deux", 3: "trois"}

d.clear()

d

Supprimer une clé

loisirs = {'claude':'foot',
           'noémie':'échec',
           'hassan':'gym'
          }

# Supprime la clé et renvoie la valeur associée
loisirs.pop("claude")

print(loisirs)

Supprimer la dernière entrée

loisirs = {1: "one", 2: "two", 3: "three"}

help(dict.popitem)

loisirs.popitem()

print(loisirs)

Les méthodes keys, values et items

Obtenir toutes les clés d'un dictionnaire

annuaire.keys()

type(annuaire.keys())

Obtenir toutes les valeurs d'un dictionnaire

annuaire.values() 

Obtenir tous les couples (clé, valeur) d'un dictionnaire

annuaire.items()

type(annuaire.items())

Remarque :
Si l'on souhaite obtenir de véritables listes à partir de ces trois méthodes de dictionnaires, il faut les précéder de la fonction de transtypage list().

cles = list(annuaire.keys())
valeurs = list(annuaire.values())
items = list(annuaire.items())

Récupérer la valeur associée à une clé

dico = {"dupond": "nicolas", 1: "one", 3.7: ["élève","prof"], (1,2): True}

# Accès direct
dico["dupond"]

# On obtient une keyError
dico["durand"]

dico.get('dupond')

# Si la clé n'existe pas, on n'obtient aucun retour. Et le programme peut continuer !
dico.get("durand")

# Pour être plus explicite, il est conseillé d'ajouter un message par défaut à get.
dico.get("durant", "cette clé n'existe pas !")

Parcourir un dictionnaire

annuaire = {('Martin','Olivier'):'0689514311',
            ('Nana','Hozier'):'0710342578', 
            ('Martin', 'Naïm'): '0666666665'
           }

for cle, valeur in annuaire.items():
    print(f"Le numéro de téléphone de {cle[1]} {cle[0]} est {valeur}")

for personne in annuaire:
    print(f"Le numéro de téléphone de {personne[1]} {personne[0]} est {annuaire[personne]}.")

5. Créer un dictionnaire à partir d'une liste de tuples de deux éléments chacun

lst_tuples = [('a',1),('b',2),('c',3)]

dict_lst_tuples = dict(lst_tuples)
print(dict_lst_tuples)

6. Compréhension de dictionnaires

Syntaxe :
{cle: valeur for élément in iterable if condition}

• cle : représente la clé de chacune des entrées du dictionnaire que l'on veut créé.
• valeur : représente la valeur associée à la clé, cle.
• iterable : peut être une chaîne de caractères, une liste, un tuple, un dictionnaire...
• condition (optionnelle) : permet de filtrer les éléments.

Exemple 1 :
Créer, à partir d'une liste de nombres, un dictionnaire où les clés sont les éléments de la liste et les valeurs associées sont leurs carrés.

# sans compréhension
nombres = [1, 2, 3, 4]
carres = {}
for nombre in nombres:
    carres[nombre] = nombre ** 2
print(carres)

# avec compréhension
nombres = [1, 2, 3, 4]
carres2 = {nombre: nombre ** 2 for nombre in nombres}
print(carres2)

Exemple 2 :
Créer, à partir d'une liste de nombres, un dictionnaire où les clés sont les éléments pairs de la liste et les valeurs associées sont leurs carrés.

# carrés pairs avec compréhension
nombres = [1, 2, 3, 4, 5, 6]
carres_pairs = {nombre: nombre ** 2 for nombre in nombres if nombre % 2 == 0}
print(carres_pairs)

Application 3 :

dict_personnes = {'Bernard': 65, 'hermine': 22, 'Brigitte': 57, 'barush': 34, 'maïramou': 29, 'Bennett': 18}

1. Écrire un programme qui génère, à l'aide d'une compréhension de dictionnaire, à partir de dict_personnes, le dictionnaire dict_personnes2. Ce dictionnaire doit avoir pour clés les prénoms, écrits en majuscules, de dict_personnes, et pour valeurs les âges associés, réduits de 5 %.
2. Écrire un programme qui génère, à l'aide d'une compréhension de dictionnaire, à partir de dict_personnes, le dictionnaire dict_personnes3. Ce dernier doit avoir pour clés les prénoms de dict_personnes commençant par un 'b' et pour valeurs les âges associés à ces prénoms, si ces âges sont supérieurs à 30 ans.

7. Dictionnaires et listes

# Une liste est ordonnée
fruits1 = ["poire", "orange", "banane"]
fruits2 = ["banane", "poire", "orange"]

fruits1 == fruits2

# Un dictionnaire n'est pas ordonné. Mais, il garde l'ordre d'insertion des entrées
dico1  =  {"pommes" : 15, "bananes" : 35, "raisins" : 12} 
dico2  =  {"bananes" : 35, "raisins" : 12, "pommes" : 15} 

dico1 == dico2

Faites-vous plaisir 1 :
Donner la réponse de l'interpréteur Python à chacun des éléments suivants à partir d'une session d'interpréteur continue :

dict_fruits  =  {"pommes" : 15, "bananes" : 35, "raisins" : 12 } 

dict_fruits["bananes"]

dict_fruits["oranges"] = 20 
len (dict_fruits)

"kaki" in dict_fruits

dict_fruits["kiwi"]

dict_fruits.get("kiwi", 0)

dict_fruits = list(dico.keys())

dict_fruits.sort()
print(fruits)

del dict_fruits["pommes"]
"pommes" in dico

Faites-vous plaisir 2 :
On donne : animal1 = {"nom" : "girafe", "taille" : 5.0, "poids" : 1100}.

1. Écrire une expression qui renvoie, dans une liste, toutes les clés de animal1.
2. Écrire une expression qui renvoie, dans une liste, toutes les valeurs de animal1.
3. Écrire une expression qui renvoie, dans une liste, toutes les items de animal1.

Faites-vous plaisir 3 :
On donne : dict_nombres = {"un": 1, "deux": 2, "trois": 3, "quatre": 4}
Écrire un code qui crée un nouveau dictionnaire, nouveau_dict_nombres, qui a pour clés les valeurs de dict_nombres et valeurs les clés de dict_nombres. Autrement dit, nouveau_dict_nombres inverse clés et valeurs de dict_nombres.

Faites-vous plaisir 4 :
On donne :
dict_revenus = {"Yaël":100 000, "Timoléon":75 000, "Annie": 20 000, "Claude": 80 000, "Amina": 50 000}

1. Créer une variable dict_revenus_ordre_croissant_prenoms qui identifie le dictionnaire dict_revenus rangé dans l'ordre croissant des prénoms.
2. Créer une variable dict_revenus_ordre_decroissant_revenus qui identifie le dictionnaire dict_revenus rangé dans l'ordre décroissant des revenus.

Faites-vous plaisir 5 :
Écrire une fonction nbre_occurrences qui prend en entrée un mot, mot, et renvoie un dictionnaire dont les items ont pour clés les lettres rencontrées et valeurs associées le nombre d'occurrences (apparitions) de chacune des lettres dans le mot. La casse doit être ignorée. On documentera la fonction.
Un exemple de sortie du programme lorsque l'utilisateur entre la donnée « missiSSipi », ressemblerait à ceci :
{'m': 1, 'i': 4, 's': 4, 'p': 1}

8. Dictionnaires et séquences

Faites-vous plaisir 6 :
On donne la liste de dictionnaires ci-après :

lst_dict_animaux = [
{"nom" : "girafe", "taille" : 5.0, "poids" : 1_100},
{"nom": "éléphant", "taille": 3.5, "poids": 6_000},
{"nom": "lion", "taille": 1.2, "poids": 190}
]

Écrire un programme qui permet d'avoir l'affichage suivant :
L'animal dont le nom est girafe pèse 1100 kg
L'animal dont le nom est éléphant pèse 6000 kg
L'animal dont le nom est lion pèse 190 kg

Faites-vous plaisir 7 :
On a le dictionnaire ci-après :

dict_eleves = {
"nom" : ["Léa", "Maïramou", "Alain"],
"âge": [17, 16, 18],
"loisir": ["gym", "boxe", "danse"]
}

1. Écrire une expression qui permet de récupérer la valeur associée à nom.
2. Écrire une expression qui permet de récupérer 16.
3. Écrire une instruction qui permet de changer le loisir danse en badminton.