đ Graphiques, đŠcollections (set, tuple, dict)
- For (séquence)
- Compréhension de liste
- Ensemble (set)
- Tuple (tuple)
- Dictionnaire (dict)
- Matplotlib
- Activités
for sur une listeà la rencontre 5, on a parcouru des listes avec for i in range(len(liste)) et liste[i] pour accéder à l'élément à l'index i.
Il existe une façon plus directe et plus lisible : parcourir les éléments directement, sans passer par l'index.
La syntaxe est la suivante :
for element in liste:
# instructions à exécuter
Voici un exemple avec une liste d'éléments chimiques :
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
for element in elements:
print("ĂlĂ©ment :", element)
ĂlĂ©ment : HydrogĂšne
ĂlĂ©ment : OxygĂšne
ĂlĂ©ment : Carbone
ĂlĂ©ment : Azote
à chaque tour de boucle, la variable element prend automatiquement la valeur de l'élément suivant dans la liste.
Son nom est libre : on aurait pu l'appeler e, chimique, ou n'importe quoi d'autre. C'est nous qui choisissons.
đ ExĂ©cutez ce code en mode dĂ©bogage. Mettez un point d'arrĂȘt sur la ligne 2 et avancez une ligne Ă la fois pour suivre l'Ă©volution de la variable element.
for et range(len()) : ce qu'on connaissait dĂ©jĂ Les deux versions ci-dessous produisent exactement le mĂȘme rĂ©sultat :
Boucle for sur la listeâ
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
for element in elements:
print("ĂlĂ©ment :", element)
Boucle for avec range(len())â
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
for i in range(len(elements)):
element = elements[i]
print("ĂlĂ©ment :", element)
La version for element in elements est plus concise et plus facile Ă lire, surtout quand on n'a pas besoin de l'index.
for element in elements: quand on veut traiter chaque Ă©lĂ©ment et qu'on n'a pas besoin de l'index.for i in range(len(elements)): quand on a besoin de l'index pour modifier la liste ou comparer des positions.while: quand la condition d'arrĂȘt est plus complexe qu'un simple parcours de liste.
La syntaxe for element in elements est pratique, mais elle ne permet pas de parcourir deux listes en parallĂšle, puisqu'on n'a pas accĂšs Ă l'index.
Dans ce cas, il faut revenir Ă for i in range(len(...)) :
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
masses_atomiques = [1.008, 15.999, 12.011, 14.007]
# â Impossible avec for element in elements : pas d'accĂšs Ă l'index
for element in elements:
print(f"{element} a une masse atomique de {masses_atomiques[???]}") # On ne connaĂźt pas l'index!
# â
Utiliser range() pour accéder aux deux listes via l'index
for i in range(len(elements)):
print(f"{elements[i]} a une masse atomique de {masses_atomiques[i]}")
HydrogĂšne a une masse atomique de 1.008
OxygĂšne a une masse atomique de 15.999
Carbone a une masse atomique de 12.011
Azote a une masse atomique de 14.007
append()Une boucle for sur une liste est souvent utilisée pour construire une nouvelle liste à partir d'une liste existante.
Voici un exemple qui crée une liste de descriptions à partir de la liste d'éléments chimiques :
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
descriptions = []
for element in elements:
descriptions.append(f"{element} est un élément chimique.") # Ajoute une description à la liste
print(descriptions)
['HydrogÚne est un élément chimique.', 'OxygÚne est un élément chimique.', 'Carbone est un élément chimique.', 'Azote est un élément chimique.']
đ ExĂ©cutez-le en mode dĂ©bogage pour suivre l'Ă©volution de la liste descriptions Ă chaque itĂ©ration.
enumerate() pour obtenir l'index et la valeur en mĂȘme tempsParfois, on a besoin Ă la fois de l'index et de la valeur de chaque Ă©lĂ©ment.
La fonction enumerate() permet d'obtenir les deux sans avoir à gérer i manuellement :
elements = ["HydrogĂšne", "OxygĂšne", "Carbone", "Azote"]
for index, element in enumerate(elements):
print(f"ĂlĂ©ment #{index} : {element}")
ĂlĂ©ment #0 : HydrogĂšne
ĂlĂ©ment #1 : OxygĂšne
ĂlĂ©ment #2 : Carbone
ĂlĂ©ment #3 : Azote
đ ExĂ©cutez-le en mode dĂ©bogage pour suivre l'Ă©volution des variables index et element Ă chaque itĂ©ration.
Les explications de cette section étaient-elles claires ?
Imaginons qu'on veuille créer une nouvelle liste contenant le carré de chaque nombre d'une liste. Avec une boucle for classique, ça ressemble à ceci :
nombres = [1, 2, 3, 4, 5, 6]
carres = []
for x in nombres:
carres.append(x ** 2)
print(carres) # Affiche [1, 4, 9, 16, 25, 36]
C'est correct, mais ça prend 3 lignes juste pour construire la liste. La comprĂ©hension de liste permet d'Ă©crire la mĂȘme chose en une seule ligne.
La compréhension de liste est une maniÚre concise et élégante de créer des listes en Python. Elle permet de générer une nouvelle liste en appliquant une expression à chaque élément d'une séquence (comme une liste, un tuple, etc.).
La syntaxe générale est la suivante :
nouvelle_liste = [expression for element in sequence]
Voici comment réécrire l'exemple précédent avec une compréhension de liste :
nombres = [1, 2, 3, 4, 5, 6]
carres = [x ** 2 for x in nombres]
print(carres) # Affiche [1, 4, 9, 16, 25, 36]
Chaque partie de [x ** 2 for x in nombres] a un rÎle précis :
# ââ expression ââ ââ element ââ âââ sequence âââ
[ x ** 2 for x in nombres ]
expression(x ** 2) : la transformation à appliquer à chaque élément.element(x) : la variable qui prend chaque valeur de la séquence.sequence(nombres) : la liste qu'on parcourt.
Exécutez ce code en mode débogage pour bien comprendre son fonctionnement.
On peut aussi ajouter une condition optionnelle pour ne garder que certains éléments :
nouvelle_liste = [expression for element in sequence if condition]
Par exemple, pour ne garder que les carrés des nombres pairs :
nombres = [1, 2, 3, 4, 5, 6]
carres_pairs = [x ** 2 for x in nombres if x % 2 == 0]
print(carres_pairs) # Affiche [4, 16, 36]
# ââ expression ââ ââ element ââ âââ sequence âââ âââââ condition âââââ
[ x ** 2 for x in nombres if x % 2 == 0 ]
Le mĂȘme rĂ©sultat avec une boucle for classique :
nombres = [1, 2, 3, 4, 5, 6]
carres_pairs = []
for x in nombres:
if x % 2 == 0:
carres_pairs.append(x ** 2)
print(carres_pairs) # Affiche [4, 16, 36]
Les deux approches produisent exactement le mĂȘme rĂ©sultat.
La comprĂ©hension de liste est simplement une façon plus compacte d'Ă©crire ce mĂȘme code.
- Concision : La comprĂ©hension de liste permet d'Ă©crire moins de lignes de code pour accomplir la mĂȘme tĂąche.
- Lisibilité : Elle rend le code plus lisible en exprimant clairement l'intention de créer une nouvelle liste basée sur une transformation ou un filtrage.
- Performance : La compréhension de liste est souvent plus rapide que l'utilisation de boucles
fortraditionnelles pour créer des listes.
Il est possible d'imbriquer des compréhensions de liste à l'intérieur d'autres compréhensions de liste.
Ce concept, appelé nested list comprehensions, n'est pas requis dans le cadre de ce cours, mais il est bon de savoir que ça existe.
đ Si ce qui suit semble difficile Ă suivre, c'est tout Ă fait normal. Cette notion dĂ©passe les attentes du cours. Vous pouvez passer directement Ă l'onglet suivant sans culpabiliser.
Une compréhension de liste imbriquée, c'est simplement une compréhension de liste dont l'expression
est elle-mĂȘme une comprĂ©hension de liste. Par exemple, pour crĂ©er une liste de listes :
liste = [[j for j in range(i)] for i in range(5)]
print(liste) # Affiche [[], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
La compréhension extérieure (for i in range(5)) génÚre 5 éléments.
Pour chaque valeur de i, la compréhension intérieure ([j for j in range(i)]) crée une sous-liste contenant les entiers de 0 à i - 1.
Le mĂȘme rĂ©sultat avec des boucles for classiques :
liste = []
for i in range(5):
sous_liste = []
for j in range(i):
sous_liste.append(j)
liste.append(sous_liste)
print(liste) # Affiche [[], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
Les explications de cette section étaient-elles claires ?
Un ensemble (set) est une collection non ordonnée d'éléments uniques.
Contrairement à une liste, un ensemble ne peut pas contenir de doublons et ses éléments n'ont pas d'index.
On l'utilise quand l'ordre n'a pas d'importance et qu'on veut garantir qu'un élément n'apparaßt qu'une seule fois,
ou effectuer des opérations mathématiques comme l'union, l'intersection et la différence.
On crée un ensemble avec des accolades {} et des valeurs séparées par des virgules :
heros = {"Peach", "Link", "Kirby"}
{} crée un dictionnaire, pas un ensemble.
Pour créer un ensemble vide, il faut utiliser set() :
heros = set()
On utilise .add() pour ajouter un élément. Si l'élément est déjà présent, il ne sera pas ajouté en double :
heros = {"Peach", "Link", "Kirby"}
heros.add("Kirby") # Ignoré, déjà présent
heros.add("Yoshi") # Ajouté
print(heros) # Résultat possible : {"Yoshi", "Kirby", "Peach", "Link"}
print(heros) # Résultat possible : {"Link", "Peach", "Yoshi", "Kirby"}
L'ordre des éléments peut varier d'un print à l'autre. Un ensemble ne garantit aucun ordre précis.
On utilise remove() pour supprimer un élément d'un ensemble :
heros = {"Peach", "Yoshi", "Kirby"}
heros.remove("Yoshi")
print(heros) # {"Peach", "Kirby"} (ordre variable)
On peut vérifier si un élément est dans un ensemble avec in :
nombres = {1, 2, 3, 4, 5}
print(3 in nombres) # True
print(9 in nombres) # False
đ La vĂ©rification avec in est particuliĂšrement rapide sur un ensemble, plus que sur une liste.
On peut obtenir le nombre d'éléments d'un ensemble avec len() :
nombres = {1, 2, 3, 4, 5}
print(len(nombres)) # 5
Pour convertir un ensemble en une liste, il suffit d'appeler la fonction list() en passant l'ensemble en paramĂštre.
mon_ensemble = {1, 2, 3, 4}
ma_liste = list(mon_ensemble)
print(f"Ma liste : {ma_liste}") # Ma liste : [1, 2, 3, 4] (ordre variable)
Pour convertir une liste en un ensemble, il suffit d'appeler la fonction set() en passant la liste en paramĂštre.
ma_liste = [1, 2, 2, 3, 4]
mon_ensemble = set(ma_liste)
print(f"Mon ensemble : {mon_ensemble}") # Mon ensemble : {1, 2, 3, 4} (ordre variable)
On remarque que les doublons de la liste ont été automatiquement supprimés lors de la conversion en ensemble.
Cette propriété est trÚs utile pour éliminer les répétitions d'une liste.
On peut combiner deux ensembles avec des opérateurs mathématiques :
groupe_a = {1, 2, 3}
groupe_b = {3, 4, 5}
Union | : tous les éléments des deux ensembles réunis, sans doublons. Comme si on fusionnait deux groupes en retirant les répétitions.
print(groupe_a | groupe_b) # {1, 2, 3, 4, 5}
Intersection & : uniquement les éléments présents dans les deux ensembles à la fois. Ce qu'ils ont en commun.
print(groupe_a & groupe_b) # {3}
Différence - : les éléments qui sont dans le premier ensemble mais pas dans le second. Ce que le premier a en exclusivité.
print(groupe_a - groupe_b) # {1, 2}

On peut parcourir les éléments d'un ensemble avec une boucle for :
heros = {"Peach", "Yoshi", "Kirby"}
for hero in heros:
print(hero)
Contrairement aux listes, un ensemble ne conserve aucun ordre.
à chaque exécution, les éléments peuvent apparaßtre dans un ordre différent :
# Exécution 1 :
Kirby
Peach
Yoshi
# Exécution 2 :
Yoshi
Kirby
Peach
# Exécution 3 :
Peach
Yoshi
Kirby
Si l'ordre est important, on utilise une liste plutĂŽt qu'un ensemble.
KeyError Se produit lorsqu'on tente de supprimer un élément absent avec remove() :
heros = {"Peach", "Yoshi", "Kirby"}
heros.remove("Pikachu") # â KeyError: 'Pikachu'
Pour éviter cette erreur, on vérifie d'abord que l'élément est présent avec in, ou on utilise discard() :
if "Pikachu" in heros:
heros.remove("Pikachu")
# ou plus simplement :
heros.discard("Pikachu") # Ne fait rien si absent
Les ensembles sont trĂšs utiles pour :
- Ăliminer les doublons d'une liste (convertir une liste en ensemble supprime automatiquement les rĂ©pĂ©titions).
- Vérifier rapidement si un élément est présent dans une collection (plus rapide qu'une liste).
- Effectuer des opérations mathématiques sur des groupes de données : union, intersection, différence.
Ensemble non ordonné et sans doublons, défini avec des accolades {}.
| Opération | Syntaxe | Description |
|---|---|---|
| Créer | couleurs = {"rouge", "vert", "bleu"} | Nouvel ensemble |
| Créer (vide) | couleurs = set() | Ensemble vide (pas {}) |
| Présence | est_present = "rouge" in couleurs | Retourne True ou False |
| Ajouter | couleurs.add("jaune") | Ajoute un élément (sans doublon) |
| Supprimer (erreur si absent) | couleurs.remove("vert") | LĂšve une erreur si absent |
| Supprimer (sans erreur) | couleurs.discard("vert") | Ne fait rien si absent |
| Union | ensemble_union = a | b | Tous les éléments des deux ensembles |
| Intersection | ensemble_commun = a & b | ĂlĂ©ments communs aux deux ensembles |
| DiffĂ©rence | ensemble_diff = a - b | ĂlĂ©ments dans a mais pas dans b |
| Convertir en liste | ma_liste = list(couleurs) | Transforme l'ensemble en liste |
| Convertir une liste en ensemble | couleurs = set(ma_liste) | Transforme une liste en ensemble (sans doublons) |
| Longueur | nb_elements = len(couleurs) | Nombre d'éléments |
Les explications de cette section étaient-elles claires ?
Un tuple est une collection ordonnée et immuable d'éléments.
Contrairement Ă une liste, un tuple ne peut pas ĂȘtre modifiĂ© aprĂšs sa crĂ©ation : on ne peut pas ajouter, retirer ou remplacer ses Ă©lĂ©ments.
Il est défini avec des parenthÚses () :
coordonnees = (10, 20)
On l'utilise quand les valeurs sont fixes par nature : des coordonnées, une date, les dimensions d'une image.
Le fait qu'il soit immuable est une garantie que ces valeurs ne changeront pas accidentellement.
On crée un tuple avec des parenthÚses () et des valeurs séparées par des virgules :
mon_tuple = (1, 2, 3, "quatre", True)
Les parenthĂšses sont optionnelles : Python reconnaĂźt le tuple grĂące aux virgules.
mon_tuple = 1, 2, 3, "quatre", True
On peut transformer une liste existante en tuple avec la fonction tuple() :
ma_liste = [1, 2, 3]
mon_tuple = tuple(ma_liste)
print(mon_tuple) # Résultat : (1, 2, 3)
On peut transformer un tuple en une liste avec la fonction list() :
mon_tuple = (1, 2, 3)
ma_liste = list(mon_tuple)
print(ma_liste) # Résultat : [1, 2, 3]
On peut accĂ©der aux Ă©lĂ©ments d'un tuple en utilisant des indices, de la mĂȘme maniĂšre que pour les listes :
mon_tuple = (10, 20, 30, 40, 50)
print(mon_tuple[0]) # Résultat : 10
print(mon_tuple[2]) # Résultat : 30
Comme les listes, les indices négatifs fonctionnent aussi :
print(mon_tuple[-1]) # Résultat : 50
print(mon_tuple[-3]) # Résultat : 30
Cependant, comme les tuples sont immuables (contrairement aux listes), on ne peut pas modifier leurs éléments :
mon_tuple[0] = 100 # Cela provoquera une erreur
On peut vérifier si une valeur est dans un tuple avec in :
coordonnees = (10, 20, 30)
print(10 in coordonnees) # True
print(99 in coordonnees) # False
On peut affecter chaque valeur d'un tuple Ă une variable distincte en une seule ligne.
Le nombre de variables doit correspondre exactement au nombre d'éléments :
coordonnees = (10, 20, 30)
x, y, z = coordonnees
print(x) # 10
print(y) # 20
print(z) # 30
Une fonction qui retourne plusieurs valeurs utilise souvent un tuple pour les regrouper.
- Les parenthĂšses sont souvent omises aprĂšs le
return. - Les valeurs retournĂ©es peuvent ĂȘtre soit capturĂ©es dans une seule variable (un tuple), soit dĂ©composĂ©es en plusieurs variables, ce qui est trĂšs pratique.
def calculer_operations(a, b):
somme = a + b
produit = a * b
return somme, produit # Retourne un tuple (somme, produit)
resultat = calculer_operations(3, 5)
print(resultat) # Résultat : (8, 15)
somme, produit = calculer_operations(3, 5)
print(somme) # Résultat : 8
print(produit) # Résultat : 15
TypeError Se produit lorsqu'on tente de modifier un élément d'un tuple. Les tuples sont immuables, cette opération est donc interdite :
mon_tuple = (10, 20, 30)
mon_tuple[0] = 100 # â TypeError: 'tuple' object does not support item assignment
IndexError Se produit lorsqu'on tente d'accéder à un index inexistant :
mon_tuple = (10, 20, 30)
print(mon_tuple[5]) # â IndexError: tuple index out of range
Les tuples sont trĂšs utiles pour :
- Regrouper des valeurs liées qui ne doivent pas changer (coordonnées GPS, dimensions, date).
- Retourner plusieurs valeurs depuis une fonction de façon claire et concise.
- Décomposer plusieurs variables en une seule ligne grùce à l'affectation multiple.
Liste ordonnée et immuable, définie avec des parenthÚses ().
| Opération | Syntaxe | Description |
|---|---|---|
| Créer | coordonnees = (10, 20) | Nouveau tuple |
| CrĂ©er (sans parenthĂšses) | coordonnees = 10, 20 | Ăquivalent avec parenthĂšses implicites |
| Convertir une liste | mon_tuple = tuple(ma_liste) | Transforme une liste en tuple |
| Convertir en liste | ma_liste = list(mon_tuple) | Transforme un tuple en liste |
| AccĂ©der | element = coordonnees[0] | ĂlĂ©ment Ă l'index 0 |
| Indice négatif | dernier = coordonnees[-1] | Dernier élément |
| Longueur | nb_elements = len(coordonnees) | Nombre d'éléments |
| Présence | est_present = 10 in coordonnees | Retourne True ou False |
| Décomposer | x, y = coordonnees | Assigne chaque élément à une variable |
| Retour multiple | return a, b | Retourne plusieurs valeurs (tuple implicite) |
Les explications de cette section étaient-elles claires ?
Un dictionnaire associe chaque clĂ© Ă une valeur, un peu comme un dictionnaire papier oĂč chaque mot est associĂ© Ă une dĂ©finition.
On peut accéder rapidement à une valeur en connaissant sa clé.
Par exemple, on peut stocker les données d'une expérience de chimie :
- la clé
"nom"est associĂ©e Ă la valeur"Ălectrolyse de l'eau"(str) - la clĂ©
"tentative"est associée à la valeur2(int) - la clé
"tension_volts"est associée à la valeur1.5(float) - la clé
"succes"est associée à la valeurTrue(bool) - la clé
"gaz_produits"est associée à la valeur["hydrogÚne", "oxygÚne"](list)
On utilise des accolades {}, avec les clés et valeurs séparées par : et chaque paire séparée par une virgule , :
experience = {
"nom": "Ălectrolyse de l'eau",
"tentative": 2,
"tension_volts": 1.5,
"succes": True,
"gaz_produits": ["hydrogĂšne", "oxygĂšne"]
}
On peut aussi partir d'un dictionnaire vide et y ajouter des paires clé-valeur une à une :
experience = {}
experience["nom"] = "Ălectrolyse de l'eau"
experience["tentative"] = 2
experience["tension_volts"] = 1.5
experience["succes"] = True
experience["gaz_produits"] = ["hydrogĂšne", "oxygĂšne"]
On accÚde à la valeur associée à une clé en utilisant les crochets [] :
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2, "succes": True}
print(experience["nom"]) # RĂ©sultat : Ălectrolyse de l'eau
print(experience["tentative"]) # Résultat : 2
On peut modifier la valeur associĂ©e Ă une clĂ© existante de la mĂȘme façon :
experience["tentative"] = 3
print(experience["tentative"]) # Résultat : 3
Pour supprimer une paire clé-valeur d'un dictionnaire, on utilise le mot-clé del suivi de la clé à supprimer :
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2, "succes": True}
del experience["succes"]
print(experience) # RĂ©sultat : {'nom': "Ălectrolyse de l'eau", 'tentative': 2}
- Les clĂ©s dans un dictionnaire doivent ĂȘtre de types immuables (comme les chaĂźnes de caractĂšres, les nombres ou les tuples immuables).
- Les valeurs peuvent ĂȘtre de n'importe quel type, y compris des listes, des ensembles, des tuples ou mĂȘme d'autres dictionnaires.
experience = {
"nom": "Ălectrolyse de l'eau", # clĂ© str, valeur str
"tentative": 2, # clé str, valeur int
"tension_volts": 1.5, # clé str, valeur float
"succes": True, # clé str, valeur bool
"gaz_produits": ["hydrogÚne", "oxygÚne"] # clé str, valeur list
"auteurs": { # clé str, valeur dict
"Alice": "chercheuse principale",
"Bob": "assistant"
}
}
On peut vérifier si une clé existe dans un dictionnaire avec in :
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2, "succes": True}
print("nom" in experience) # True
print("temperature" in experience) # False
â ïž in vĂ©rifie les clĂ©s uniquement, pas les valeurs.
On peut obtenir le nombre de paires clé: valeur avec len() :
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2, "succes": True}
print(len(experience)) # 3
Trois méthodes permettent d'accéder au contenu d'un dictionnaire :
.keys(): retourne toutes lesclésdu dictionnaire..values(): retourne toutes lesvaleursdu dictionnaire..items(): retourne toutes les paires(clé, valeur)sous forme de tuples.
Ces méthodes retournent des types spéciaux (dict_keys, dict_values, dict_items) qui se comportent comme des listes pour l'itération.
On peut les parcourir directement avec une boucle for, comme on le verra dans la section suivante.
On peut parcourir un dictionnaire avec une boucle for de trois maniĂšres selon ce dont on a besoin.
Sur les clés : .keys()
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2, "succes": True}
for cle in experience.keys(): # cle â "nom", puis "tentative", puis "succes"
print(cle)
nom
tentative
succes
Sur les valeurs : .values()
for valeur in experience.values(): # valeur â "Ălectrolyse de l'eau", puis 2, puis True
print(valeur)
Ălectrolyse de l'eau
2
True
Sur les paires clé-valeur : .items()
for cle, valeur in experience.items(): # ("nom", "Ălectrolyse de l'eau"), puis ("tentative", 2), puis ("succes", True)
print(f"{cle} : {valeur}")
nom : Ălectrolyse de l'eau
tentative : 2
succes : True
KeyError Levée dans deux situations : quand on accÚde à une clé inexistante ou quand on tente de la supprimer :
experience = {"nom": "Ălectrolyse de l'eau", "tentative": 2}
print(experience["temperature"]) # KeyError: 'temperature'
del experience["temperature"] # KeyError: 'temperature'
Pour éviter cette erreur, on vérifie d'abord que la clé est présente avec in :
if "temperature" in experience:
print(experience["temperature"])
del experience["temperature"]
Les dictionnaires sont trĂšs utiles pour :
- Stocker des données structurées (comme les informations d'un joueur : nom, score, niveau).
- Compter des occurrences (par exemple, combien de fois chaque mot apparaĂźt dans un texte).
- Regrouper des données associées (comme associer chaque héros à son score).
Paires clé-valeur, défini avec des accolades {}.
| Opération | Syntaxe | Description |
|---|---|---|
| CrĂ©er | experience = {"nom": "Ălectrolyse", "tentative": 2} | Nouveau dictionnaire |
| Créer (vide) | experience = {} | Dictionnaire vide |
| Accéder | valeur = experience["nom"] | Valeur associée à la clé |
| Ajouter / Modifier | experience["succes"] = True | Ajoute ou écrase la paire clé-valeur |
| Supprimer | del experience["tentative"] | Supprime la paire clé-valeur |
| Présence | cle_existe = "nom" in experience | Vérifie si la clé existe |
| Clés | liste_cles = experience.keys() | Retourne toutes les clés |
| Valeurs | liste_valeurs = experience.values() | Retourne toutes les valeurs |
| Paires | liste_paires = experience.items() | Retourne les paires (clé, valeur) |
| Longueur | nb_paires = len(experience) | Nombre de paires clé-valeur |
| Itérer (clés) | for cle in experience.keys(): | Parcourir toutes les clés |
| Itérer (valeurs) | for val in experience.values(): | Parcourir toutes les valeurs |
| Itérer (paires) | for cle, val in experience.items(): | Parcourir clés et valeurs |
Les explications de cette section étaient-elles claires ?
Matplotlib est une bibliothÚque de visualisation de données en Python qui permet de créer des graphiques statiques, animés et interactifs. Elle est largement utilisée pour l'analyse de données, la science des données et l'apprentissage-machine (machine learning).
N'hésitez pas à consulter la documentation officielle de Matplotlib pour plus de détails et d'exemples.
Afin de pouvoir utiliser Matplotlib dans un projet, il faut d'abord installer la bibliothĂšque Matplotlib dans votre projet.
Matplotlib est une bibliothĂšque qui contient plusieurs modules.
Le module le plus couramment utilisé pour créer des graphiques est pyplot.
Pour l'importer dans un script, on utilise la commande suivante :
import matplotlib.pyplot as plt
Ici, nous importons le module pyplot de Matplotlib et lui donnons l'alias plt pour simplifier son utilisation dans le code.
Nous pourrons ainsi appeler les fonctions du module pyplot en utilisant le préfixe plt.
Par exemple :
plt.plot(x, y) # Pour tracer un graphique
plt.show() # Pour afficher le graphique
qui est plus court et lisible que :
matplotlib.pyplot.plot(x, y)
matplotlib.pyplot.show()
Créons d'abord un graphique trÚs simple, avec 3 points :
import matplotlib.pyplot as plt
# Données à tracer
x = [-100, 0, 100] # Liste des abscisses (x) des 3 points
y = [10000, 0, 10000] # Liste des ordonnées (y) des 3 points
# Tracer les points (-100, 10000), (0, 0) et (100, 10000)
plt.plot(x, y)
# Afficher le graphique
plt.show()
Exécutez ce code pour voir le résultat.

âžïž Avec plt.show(), le graphique s'ouvre dans une fenĂȘtre et le programme reste en pause jusqu'Ă ce que vous fermiez la fenĂȘtre.
Si votre programme « ne finit pas », vĂ©rifiez qu'aucune fenĂȘtre de graphique n'est restĂ©e ouverte!
La fonction plt.plot(x, y) trace les points définis par les listes x et y.
Elle nĂ©cessite qu'on lui fournisse deux listes de mĂȘme longueur : une pour les abscisses (x) et une pour les ordonnĂ©es (y).
â Si les deux listes n'ont pas la mĂȘme longueur, par exemple x = [-100, 0, 100] et y = [10000, 0] :
ValueError: x and y must have same first dimension, but have shapes (3,) and (2,)
Les shapes (3,) et (2,) indiquent la longueur de chaque liste : il manque une valeur dans y!
Mais elle peut aussi prendre des paramĂštres optionnels pour personnaliser le graphique, comme la couleur, le style de ligne, les marqueurs, etc.
Nous allons en voir quelques-uns. Commençons par leurs valeurs par défaut :
import matplotlib.pyplot as plt
# Données à tracer
x = [-100, 0, 100]
y = [10000, 0, 10000]
# Tracer les points
plt.plot(
x, y,
color = 'C0', # couleur
linestyle = '-', # type de ligne
marker = None, # type de point
linewidth = 1.5, # épaisseur de la ligne
markersize = 6, # taille des marqueurs
alpha = 1.0, # opacité (0.0 - 1.0)
label = None # étiquette pour la légende
)
plt.show()

Le rĂ©sultat est le mĂȘme qu'avec plt.plot(x, y), car les paramĂštres que nous avons spĂ©cifiĂ©s sont les valeurs par dĂ©faut.
Il n'est pas nécessaire d'écrire tous les paramÚtres d'une fonction!
On commence par appeler la fonction avec seulement ses paramĂštres obligatoires.
Une fois que le graphique de base s'affiche correctement, on ajoute les paramÚtres facultatifs un à la fois, en vérifiant le résultat à chaque ajout.
La plupart des exercices ne demandent d'ailleurs que quelques paramĂštres.
plt.plot(x, y):xetysont les seuls paramĂštres obligatoires.color,linestyle,label, etc. sont facultatifs.plt.legend(): aucun paramĂštre obligatoire.
Exemple de progression :
# Ătape 1 : version minimale, seulement les paramĂštres obligatoires
plt.plot(x, y)
# Ătape 2 : on ajoute un paramĂštre facultatif et on vĂ©rifie le rĂ©sultat
plt.plot(x, y, color='green')
# Ătape 3 : on en ajoute un autre, puis on affiche la lĂ©gende
plt.plot(x, y, color='green', label='y = xÂČ')
plt.legend()
Si une erreur apparaßt, on sait qu'elle vient du dernier paramÚtre ajouté.
Changeons quelques paramĂštres pour voir leur effet :
import matplotlib.pyplot as plt
x = [-100, 0, 100]
y = [10000, 0, 10000]
plt.plot(
x, y,
color = 'darkorange', # orange foncé
linestyle = '', # pas de ligne
marker = 'o', # cercle pour les points
markersize = 16 # points plus gros
)
plt.show()

Ajoutons maintenant plus de points pour obtenir une courbe de :
import matplotlib.pyplot as plt
# Données à tracer
x = [i for i in range(-100, 101)] # Entiers de -100 Ă 100
y = [i ** 2 for i in x] # Carrés des entiers
plt.plot(x, y)
plt.show()
On obtient une belle parabole.

On peut appeler plusieurs fois plt.plot() pour ajouter plusieurs Ă©lĂ©ments sur le mĂȘme graphique.
Par exemple, affichons en orange foncĂ© les points oĂč x est un multiple de 10 :
- Le premier appel Ă
plt.plot()dessine les lignes. - Puis un deuxiĂšme appel Ă
plt.plot()dessine les points en orange avec une opacité de 0.75.
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
# Points oranges pour les x multiples de 10
x_orange = [i for i in x if i % 10 == 0]
y_orange = [i ** 2 for i in x_orange]
# les lignes :
plt.plot(x, y)
# les points :
plt.plot(
x_orange, y_orange,
color = 'darkorange',
linestyle = '', # pas de ligne
marker = 'o',
markersize = 12,
alpha = 0.75
)
plt.show()

Ajoutons maintenant la courbe miroir en vert pour :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y] # miroir de y
x_orange = [i for i in x if i % 10 == 0]
y_orange = [i ** 2 for i in x_orange]
plt.plot(x, y)
plt.plot(
x_orange, y_orange,
color = 'darkorange',
linestyle = '',
marker = 'o',
markersize = 12,
alpha = 0.75
)
plt.plot(
x, y_miroir,
color = 'green'
)
plt.show()

On peut ajouter une grille pour mieux visualiser les points, Ă l'aide de la fonction plt.grid() :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y]
plt.plot(x, y)
plt.plot(x, y_miroir, color = 'darkorange')
# Ajouter une grille (valeurs par défaut)
plt.grid(
axis = 'both', # 'both' : les 2 axes
# 'x' : lignes verticales
# 'y' : lignes horizontales
linestyle = '-', # ligne pleine
linewidth = 0.8, # épaisseur fine
color = '#b0b0b0', # gris pĂąle
alpha = 1.0 # opaque
)
# Si la grille passe par-dessus des points, ajouter :
plt.gca().set_axisbelow(True)
plt.show()

Le paramĂštre facultatif linestyle permet de changer le style de ligne, autant pour une courbe (plt.plot()) que pour la grille (plt.grid()).
Par exemple, linestyle='--' trace une ligne pointillée :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y]
plt.plot(x, y)
plt.plot(x, y_miroir, linestyle='--') # courbe pointillée
plt.grid(linestyle='--') # grille pointillée
plt.gca().set_axisbelow(True)
plt.show()
Remarquez qu'on n'a pas indiquĂ© de couleur, mais que les deux courbes sont quand mĂȘme de couleurs diffĂ©rentes (bleu et orange). Quand on trace plusieurs courbes, Matplotlib leur donne automatiquement des couleurs diffĂ©rentes.
Le paramÚtre color n'est donc nécessaire que pour choisir une couleur précise.

Pour rendre le graphique plus compréhensible, on peut ajouter un titre au graphique, des étiquettes (labels) aux axes et on peut aussi personnaliser les ticks (valeurs affichées) d'un axe, en modifiant leur rotation, leur alignement et la taille de leur police :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y]
plt.plot(x, y)
plt.plot(x, y_miroir, color = 'darkorange')
# Titre du graphique
plt.title("Graphique de y = xÂČ et y = -xÂČ")
# Titres des axes
plt.xlabel("Axe des X")
plt.ylabel("Axe des Y")
# Personnalisation des ticks
# (valeurs affichées) de l'axe des X
plt.xticks(
rotation=30, # rotation des ticks
ha='right', # alignement horizontal
fontsize=20 # taille de la police
)
# Ajuste la mise en page pour éviter les coupures
plt.tight_layout()
plt.show()

Lorsque nous avons plusieurs courbes sur le mĂȘme graphique, il est important de les diffĂ©rencier en ajoutant une lĂ©gende.
Pour cela, on peut utiliser le paramÚtre label dans les appels à plt.plot() pour donner une étiquette à chaque courbe, puis appeler la fonction plt.legend() pour afficher la légende avec les étiquettes correspondantes :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y]
plt.plot(
x, y,
label='y = xÂČ' # Ă©tiquette pour la lĂ©gende
)
plt.plot(
x, y_miroir,
marker='o',
color = 'darkorange',
label='y = -xÂČ' # Ă©tiquette pour la lĂ©gende
)
# Affiche la légende avec les
# étiquettes définies dans les appels à plt.plot()
plt.legend(
loc='lower right', # position
title="Fonction", # titre de la légende
title_fontsize=30, # taille du titre
prop={'size': 20}, # taille des étiquettes
markerscale=2 # taille des marqueurs
)
plt.show()

plt.legend() sans labelplt.legend() affiche seulement les étiquettes données avec le paramÚtre label="..." dans les appels à plt.plot().
Si aucune courbe n'a de label, la légende n'affiche rien (Matplotlib affiche seulement un avertissement dans la console).
plt.plot(x, y)
plt.plot(x, y_miroir)
plt.legend() # â aucune lĂ©gende : les courbes n'ont pas de label
plt.plot(x, y, label='y = xÂČ')
plt.plot(x, y_miroir, label='y = -xÂČ')
plt.legend() # â
la lĂ©gende affiche « y = xÂČ Â» et « y = -xÂČ Â»
Si on souhaite dĂ©cider de la taille exacte de notre graphique, on peut utiliser la fonction plt.figure(), qui doit ĂȘtre appelĂ©e avant les appels Ă plt.plot() :
import matplotlib.pyplot as plt
x = [i for i in range(-100, 101)]
y = [i ** 2 for i in x]
y_miroir = [-i for i in y]
# largeur = 9 pouces, hauteur = 4 pouces
plt.figure(figsize=(9, 4))
plt.plot(x, y)
plt.plot(x, y_miroir, color = 'darkorange')
plt.show()

Au lieu d'afficher le graphique à l'écran avec plt.show(), on peut le sauvegarder dans un fichier image (PNG, JPG, SVG, etc.) en utilisant la fonction plt.savefig() :
plt.savefig("mon_graphique.png") # Sauvegarde le graphique en format PNG
plt.savefig("mon_graphique.svg") # Sauvegarde le graphique en format SVG
plt.savefig("mon_graphique.jpg") # Sauvegarde le graphique en format JPG
plt.savefig("mon_graphique.pdf") # Sauvegarde le graphique en format PDF
Il faut ajouter ce code avant plt.show(), et un fichier image sera créé dans le mĂȘme rĂ©pertoire que le script, avec le nom spĂ©cifiĂ©.
Lorsqu'on gĂ©nĂšre plusieurs graphiques dans le mĂȘme script, il est important de les gĂ©rer correctement pour Ă©viter les confusions entre les diffĂ©rentes figures.
Ce code gĂ©nĂšre 3 courbes diffĂ©rentes sur le mĂȘme graphique :
import matplotlib.pyplot as plt
x = [i for i in range(-10, 11)]
y = [i ** 2 for i in x]
plt.plot(x, y)
plt.plot(x, [-i for i in y])
plt.plot(x, x)
plt.savefig("figure.pdf")
plt.show()
Remarque : par défaut, chaque appel à plt.plot() utilise une couleur différente, ce qui permet de différencier les courbes.

Mais si on voulait créer plusieurs graphiques séparés, il faut utiliser plt.figure() pour créer une nouvelle figure avant de tracer un nouveau graphique :
import matplotlib.pyplot as plt
x = [i for i in range(-10, 11)]
y = [i ** 2 for i in x]
plt.figure() # Crée une premiÚre figure
plt.plot(x, y) # Trace une courbe dans cette premiĂšre figure
plt.savefig("figure1.pdf") # Sauvegarde la figure
plt.figure() # Crée une nouvelle figure
plt.plot(x, [-i for i in y])
plt.savefig("figure2.pdf")
plt.figure()
plt.plot(x, x)
plt.savefig("figure3.pdf")
plt.show() # Affiche toutes les figures
- Lâappel Ă
plt.show()est optionnel et sert uniquement Ă afficher les figures Ă lâĂ©cran. - Sans
plt.figure(), les courbes seraient toutes tracĂ©es sur la mĂȘme figure.



Matplotlib offre une grande variété de types de graphiques pour visualiser les données de différentes maniÚres.
Vous pouvez les explorer dans la documentation officielle de Matplotlib.
Voici quelques exemples qui vous seront utiles :
plt.scatter() : pour créer des nuages de points
import matplotlib.pyplot as plt
x = [i for i in range(10)]
y = [i ** 2 for i in x]
tailles_points = [i * 10 for i in y]
# [0, 10, 40, 90, 160, 250, 360, 490, 640, 810]
plt.scatter(x, y, alpha=0.5, s=tailles_points)
plt.scatter(x, x, alpha=0.5, s=200)
plt.show()
plt.scatter() permet de dessiner des points, tout comme plt.plot() avec marker='o' et linestyle=''.
Cependant, plt.scatter() offre plus de contrĂŽle, notamment en permettant de modifier la taille (s) de chaque point individuellement (ici les points bleus).

plt.bar() : pour créer des graphiques à barres
import matplotlib.pyplot as plt
categories = ['A', 'B', 'C', 'D']
valeurs = [10, 15, 7, 12]
plt.bar(categories, valeurs)
plt.show()
Le paramĂštre facultatif color permet de choisir la couleur des barres.
Si on lui donne une liste de couleurs, chaque barre reçoit la couleur Ă la mĂȘme position dans la liste (la 1re barre reçoit la 1re couleur, etc.) :
import matplotlib.pyplot as plt
categories = ['A', 'B', 'C', 'D']
valeurs = [10, 15, 7, 12]
couleurs = ['skyblue', 'limegreen', 'gold', 'salmon']
plt.bar(categories, valeurs, color=couleurs)
plt.show()
La liste couleurs doit contenir autant d'éléments que la liste categories.
Pour que toutes les barres aient la mĂȘme couleur, on donne une seule couleur : color='skyblue'.
plt.boxplot() : pour créer des boßtes à moustaches
Contrairement à plt.bar(), qui affiche une seule valeur par catégorie, plt.boxplot() permet de visualiser la distribution complÚte des données pour chaque catégorie.
import matplotlib.pyplot as plt
categories = ['A', 'B', 'C', 'D']
data = [
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6],
[1, 3, 5, 7, 9],
[2, 2, 3, 3, 4, 10]
]
plt.boxplot(data, tick_labels=categories)
plt.show()
Comment interpréter une boßte à moustaches :
- La ligne du milieu (orange) représente la médiane : 50 % des valeurs sont en dessous, 50 % au-dessus.
- Le bas de la boßte représente le 1er quartile (Q1) : 25 % des valeurs sont en dessous.
- Le haut de la boßte représente le 3e quartile (Q3) : 75 % des valeurs sont en dessous.
- La hauteur de la boĂźte est lâintervalle interquartile (IQR) = Q3 â Q1 : il contient le 50 % central des donnĂ©es.
- Les moustaches (les traits) sâĂ©tendent jusquâĂ 1,5 Ă IQR au-delĂ de Q1 et Q3.
- Les cercles (âą) sont les valeurs aberrantes (outliers) : valeurs qui dĂ©passent les moustaches.
Voici les problÚmes les plus fréquents : certains génÚrent une erreur explicite, d'autres produisent silencieusement un résultat inattendu.
Avant de chercher l'erreur à la main, on utilise le débogueur PyCharm.
On place un point d'arrĂȘt avant plt.plot() et on inspecte les listes dans le panneau des variables :
- on vérifie leur longueur avec
len() - on vérifie leur type avec
type() - on vérifie leurs valeurs
Le débogueur montre exactement ce que Matplotlib reçoit comme données.
ValueError: x and y must have same first dimensionLes listes x et y n'ont pas le mĂȘme nombre d'Ă©lĂ©ments. On vĂ©rifie que leurs longueurs sont identiques.
ValueError: x and y must have same first dimension, but have shapes (3,) and (2,)
x = [1, 2, 3]
y = [10, 20] # â 2 Ă©lĂ©ments au lieu de 3
plt.plot(x, y) # â ValueError
x = [1, 2, 3]
y = [10, 20, 30] # â
mĂȘme nombre d'Ă©lĂ©ments
plt.plot(x, y)
On a oublié plt.show(), ou on a appelé plt.show() avant de tracer les données. plt.show() doit toujours venir en dernier.
plt.show() # â avant de tracer
plt.plot(x, y)
plt.plot(x, y)
plt.show() # â
en dernier
Matplotlib rĂ©utilise la mĂȘme figure par dĂ©faut. Il faut appeler plt.figure() avant de commencer un nouveau graphique pour repartir d'une ardoise vide.
plt.plot(x, y1)
plt.show()
plt.plot(x, y2) # â s'ajoute Ă la figure prĂ©cĂ©dente
plt.show()
plt.figure() # â
nouvelle figure vide
plt.plot(x, y1)
plt.figure() # â
nouvelle figure vide
plt.plot(x, y2)
plt.show() # â
affiche les deux figures séparément
AttributeError: ... got an unexpected keyword argumentLe nom d'un paramÚtre facultatif est mal écrit. « unexpected keyword argument » signifie que Matplotlib ne connaßt aucun paramÚtre portant ce nom.
On vérifie l'orthographe et les majuscules : Python distingue les majuscules des minuscules, donc Linestyle et linestyle sont deux noms différents.
AttributeError: Line2D.set() got an unexpected keyword argument 'Linestyle'
plt.plot(x, y, Linestyle='--') # â « L » majuscule â AttributeError
plt.plot(x, y, linestyle='--') # â
tout en minuscules
Le message indique entre apostrophes le nom fautif ('Linestyle') : c'est ce paramĂštre qu'il faut corriger.
Les explications de cette section étaient-elles claires ?
Pour favoriser une progression efficace, ce cours adopte une approche de classe inversée. Ce modÚle déplace l'acquisition théorique hors de la classe pour transformer les heures de rencontre en véritables séances d'application pratique.
-
Ă la maison (Exploration et Appropriation) : Vous ĂȘtes le maĂźtre de votre rythme. Ces activitĂ©s vous permettent de dĂ©couvrir les nouveaux concepts et tester les exemples au moment oĂč vous ĂȘtes le plus concentrĂ©. Si une notion vous semble obscure, n'hĂ©sitez pas Ă poser des questions Ă votre prof au fur et Ă mesure.
-
En classe (Application et Consolidation) : Le temps en prĂ©sentiel est une ressource prĂ©cieuse. Nous l'utilisons pour nous attaquer aux dĂ©fis plus complexes et aux exercices de programmation qui demandent une mobilisation active de vos connaissances. Câest le moment idĂ©al pour obtenir une rĂ©troaction immĂ©diate, collaborer avec vos pairs et bĂ©nĂ©ficier de l'accompagnement de votre enseignant au moment oĂč vous en avez le plus besoin.
- đ ActivitĂ©s Ă faire Ă la maison
- đ« ActivitĂ©s Ă faire en classe
đ§ Auto-validation des connaissancesâ
Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R09. Ne faites ce questionnaire que lorsque vous vous sentez en trÚs bonne maßtrise de la matiÚre. En classe, dÚs votre arrivée, vous aurez un questionnaire trÚs similaire, évalué sommativement, à compléter sans accÚs à aucune documentation.
Ne pas remplir le formulaire diminue fortement vos chances de rĂ©ussir l âĂ©valuation sommative en dĂ©but de rencontre.
Assurez-vous de bien comprendre toutes les notions derriĂšre chaque question.
đš Exercices de crĂ©ationâ
Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.
Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.
đ CrĂ©ez un fichier r09_virus_liste_simple.py pour votre rĂ©ponse.
Umbrella Corporation souhaite afficher la liste des virus qu'elle possĂšde.
La présentation souhaitée est détaillée ci-dessous. La liste est contenue dans la variable virus.
virus = ["Virus-T", "Virus-C", "Virus-G", "Uroboros"]
â ïž CONTRAINTES Ă RESPECTERâ
- Votre code doit fonctionner peu importe le nombre d'éléments dans la liste.
- Si la liste est vide, afficher un message sympa Ă l'utilisateur.
- Si la liste n'est pas vide, vous devez utiliser un
for element in listepour parcourir les éléments de la liste. - Vous pouvez modifier le contenu de la liste fournie pour tester différents scénarios.
â RĂSULTAT ATTENDU AVEC LA LISTE DE DĂPART FOURNIEâ
Liste des 4 virus :
Virus-T
Virus-C
Virus-G
Uroboros
â RĂSULTAT ATTENDU AVEC UNE LISTE Ă 2 ĂLĂMENTSâ
Liste des 2 virus :
Virus-T
Virus-C
â RĂSULTAT ATTENDU AVEC UNE LISTE VIDEâ
Désolé aucun produit pharmaceutique mortel disponible
Listes, boucle for ... in, fonction len(), test de liste vide
đ CrĂ©ez un fichier r09_virus_listes_paralleles.py pour votre rĂ©ponse.
Recopiez le code de l'exercice précédent, il vous servira de point de départ.
La Umbrella Corporation souhaite améliorer le rapport précédent fait.
Elle vous fournit sous la forme d'une liste des caractéristiques sur chaque virus.
virus = ["Virus-T", "Virus-C", "Virus-G", "Uroboros"]
caracteristiques = [
"Transforme les humains en zombies et armes biologiques",
"Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus",
"Cause des mutations incontrÎlables avec régénération cellulaire rapide",
"Consomme les organismes incompatibles et renforce les hĂŽtes compatibles"
]
Comme les deux listes doivent ĂȘtre parcourues en parallĂšle via un index commun, un for element in liste ne fonctionnera pas. Utilisez for i in range(len()).
â RĂSULTAT ATTENDU AVEC LES LISTES DE DĂPART FOURNIESâ
Liste des 4 virus :
Virus-T - Transforme les humains en zombies et armes biologiques
Virus-C - Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus
Virus-G - Cause des mutations incontrÎlables avec régénération cellulaire rapide
Uroboros - Consomme les organismes incompatibles et renforce les hĂŽtes compatibles
â RĂSULTAT ATTENDU AVEC DES LISTES Ă 2 ĂLĂMENTSâ
Liste des 2 virus :
Virus-T - Transforme les humains en zombies et armes biologiques
Virus-C - Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus
Listes parallĂšles, boucle for i in range(len(...)), parcours par index
đ CrĂ©ez un fichier r09_virus_liste_2d.py pour votre rĂ©ponse.
Recopiez le code du premier exercice, il vous servira de point de départ.
La Umbrella Corporation souhaite améliorer le rapport précédent fait.
La corporation souhaite désormais afficher dans le rapport le taux de succÚs de mutation.
Elle vous fournit désormais toutes les données sous la forme d'une seule liste!
virus_et_autres_info = [
["Virus-T", 0.9 ,"Transforme les humains en zombies et armes biologiques"],
["Virus-C", 0.0001 ,"Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus"],
["Virus-G", 0.85, "Cause des mutations incontrÎlables avec régénération cellulaire rapide"],
["Uroboros", 0.005, "Consomme les organismes incompatibles et renforce les hĂŽtes compatibles"]
]
Le taux de mutation est stocké comme un nombre décimal (ex. 0.9). Pour l'afficher en pourcentage, multipliez par 100 (ex. 0.9 * 100 = 90.0%).
â RĂSULTAT ATTENDU AVEC LA LISTE DE DĂPART FOURNIEâ
Liste des 4 virus :
Virus-T - Transforme les humains en zombies et armes biologiques (taux de mutation estimé : 90.0%)
Virus-C - Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus (taux de mutation estimĂ© : 0.01%)
Virus-G - Cause des mutations incontrÎlables avec régénération cellulaire rapide (taux de mutation estimé : 85.0%)
Uroboros - Consomme les organismes incompatibles et renforce les hÎtes compatibles (taux de mutation estimé : 0.5%)
â RĂSULTAT ATTENDU AVEC UNE LISTE DE 2 LISTESâ
Liste des 2 virus :
Virus-T - Transforme les humains en zombies et armes biologiques (taux de mutation estimé : 90.0%)
Virus-C - Provoque des mutations extrĂȘmes et rĂ©gĂ©nĂšre les tissus (taux de mutation estimĂ© : 0.01%)
Listes à 2 dimensions (listes imbriquées), accÚs par index multiple, f-strings, formatage de pourcentage
đ CrĂ©ez un fichier r09_comprehension_liste.py pour votre rĂ©ponse.
La compréhension de liste permet de transformer, filtrer et manipuler des données de maniÚre concise et efficace.
Ă partir de la liste suivante :
liste = [1, 2, 3, 4, 5]
Vous devez créer 6 nouvelles listes en utilisant exclusivement la compréhension de liste.
Chaque cas représente une transformation ou une opération différente.
đ§© CAS Ă COMPLĂTERâ
-
Multiplier chaque élément par 5
Résultat attendu : [5, 10, 15, 20, 25] -
Garder uniquement les nombres supérieurs à 2
Résultat attendu : [3, 4, 5] -
Créer une liste de booléens indiquant si chaque nombre est supérieur à 3
Résultat attendu : [False, False, False, True, True] -
Créer une nouvelle liste contenant les carrés sous forme de texte
Résultat attendu : ['Le carré de 1 est 1', 'Le carré de 2 est 4', ..., 'Le carré de 5 est 25']
Une f-string sera nécessaire dans la section expression de la compréhension de liste.
- Remplacer les nombres impairs par le mot "impair"
Résultat attendu : ['impair', 2, 'impair', 4, 'impair']
Un if/else compacte est nécessaire dans la section expression de la compréhension de liste.
- Doubler uniquement les nombres pairs
Résultat attendu : [4, 8]
â FORMAT ATTENDUâ
Pour chaque cas, vous devez écrire votre code comme ceci :
casX = [ ... ] # Remplacez les "..." par votre compréhension de liste
print(casX)
Compréhension de liste, filtrage (if), transformation (expression), if/else compact, f-strings
đ CrĂ©ez un fichier r09_ensembles.py pour votre rĂ©ponse.
Les ensembles (set) permettent de stocker des éléments uniques et d'effectuer des opérations mathématiques comme l'union, l'intersection ou la différence.
Ă partir des ensembles suivants :
ensemble1 = {1, 2, 3, 4, 5}
ensemble2 = {4, 5, 6, 7, 8}
Vous devez créer 3 nouveaux ensembles et compléter 1 cas de conversion.
Pour les cas 1 à 3, utilisez les opérations ensemblistes (union, intersection et différence) pour obtenir les résultats demandés.
- Chaque rĂ©sultat doit ĂȘtre obtenu par une seule opĂ©ration entre
ensemble1etensemble2. - Vous devez déterminer quelle opération convient à chaque cas.
- Vous ne devez pas modifier les ensembles de départ ni construire les résultats élément par élément (avec
add(),remove(), etc.). - N'utilisez ni boucles ni compréhensions de liste.
Pour le cas 4, utilisez les conversions appropriées pour éliminer les doublons et obtenir une liste triée.
đ§© CAS Ă COMPLĂTERâ
- Résultat attendu : {1, 2, 3, 4, 5, 6, 7, 8}
- Résultat attendu : {4, 5}
- Résultat attendu : {1, 2, 3}
-
La liste suivante contient des doublons. Convertissez-la en ensemble pour les supprimer, puis obtenez une liste triée.
Résultat attendu : [1, 3, 5, 7, 9]mesures = [3, 7, 3, 1, 7, 9, 1, 5]
La fonction sorted() retourne une liste triée à partir d'un ensemble.
â FORMAT ATTENDUâ
Pour les cas 1 Ă 3, utilisez le format suivant :
casX = ensemble1 ... ensemble2 # Remplacez les "..." par l'opérateur approprié
print(casX)
Pour le cas 4 :
cas4 = ... # Conversion et tri
print(cas4)
Ensembles (set), union, intersection, différence, conversion de types et tri avec sorted().
đ CrĂ©ez un fichier r09_dictionnaires_imbrique.py pour votre rĂ©ponse.
Les données de température d'une journée d'une ville sont stockées sous forme de dictionnaire.
info = {
"lieu": "Raccoon City",
"date": "2025-07-12",
"temperatures_C": {
"Matin": 18.2,
"Midi": 22.5,
"AprĂšs-midi": 24.1,
"Soir": 20.3
}
}
Ăcrivez un programme qui :
- Affiche le lieu et la date en en-tĂȘte.
- Affiche chaque moment de la journée avec sa température, alignés en colonnes.
- Calcule et affiche la température moyenne.
Le résultat doit correspondre exactement au format suivant (y compris les espaces, les lignes vides et les indentations) :
Températures à Raccoon City le 2025-07-12
Matin : 18.2 °C
Midi : 22.5 °C
AprÚs-midi : 24.1 °C
Soir : 20.3 °C
Température moyenne : 21.28 °C
Pour accĂ©der aux tempĂ©ratures, utilisez info['temperatures_C']. C'est lui-mĂȘme un dictionnaire que vous pouvez parcourir avec .items().
Consultez l'aide-mémoire sur les f-strings pour les options de formatage permettant d'aligner du texte sur une largeur fixe.
Dictionnaires imbriqués, accÚs par clé, .items(), calcul de moyenne, alignement avec f-strings
đ CrĂ©ez un fichier r09_jeu_devinette_ameliore.py pour votre rĂ©ponse.
Partez du code suivant (version de base du jeu de devinette) et améliorez-le afin d'insulter gentiment l'utilisateur s'il saisit un nombre déjà saisi.
MalgrĂ© sa stupiditĂ©, vous devez quand mĂȘme lui indiquer si la bonne rĂ©ponse est plus haute ou plus basse!
import random
nombre_secret = random.randint(1, 100)
while True:
devine = int(input("Tente de trouver le nombre que j'ai en tĂȘte : "))
if devine == nombre_secret: #Condition d'arrĂȘt de la boucle
break
elif devine < nombre_secret: # Indication sur la direction, mĂȘme si l'essai Ă©tait rĂ©pĂ©tĂ©
print("Plus haut!\n")
else:
print("Plus bas!\n")
print("Bravo humain, tu as trouvé le nombre!")
â ïž CONTRAINTES Ă RESPECTERâ
- Stockez tous les essais de l'utilisateur dans un ensemble.
- Utilisez l'opérateur
inpour vérifier si un essai a déjà été saisi.