Exercice d’application

• Considérons le fichier [Link] qui contient les notes obtenues par des
étudiants pour le cours de Python. Chaque ligne du fichier ne contient
qu'une note. Placer ce fichier dans votre répertoire de travail.
• Créer un script Python qui lit chaque ligne de ce fichier, extrait les notes
sous forme de float et les stocke dans une liste.
• Finaliser le script en calculant et affichant la moyenne des notes avec
deux décimales.
• Créer un script permettant de réécrire ensuite les notes dans le fichier
[Link] avec une note par ligne suivie de « recalé » si la note est
inférieure à 10 et « admis » si la note est supérieure ou égale à 10.
Toutes les notes seront écrites avec deux décimales. Exemple de trois
premières lignes du fichier [Link] :
• 13.5 admis
• 17.0 admis
• 9.5 recalé
97
 Dictionnaires et tuples
 Définition:
Un dictionnaire contient une collection d'objets Python auxquels on
accède à l'aide d'une clé de correspondance plutôt qu'un indice. Ainsi, il
ne s'agit pas d'objets séquentiels comme les listes, mais d'objets dits
de correspondance (mapping objects) ou tableaux associatifs.
 Exemple :
animal1 = {}
animal1["nom"] = "girafe"
animal1["taille"] = 5.0
animal1["poids"] = 1100
• On remplit le dictionnaire avec plusieurs clés ou champs ("nom",
"taille", "poids") auxquelles on affecte des valeurs.
• Les accolades nous montrent qu'il s'agit d'un dictionnaire.
• Chaque élément séparé par une virgule, on a une association du type
98
clé: valeur.
 Dictionnaires et tuples
• Une fois le dictionnaire créé, on récupère la valeur associée à une clé
donnée avec une syntaxe du type dictionnaire["clé"].
• On peut aussi initialiser toutes les clés et les valeurs d'un dictionnaire
en une seule opération.
• On peut également ajouter une clé et une valeur supplémentaire.
• Comme pour les listes, l'instruction len() renvoie la longueur du
dictionnaire.
 Exemple :
animal1["nom"]
animal1["taille"] = 5.0

animal2 = {"nom": "singe", "poids": 70, "taille": 1.75}

animal2["age"] = 15
len(animal2) 99
 Dictionnaires et tuples
 Remarque :
• L'avantage des dictionnaires : pouvoir retrouver des éléments par des
noms (clés) plutôt que par des indices (proche d’esprit humain).
• Les dictionnaires se révèlent très pratiques pour manipuler des
structures complexes à décrire et lorsque les listes présentent leurs
limites.
 Application :
Ecrire un script pour stocker les coordonnées d'un point
dans l'espace en utilisant deux versions: liste et dictionnaire.
Comparer et commenter le résultat ?

100
 Itération sur les clés - Méthodes .keys() et .values()
• Si on souhaite voir toutes les associations clés / valeurs, on peut itérer
sur un dictionnaire par défaut sur les clés.
• Les méthodes .keys() et .values() renvoient, en cas de doute, les clés
et les valeurs d'un dictionnaire.
• dict_keys et dict_values ne sont pas indexables.
• Si besoin, nous pouvons les transformer en liste avec la fonction list().
 Exemples :
animal2 = {'nom': 'singe', 'poids': 70, 'taille': 1.75}
for key in animal2:
print(key, animal2[key])
[Link]()
[Link]()
list([Link]())
[Link]()[1] 101
 Itération sur les clés
• On peut itérer dessus dans une boucle (on dit qu'ils sont itérables).
• La méthode .items() renvoie un nouvel objet dict_items.
• On ne peut pas retrouver un élément par son indice dans un objet
dict_items, on peut itérer dessus.
• La syntaxe ressemble à la fonction enumerate(), on itère à la fois sur
key et sur val.
 Exemples :
for cle in [Link]():
print(cle)
dico = {7: "t", 5: "o", 12: "t", 33: "o"}
[Link]()
[Link]()[2]
for key, val in [Link]():
102
print(key, val)
 Existence d'une clé ou d'une valeur
• Pour vérifier si une clé existe dans un dictionnaire, on peut utiliser le
test d’appartenance avec l'opérateur in qui renvoie un booléen.
• Si on souhaite tester si une valeur existe dans un dictionnaire, on peut
utiliser l'opérateur in avec l'objet renvoyé par la méthode .values().
• Si on demande la valeur associée à une clé qui n'existe pas, Python
renvoie une erreur. La méthode .get() résous ce problème. On peut
indiquer à .get() une valeur par défaut si la clé n'existe pas.
 Exemples :
"poids" in animal2
if "poids" in animal2:
print("La clé 'poids' existe pour animal2")
[Link]()
"singe" in [Link]()
animal2["age"]
[Link]("nom")
103
[Link]("age", 42)
 Liste de dictionnaires
• La création d’une liste de dictionnaires possédant les mêmes clés,
permet d’obtenir une structure qui ressemble à une base de données.
• Les dictionnaires permettent de gérer des structures complexes de
manière plus explicite que les listes.
 Exemple :

animaux = [animal1, animal2]

for ani in animaux:

print(ani["nom"])

104
 Tuples
Définition:
• Les tuples (« n-uplets » en français) sont des objets séquentiels
correspondant aux listes, mais ils sont toutefois non modifiables.
• On dit aussi qu'ils sont immuables.
• En pratique, on utilise les parenthèses au lieu des crochets pour les
créer.
 Exemple :
tuple1 = (1, 2, 3)
print(tuple1)
type(tuple1)
tuple1[2]
tuple1[0:2]
tuple1[2] = 15
tuple1 = tuple1 + (2,)
print(tuple1)
tuple2 = 1, 2, 3 print(tuple2) 105
 Tuples
• Pour déclarer et initialiser les tuples, il est conseiller d'utiliser les
parenthèses afin d'éviter chaque confusion.
• Les opérateurs + et * fonctionnent comme pour les listes
(concaténation et duplication).
• On peut utiliser la fonction tuple (sequence) similaire de list(), qui
prend en argument un objet et renvoie le tuple correspondant
(casting).
• Elle ne fonctionne pas avec les entiers, floats ou booléens comme :
tuple(2).
 Exemple :
(1, 2) + (3, 4)
(1, 2, 1, 2, 1, 2, 1, 2)

tuple([1,2,3])
tuple(“BONJOUR")
tuple(range(5))
106
 Tuples - Affectation multiple
• Les tuples sont souvent utilisés pour l'affectation multiple, afin
d’affecter des valeurs à plusieurs variables en même temps .
• Le nombre de variables et de valeurs doit être cohérents à gauche et
à droite de l'opérateur =.
• Il est aussi possible de faire des affectations multiples avec des listes.
• Elle ne fonctionne pas avec les entiers, floats ou booléens comme :
tuple(2) (affichage d’erreur !).
 Exemple :
x, y, z = 1, 2, 3 (tuple unpacking)
[x, y, z] = [1, 2, 3] (déconseillée)

tuple1=(1,2,3)
x, y, z = tuple1, évaluer x, y et z ? accéder aux éléments par indiçage,
que peut-on conclure ?

107
 Itérations sur plusieurs valeurs à la fois
• La fonction enumerate() permet d'itérer en même temps sur les
indices et les éléments d'une liste.
• La méthode .items() itère, comme enumerate(), sur une série de
tuples.
• On peut itérer sur trois valeurs en même temps à partir d'une liste de
tuples de trois éléments .
 Exemple :
for indice, element in enumerate([75, -75, 0]):
print(indice, element)

for tuple2 in enumerate([75, -75, 0]): liste = [(5, 6, 7), (6, 7, 8), (7, 8, 9)]
print(tuple2, type(tuple2)) for x, y, z in liste:
dico = {"etudiant": 8, "moyenne": 15} print(x, y, z) Conclure ?
for cle, valeur in [Link]():
print(cle, valeur)
for tuple3 in [Link]():
print(tuple3, type(tuple3)) 108
 Fonction divmod()
• La fonction divmod() prend en argument deux valeurs, le numérateur
et le dénominateur d'une division, et renvoie le quotient et le reste de
la division entière correspondante.
• En utilisant l'affectation multiple, on peut ainsi récupérer à la fois le
quotient et le reste en une seule ligne .
 Exemple :
Convertir 754 secondes en minutes par deux méthodes différentes et
conclure ?

109
 Exercices d’application
 Exercice1 :
Soit le dictionnaire suivant donnant les notes d'un étudiant :

dico_notes = {
"math": 14, "programmation": 12,
"anglais": 16, "physique": 10,
"culture": 19
}
Calculer la moyenne de ses notes de deux manières différentes.
Calculer à nouveau la moyenne sans la note de physique.
 Exercice2 :
À partir de la liste de tuples suivante :

[("chien", 3), ("chat", 4), ("souris", 16)]

afficher chaque animal et son nombre en utilisant qu'une seule boucle
for. Attention, pour cet exercice, il est interdit d'utiliser l'indiçage des
110
listes.