Tutoriel python le niveau intermédiaire – LES DICTIONNAIRES

Bienvenue dans le tutoriel python niveau intermédiaire numéro 2.

UN NOUVEAU TYPE DE DONNÉES

La liste Python est un type de données très polyvalent, car elle vous permet d’agréger facilement de nombreux types de données différents en une seule variable. Cependant, elle montre ses limites lorsqu’une certaine complexité est atteinte (par exemple lorsque les éléments d’une liste sont à leur tour des listes). Imaginons, par exemple, que l’on veuille représenter l’élève d’une école par une liste ; il serait sans doute conseillé de remplir au préalable un tableau pour se souvenir de ce que représentent les différents éléments :

Indice	Type	Signification
0	str (stringa)	Prénom
1	str	Nom
2	int (intero)	Année d’étude
3	str	Section
4	list di int	Votes
5	list di int	Absences

puis nous pourrions écrire une déclaration d’affectation comme celle-ci :

élève = ["Mario", "Rossi", 2, "B", [7, 7, 6, 5, 6, 8, 9], [3, 1, 2, 0, 1, 1]]

La limite d’une telle approche réside dans le fait que les éléments d’une liste sont indexés par leur position : si l’on voulait maintenant effectuer des opérations sur la variable élève il faudrait retenir que, par exemple, sa note en Mathématiques se trouve dans élève [4 ] [3], les absences en italien chez l’élève [5] [0] et ainsi de suite, entraînant un code difficile à écrire et à lire sans consulter constamment le tableau ci-dessus.

Pour ces situations, un type de données plus avancé existe en Python, le dictionnaire (dictionary en anglais, dict en Python) : c’est une liste dont les éléments, plutôt que par leur position, sont indexés par une clé alphabétique. Cela signifie que, dans l’exemple précédent, au lieu d’écrire élève [0] ou élève [1], nous pouvons écrire élève [“Nom”] ou élève [“Nom”].

Un dictionnaire est un ensemble de paires clé-donnée : le premier élément de la paire contient la clé (c’est-à-dire le nom de la donnée), le second sa valeur. La syntaxe pour déclarer un dictionnaire n’est pas si simple : voyons quelques exemples dans IDLE :

>>> personne1 = {"Nom": "Luigi", "Nom": "Bianchi", "Âge": 35}
>>> personne2 = {"Nom": "Pietro", "Nom": "Verdi", "Âge": 38}

Pour déclarer une variable de type dictionnaire il faut utiliser des accolades (entre autres choses assez gênantes sur le clavier italien, elles s’obtiennent en appuyant ensemble sur , et la touche avec accolades). En leur sein, une série de paires de clés doivent être déclarées, séparées par des virgules : valeur, où clé est une chaîne qui sera le nom des données, tandis que valeur est la donnée réelle (qui peut généralement être de n’importe quel type) . À ce stade, nous pouvons sélectionner les différents éléments par leur nom :

>>> personne1 ["Nom"]
'Luigi'
>>> personne2 ["Âge"]
38

Bien sûr, cette syntaxe permet à la fois de lire et d’écrire des données. Par exemple, si c’est aujourd’hui l’anniversaire de Peter, je peux écrire :

>>> personne2 ["Age"] = personne2 ["Age"] + 1 # ou, plus simplement : personne2 ["Age"] + = 1
>>> personne2
{'Nom' : 'Pietro', 'Nom' : 'Verdi', 'Âge' : 39}

Voici un exemple plus compliqué : nous procédons maintenant à la mémorisation de notre élève, à l’aide d’un dictionnaire qui contient à son tour deux dictionnaires. Je vous rappelle que, comme cela arrive également pour les listes, pour accéder aux éléments d’un dictionnaire “à l’intérieur d’un autre dictionnaire”, vous devez utiliser les crochets deux fois :

>>> votes = {"Italien": 7, "Histoire": 7, "Anglais": 6, "Mathématiques": 5,
"Dessin": 6, "Ed Physique": 8, "Conduite": 9}
>>> absences = {"Italien": 3, "Histoire": 1, "Anglais": 2, "Mathématiques": 0,
"Dessin": 1, "Ed Physique": 1}
>>> élève = {"Nom": "Mario", "Nom": "Rossi", "Classe": 3,
"Section": "B", "Votes": votes, "Absences": absences}
>>> élève ["Nom"]
'Mario'
>>> élève ["Notes"] ["Mathématiques"]
5

Notez la dernière instruction : le premier crochet sélectionne la donnée qui a la clé “Votes” (c’est-à-dire le dictionnaire des votes) et le second sélectionne la donnée à l’intérieur qui a la clé “Mathématiques”.

Étant donné qu’une déclaration de dictionnaire peut être très longue à lire, certains programmeurs utilisent un retour chariot après chaque paire clé:valeur (après la virgule) pour la rendre plus claire. N’oubliez pas qu’en enveloppant à l’intérieur d’une parenthèse ouvrante, Python comprend que l’instruction continue sur la ligne suivante et ne tient pas compte de l’indentation

>>> votes = {
     "Italien": 7,
     "Histoire": 7,
     "Anglais": 6,
     "Mathématiques": 5,
     "Dessin": 6,
     "Et Physique": 8,
     "Conduite": 9}

Alternativement, on peut déclarer un dictionnaire initialement vide et ajouter progressivement les paires clé : valeur simplement en leur attribuant une valeur

>>> personne3 = {}
>>> personne3 ["Nom"] = "Carlo"
>>> personne3 ["Nom"] = "Bruni"
>>> personne3 ["Âge"] = 28
>>> personne3
{'Nom' : 'Carlo', 'Prénom' : 'Bruni', 'Âge' : 28}

EXERCICE 2.1 : Aidez un vétérinaire à représenter les animaux de compagnie de ses patients à l’aide d’un dictionnaire Python : vous devez entrer ces clés dans les données à retenir : le nom de l’animal, l’espèce (chien, chat, perroquet…), le race (pitbull, cocker, métis…), âge, nom du propriétaire. Créez deux variables différentes animal1 et animal2 qui représentent deux animaux.
EXERCICE 2.2 Faites de même avec deux voitures : mémorisez la marque, le modèle, la cylindrée et l’année d’immatriculation.
REMARQUE : Vous pouvez résoudre ces exercices soit en déclarant le dictionnaire entier dans une instruction, soit en ajoutant les données une instruction à la fois.

FONCTIONS SUR LES DICTIONNAIRES

En plus d’assigner et de lire des valeurs, avec les dictionnaires, nous pouvons faire beaucoup d’autres choses : Python définit un bon nombre de fonctions qui agissent sur elles. La plupart de ces fonctions doivent être appelées à l’aide de la syntaxe à points nom_dictionnaire.nom_fonction (arguments) (les fonctions appelées de cette manière sont appelées méthodes).

Commençons par fromkeys() qui a ce paradigme :

fromkeys (itérable, valeur = None) -> dict
La fonction prend comme paramètre un itérable (liste ou tuple) qui contient des chaînes et renvoie un dictionnaire qui utilise les chaînes données comme clés ; les valeurs correspondantes sont toutes initialisées à value, ou à None (le mot clé Python pour “no value”) si on omet le paramètre optionnel. L’appel à cette fonction pose cependant un petit problème : puisqu’il s’agit d’une méthode mais qu’elle ne s’applique généralement à aucun dictionnaire préexistant (précisément parce qu’elle sert à en créer un nouveau), il faut l’appeler en utilisant, au à gauche du point, un dictionnaire vide (comme variable temporaire) ou le mot dict, comme ceci :

>>> new_dict = dict.fromkeys (["a", "b", "c"]) # ok
>>> nouveau_dict
{'a' : aucun, 'b' : aucun, 'c' : aucun}
>>> new_dict = {} .fromkeys(["a", "b", "c"], 0) # c'est bien aussi
>>> nouveau_dict
{'a' : 0, 'b' : 0, 'c' : 0}
>>> new_dict = fromkeys (["a", "b", "c"]) # celui-ci n'est pas
Traceback (dernier appel le plus récent) :
   Fichier "", ligne 1, dans
     d1 = à partir des touches (k)
NameError : le nom 'fromkeys' n'est pas défini

Cette fonction est utile dans les situations où nous devons stocker un grand nombre de dictionnaires tous basés sur les mêmes clés. Prenons par exemple notre exemple d’un élève d’une école : une fois que nous aurons décidé quelles données nous devons mémoriser, nous devrons probablement saisir les données de tous les élèves inscrits : chacun d’eux sera un dictionnaire basé sur le même clés. Voyons un exemple :

Créez un nouveau fichier dans l’éditeur de texte IDLE et copiez les lignes de code ci-dessous :

# on définit nos clés
keys_alunno = ("Nom", "Prénom", "Année du cours", "Section", "Notes", "Absences")

def insert_pupil ():
     # créer un élève avec toutes les valeurs définies sur Aucun
     pupille = dict.fromkeys (pupil_keys)
# maintenant la fonction nous demande d'entrer les données
     print ("Insérer les données de l'élève")
     pour st dans keys_alunno [: - 2] :
         élève [st] = entrée (st + ":")
     élève de retour

a = insérer_élève ()
imprimer (a)

Ce programme simple appelle la fonction insert_pupil() qui permet à l’utilisateur de saisir les données personnelles d’un élève et de les restituer sous forme de dictionnaire. A la ligne #6 il crée le dictionnaire étudiant avec fromkeys() et en #9 commence une boucle for dans laquelle le compteur st varie sur les clés du dictionnaire (ie les chaînes “Name” “Surname”, etc.). A noter l’utilisation de la notation slice étudiée au chapitre précédent pour exclure les deux dernières clés (en fait ici on veut insérer uniquement les données personnelles, les votes et les absences seront vraisemblablement insérés plus tard et resteront donc à None).

EXERCICE 2.3 : Modifier le programme pour qu’il appelle la fonction à l’intérieur d’un cycle, en introduisant 5 élèves, en imprimant leurs données et en les ajoutant les unes après les autres à une liste d’élèves (initialement vide).

Dans l’exemple précédent, nous avons utilisé une boucle sur les clés du dictionnaire pour insérer des données ; des cas comme celui-ci sont assez fréquents, et en Python il existe des fonctions spéciales pour faciliter l’écriture de boucles.

Une fonction	Signification
keys()	Renvoie un objet itérable contenant toutes les clés du dictionnaire, dans l’ordre dans lequel elles ont été saisies
values()	Renvoie un objet itérable contenant toutes les valeurs du dictionnaire, dans l’ordre dans lequel elles ont été saisies
items()	Renvoie un objet itérable contenant toutes les paires (“clé”, “valeur”) du dictionnaire sous forme de tuple.

Qu’est-ce qu’un objet itérable ? C’est quelque chose de très similaire à la plage : un objet composé de plusieurs éléments, qui permet d’exécuter une boucle for dessus mais pas de modifier (ni même de sélectionner avec des crochets) les éléments individuels. En fait, comme je vous l’ai dit, ces fonctions servent généralement à générer des boucles ; si la variable d est un dictionnaire, alors :

for k in d.keys ():
     . . . # loop on dictionary keys
for v in d.values ():
     . . . # loop over dictionary values
for i in d.items ():
     . . . # loop on key-value pairs

Le choix de ne pas retourner une liste est essentiellement dû à des raisons d’efficacité : comme vous le savez, les listes sont les types de données qui consomment le plus de mémoire, et fondamentalement cela n’aurait pas beaucoup de sens d’obtenir la liste de ses clés à partir d’un dictionnaire et puis modifiez-le (car cela ne modifierait pas le dictionnaire). Dans tous les cas, si nous en avions vraiment besoin, nous pourrions toujours appliquer la fonction list () au résultat des clés () (mais ATTENTION! Je répète que, dans ce cas, nous modifions la liste obtenue, mais PAS le dictionnaire à partir duquel nous l’avons prise). Voyons quelques exemples pour clarifier nos idées :

ESERCIZIO 2.4: Se non l’avete già fatto, ridefinite in IDLE il dizionario persona1 come abbiamo fatto sopra:

>>> personne1 = {"Nom": "Luigi", "Nom": "Bianchi", "Âge": 35}

Tapez maintenant les instructions suivantes et notez la réponse de Python lorsque vous appuyez sur ENTRÉE :

>>> personne 1.keys ()
>>> personne 1.values ​​​​()
>>> personne 1.articles ()
>>> k = personne 1.keys ()
>>> k.append ("Adresse")
>>> k [0]
>>> k = liste (k)
>>> k.append ("Adresse")
>>> k
>>> personne1

Dans les lignes #5 et #6 vous remarquerez qu’il est impossible de changer le résultat de keys() ou de lire un seul élément. Dans # 7, nous convertissons k en une liste et la modifions, mais, comme on le voit dans # 10, le dictionnaire person1 reste inchangé.

EXERCICE 2.5 :

Toujours en partant du dictionnaire person1, écrivez trois petites boucles for qui impriment, l’une après l’autre, ses clés, ses valeurs et ses paires clé-valeur. ATTENTION! Vous pouvez également faire cet exercice dans IDLE (sans avoir besoin d’utiliser l’éditeur qui vous invite à enregistrer le fichier) : tapez le for et appuyez sur (IDLE indentera automatiquement la ligne suivante), puis écrivez le corps de la boucle (juste une seule ligne) et appuyez deux fois sur pour exécuter les deux lignes.

Enfin, reprenons notre programme school_management.py et apportons quelques améliorations :

EXERCICE 2.6 :

L’instruction print (a) à la fin du programme imprime la variable sous forme de dictionnaire, avec les clés et les valeurs entre accolades. Si nous voulons imprimer uniquement les valeurs saisies, nous pouvons les remplacer par ces lignes :

.   .   .

for st in a.values():
    print(st, end=" ")
print()

N’oubliez pas que end est un des paramètres optionnels de la fonction print(), qui indique le caractère à ajouter après le dernier argument : si on l’omet, la fonction imprime un caractère de retour à la ligne (et donc revient à la ligne à chaque fois qu’elle est appelée, comme par exemple En écrivant end=”” à la place, on lui fait imprimer un espace, pour que toutes les valeurs soient imprimées sur la même ligne (et on ne boucle qu’à la fin de la boucle, quand on exécute l’impression finale()).

EXERCICE 2.7

Enfin, nous créons une autre fonction pour saisir les notes et les absences de l’élève.
Immédiatement après la liste pupil_key, ajoutez cet autre :

keys_materie = {"Italien", "Histoire", "Anglais", "Mathématiques", "Dessin", "Ed Physique", "Conduite"}

Définissez, après le insert_alumnus(), cette autre fonction :

def insert_votes (élève):
     élève ["Votes"] = fromkeys (material_keys)
     pour k dans élève ["Notes"]. touches ():
         élève ["Notes"] [k] = entrée ("Note en" + k + ":")
     élève de retour

Appelez la fonction depuis le programme principal, après avoir saisi les données personnelles de l’élève.

EXERCICE 2.8

Modifiez la fonction insert_votes() afin qu’avec les votes (dans le même cycle) vous puissiez également insérer des absences (gardez à l’esprit que les deux dictionnaires qui représentent les votes et les absences ont les mêmes clés).

Enfin, nous énumérons d’autres fonctions importantes qui nous permettent de manipuler des dictionnaires :

fonction	Signification
update (list)	Cette fonction accepte un autre dictionnaire ou une liste de paires clé-valeur comme paramètre. Pour chaque paire, si la clé est déjà présente, il met à jour sa valeur, sinon il l’ajoute au dictionnaire.
pop (“key”, [default]) -> value	Supprime la paire avec la clé spécifiée du dictionnaire, renvoyant la valeur des données. Si la clé n’est pas présente, elle renvoie le paramètre facultatif par défaut ou provoque une erreur si elle n’est pas présente.
popitem () -> (“key”, value)	Supprime la dernière paire ajoutée du dictionnaire, renvoyant sa clé et sa valeur sous forme de tuple. Si le dictionnaire est vide, cela provoque une erreur.
clear ()	Supprime toutes les paires du dictionnaire, qui devient un dictionnaire vide

Voyons un exemple d’utilisation de ces fonctions :

>>> person1 = {"Name": "Luigi", "Surname": "Bianchi", "Age": 35}
>>> person1.update ({"Age": 36, "Country": "Single"})
>>> person1
{'Name': 'Luigi', 'Surname': 'Bianchi', 'Age': 36, 'Country': 'Single'}
>>> persona1.pop ("Age")
36
>>> person1
{'Name': 'Luigi', 'Surname': 'Bianchi', 'Country': 'Single'}
>>> persona1.pop ("Age")
36
>>> person1
{'Name': 'Luigi', 'Surname': 'Bianchi', 'Country': 'Single'}
>>> persona1.pop ("Age")
Traceback (most recent call last):
   File "<pyshell # 12>", line 1, in <module>
     persona1.pop ("Age")
KeyError: 'Age'
>>> person1.pop ("Age", 0)
0