đ Fichiers, đą NumPy
- Tuple (tuple)
- Dictionnaire (dict)
- Fichier
- Fichier texte
- Fichier CSV
- NumPy
- NumPy et Matplotlib
- Exercices
Vous connaissez maintenant les 4 types de données de base en Python :
- les entiers (
int) : 5, -3, 42, 0, ... - les nombres Ă virgule (
float) : 3.14, -0.001, 2.0, ... - les chaĂźnes de caractĂšres (
str) : "Bonjour", 'a', "123", ... - les booléens (
bool) :True,False
Et deux structures de données principales :
- les listes (
list) : une collection ordonnée et modifiable d'éléments, définie en utilisant des crochets[]. - les ensembles (
set) : une collection non ordonnée et non indexée d'éléments uniques, définie en utilisant des accolades{}.
Nous allons maintenant découvrir deux autre types de structures de données en Python :
- les tuples (
tuple). - les dictionnaires (
dict).
Un tuple est une collection ordonnée et immuable d'éléments.
Contrairement aux listes, les tuples ne peuvent pas ĂȘtre modifiĂ©s aprĂšs leur crĂ©ation.
Ils sont définis en utilisant des parenthÚses ().
# Création d'un tuple
mon_tuple = (1, 2, 3, "quatre", True)
On peut aussi créer un tuple sans parenthÚses :
mon_tuple = 1, 2, 3, "quatre", True
On peut convertir une liste en tuple en utilisant la fonction tuple() :
ma_liste = [1, 2, 3]
mon_tuple = tuple(ma_liste)
print(mon_tuple) # 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
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
Le dictionnaire est une structure de données trÚs puissante en Python, mais aussi plus complexe que les listes, les ensembles ou les tuples.
Il ressemble Ă un ensemble, oĂč chaque Ă©lĂ©ment unique est en fait une clĂ©, associĂ©e Ă une valeur.
Un peu comme un dictionnaire papier, oĂč chaque mot (la clĂ©) est associĂ© Ă une dĂ©finition (la valeur).
On peut accéder rapidement à une valeur en connaissant sa clé.
Par exemple, on peut créer un dictionnaire pour stocker des informations sur une personne :
- la clé "nom" est associée à la valeur "Alice"
- la clé "ùge" est associée à la valeur 30
- la clé "ville" est associée à la valeur "Montréal"
Pour créer un dictionnaire, on utilise des accolades {} et on sépare les clés des valeurs avec des deux-points :.
Chaque paire clé-valeur est séparée par une virgule ,.
# Création d'un dictionnaire
mon_dict = {
"nom": "Alice",
"Ăąge": 30,
"ville": "Montréal"
}
On peut aussi créer un dictionnaire vide et y ajouter des éléments plus tard (ce qui est plus courant et trÚs pratique) :
mon_dict = {}
mon_dict["nom"] = "Alice"
mon_dict["Ăąge"] = 30
On peut accéder aux valeurs d'un dictionnaire en utilisant leurs clés :
mon_dict = {"nom": "Alice", "ùge": 30, "ville": "Montréal"}
print(mon_dict["nom"]) # Résultat : Alice
print(mon_dict["ùge"]) # Résultat : 30
On peut aussi modifier les valeurs associées à une clé :
mon_dict["Ăąge"] = 31
print(mon_dict["ùge"]) # Résultat : 31
- 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.
mon_dict = {
"nom": "Alice", # clé str, valeur str
"ùge": 30, # clé str, valeur int
"notes": [85, 90, 78], # clé str, valeur list
"adresse": { # clé str, valeur dict
"rue": "123 Rue Principale",
"ville": "Montréal"
}
}
On peut parcourir les clés ou les paires clé-valeur d'un dictionnaire en utilisant une boucle for :
mon_dict = {"nom": "Alice", "ùge": 30, "ville": "Montréal"}
# Itération sur les clés :
for cle in mon_dict:
print(cle) # Affiche chaque clé
print("---")
# Itération sur les paires clé-valeur :
for cle, valeur in mon_dict.items():
print(cle, valeur) # Affiche chaque paire clé-valeur
L'exécution de ce code affichera :
nom
Ăąge
ville
---
nom Alice
Ăąge 30
ville Montréal
Voici quelques méthodes couramment utilisées avec les dictionnaires :
mon_dict.keys(): retourne unelistdes clés du dictionnaire.mon_dict.values(): retourne unelistdes valeurs du dictionnaire.mon_dict.items(): retourne unelistde tuples (clé, valeur).
Exemple :
mon_dict = {"nom": "Alice", "ùge": 30, "ville": "Montréal"}
print(mon_dict.keys()) # Résultat : dict_keys(['nom', 'ùge', 'ville'])
print(mon_dict.values()) # Résultat : dict_values(['Alice', 30, 'Montréal'])
print(mon_dict.items()) # Résultat : dict_items([('nom', 'Alice'), ('ùge', 30), ('ville', 'Montréal')])
Les dictionnaires sont trĂšs utiles pour :
- Stocker des données structurées (comme des informations sur une personne, un produit, etc.).
- Compter des occurrences (par exemple, compter combien de fois chaque mot apparaĂźt dans un texte).
- Regrouper des données associées (comme des listes de scores pour différents joueurs).
Un fichier c'est quoi?
- un ensemble de données stockées sur un support de stockage (disque dur, SSD, clé USB, carte SD, etc.)
- chaque fichier a un nom et une extension (par exemple
monfichier.txt) - les fichiers peuvent contenir différents types de données : texte, images, vidéos, audio, etc.
- pour lire ou écrire dans un fichier, on utilise des programmes ou des scripts
Types de fichiers courantsâ
- Fichiers texte (.txt, .csv, .json, .xml, etc.)
- Fichiers binaires (.bin, .exe, .dll, etc.)
- Fichiers image (.jpg, .png, .gif, etc.)
- Fichiers audio (.mp3, .wav, .flac, etc.)
- Fichiers vidéo (.mp4, .avi, .mkv, etc.)
OpĂ©rations courantes sur les fichiersâ
- Ouvrir un fichier : pour lire ou écrire des données
- Lire un fichier : pour extraire les données contenues dans le fichier
- Ăcrire dans un fichier : pour ajouter ou modifier des donnĂ©es dans le fichier
- Fermer un fichier : pour libérer les ressources utilisées par le fichier
En Python, on utilise la fonction open() pour ouvrir un fichier. Par exemple :
# Ouvrir un fichier en mode lecture
fichier = open("monfichier.txt", "r")
# Lire le contenu du fichier
contenu = fichier.read()
print(contenu)
# Fermer le fichier
fichier.close()
Un fichier texte est un type de fichier trĂšs courant et simple Ă manipuler.
- Il est simplement constitué d'une suite de caractÚres lisibles par l'humain.
- Il ne contient aucun formatage, juste du texte brut.
- â
Les scripts Python (
.py) que vous Ă©crivez sont aussi des fichiers texte. - â Un fichier
.docx(Word) ou.pdfcontient du texte, mais aussi beaucoup d'autres informations de formatage, donc ce ne sont pas des fichiers texte.
Un fichier texte est organisé en lignes.
- Chaque ligne peut contenir plusieurs morceaux de données séparés par des espaces, des tabulations, des virgules, etc.
- Les lignes sont séparées par des caractÚres spéciaux appelés "sauts de ligne" (
\n).
On peut souvent ouvrir ou créer un fichier texte
- à la main avec un éditeur de texte (Notepad, Pycharm, VSCode, ...)
- avec du code Python pour les manipuler
Exemple de code Python pour lire un fichier texte ligne par ligne :
# Ouvrir un fichier en mode lecture
with open("monfichier.txt", "r") as f: # "r" pour "read"
# Lire chaque ligne du fichier
for ligne in f:
print(ligne, end="") # end="" pour éviter d'ajouter des lignes vides supplémentaires
Exemple de code Python pour écrire dans un fichier texte :
# Ouvrir un fichier en mode écriture
with open("monfichier.txt", "w") as f: # "w" pour "write"
# Ăcrire des lignes dans le fichier
f.write("Bonjour le monde!\n")
f.write("Ceci est un fichier texte.\n")
En Python, il est recommandé d'utiliser le mot-clé with pour gérer les fichiers.
- Cela garantit que le fichier est correctement fermĂ© aprĂšs son utilisation, mĂȘme en cas d'erreur.
- Le fichier est automatiquement fermé lorsque le bloc
withest quitté.
with open("monfichier.txt", "r") as f:
contenu = f.read()
# Le fichier est automatiquement fermé ici
On peut aussi lire tout le contenu d'un fichier texte en une seule fois avec la méthode read() :
Supposons que le fichier monfichier.txt contient :
Y a pas deux gros.
Y en a qu'un seul.
Et il est pas gros.
On peut lire tout le contenu du fichier avec le code suivant :
with open("monfichier.txt", "r") as f:
contenu = f.read()
print(contenu)
La variable contenu contiendra alors la chaĂźne de caractĂšres complĂšte du fichier, y compris les sauts de ligne :
Y a pas deux gros.
Y en a qu'un seul.
Et il est pas gros.
On peut aussi lire toutes les lignes d'un fichier texte en une seule fois avec la méthode readlines() :
with open("monfichier.txt", "r") as f:
lignes = f.readlines()
print(lignes)
La variable lignes contiendra alors une liste de chaßnes de caractÚres, chaque chaßne représentant une ligne du fichier, avec les sauts de ligne (\n) inclus :
["Y a pas deux gros.\n", "Y en a qu'un seul.\n", "Et il est pas gros.\n"]
PlutÎt que d'écrire ligne par ligne avec write(), on peut d'abord construire une liste de lignes, puis utiliser la méthode join() pour joindre les lignes avec des sauts de ligne (\n) en une seule chaßne de caractÚres, et enfin écrire cette chaßne dans le fichier.
lignes = ["Y a pas deux gros.", "Y en a qu'un seul.", "Et il est pas gros."]
with open("monfichier.txt", "w") as f:
f.write("\n".join(lignes))
Un fichier CSV (Comma-Separated Values) est un type de fichier texte utilisé pour stocker des données tabulaires, comme dans une feuille de calcul ou une base de données.
- Chaque ligne du fichier représente un enregistrement (ou une ligne de données).
- Les valeurs dans chaque ligne sont séparées par des virgules (
,) (comma), bien que d'autres dĂ©limiteurs comme le point-virgule (;) ou la tabulation puissent aussi ĂȘtre utilisĂ©s.
Exemple de contenu d'un fichier CSV :
jour,heures_ensoleillement,temperature_moyenne,precipitations
Lundi,5,22.5,0.0
Mardi,6,24.0,1.2
Mercredi,4,19.5,0.0
Jeudi,5,21.0,0.5
Vendredi,7,23.5,0.0
Samedi,8,25.0,0.0
Dimanche,3,20.0,2.3
En Python, on peut utiliser le module intégré csv pour lire et écrire des fichiers CSV facilement.
Lire un fichier CSVâ
import csv
with open("monfichier.csv", "r") as f:
lecteur_csv = csv.reader(f)
for ligne in lecteur_csv:
print(ligne)
Ăcrire dans un fichier CSVâ
import csv
donnees = [
["jour", "heures_ensoleillement", "temperature_moyenne", "precipitations"],
["Lundi", 5, 22.5, 0.0],
["Mardi", 6, 24.0, 1.2],
["Mercredi", 4, 19.5, 0.0],
["Jeudi", 5, 21.0, 0.5],
["Vendredi", 7, 23.5, 0.0],
["Samedi", 8, 25.0, 0.0],
["Dimanche", 3, 20.0, 2.3]
]
with open("monfichier.csv", "w", newline='') as f:
ecrivain_csv = csv.writer(f)
ecrivain_csv.writerows(donnees)
import csv
jours = []
heures_ensoleillement = []
temperature_moyenne = []
precipitations = []
with open("monfichier.csv", "r") as f:
lecteur_csv = csv.reader(f)
next(lecteur_csv) # Ignorer la ligne d'en-tĂȘte
for ligne in lecteur_csv:
jours.append(ligne[0])
heures_ensoleillement.append(float(ligne[1])) # Conversion en nombre flottant
temperature_moyenne.append(float(ligne[2])) # Conversion en nombre flottant
precipitations.append(float(ligne[3])) # Conversion en nombre flottant
print("Jours :", jours)
print("Heures d'ensoleillement :", heures_ensoleillement)
print("Températures moyennes :", temperature_moyenne)
print("Précipitations :", precipitations)
affichera :
Jours : ['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']
Heures d'ensoleillement : [5.0, 6.0, 4.0, 5.0, 7.0, 8.0, 3.0]
Températures moyennes : [22.5, 24.0, 19.5, 21.0, 23.5, 25.0, 20.0]
Précipitations : [0.0, 1.2, 0.0, 0.5, 0.0, 0.0, 2.3]
Lors de la lecture de données avec le module csv, les données sont toujours obtenues en format string.
Des conversions peuvent ĂȘtre nĂ©cessaires au besoin.
- Remarquez ci-haut la fonction
float()appelée lors de la lecture des nombres.
On pourrait maintenant utiliser ces listes pour faire des analyses ou des visualisations :
import matplotlib.pyplot as plt
plt.plot(jours, temperature_moyenne, marker='o')
plt.plot(jours, heures_ensoleillement, marker='s')
plt.plot(jours, precipitations, marker='^')
plt.title("Température moyenne sur la semaine")
plt.xlabel("Jour")
plt.ylabel("Température (°C)")
plt.grid()
plt.legend(["Température moyenne", "Heures d'ensoleillement", "Précipitations"])
plt.show()

NumPy est une bibliothÚque Python trÚs populaire pour le calcul scientifique et l'analyse de données.
- Elle fournit des structures de données puissantes, comme les tableaux multidimensionnels (
ndarray), qui permettent de manipuler efficacement de grandes quantités de données numériques. - NumPy offre également une large gamme de fonctions mathématiques et statistiques optimis ées pour travailler avec ces tableaux.
Pour utiliser NumPy, il faut d'abord l'importer :
import numpy as np
On peut créer un tableau NumPy à partir d'une liste Python en utilisant la fonction np.array() :
liste = [1, 2, 3, 4, 5]
tableau = np.array(liste)
print(tableau) # Résultat : [1 2 3 4 5]
print(type(tableau)) # Résultat : <class 'numpy.ndarray'>
NumPy permet de créer des tableaux multidimensionnels (matrices) en passant une liste de listes à np.array() :
liste_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tableau_2d = np.array(liste_2d)
print(tableau_2d)
Cela affichera :
[[1 2 3]
[4 5 6]
[7 8 9]]
Un tableau NumPy possÚde plusieurs propriétés utiles :
shape: retourne la forme (dimensions) du tableau (sous forme de tuple).dtype: retourne le type de données des éléments du tableau.size: retourne le nombre total d'éléments dans le tableau. Exemple :
tableau = np.array([[1, 2, 3], [4, 5, 6]])
print(tableau.shape) # Résultat : (2, 3)
print(tableau.dtype) # Résultat : int64 (ou int32 selon la plateforme)
print(tableau.size) # Résultat : 6
Les tableaux NumPy permettent d'effectuer des opérations mathématiques de maniÚre efficace et concise. Par exemple, on peut additionner deux tableaux élément par élément :
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b # Résultat : array([5, 7, 9])
On peut aussi effectuer des opérations plus complexes, comme le calcul de la moyenne ou de la somme des éléments :
tableau = np.array([1, 2, 3, 4, 5])
moyenne = np.mean(tableau) # Résultat : 3.0
somme = np.sum(tableau) # Résultat : 15
On peut accĂ©der aux Ă©lĂ©ments d'un tableau NumPy en utilisant des indices, de la mĂȘme maniĂšre que pour les listes Python :
tableau = np.array([10, 20, 30, 40, 50])
print(tableau[0]) # Résultat : 10
print(tableau[2]) # Résultat : 30
On peut aussi utiliser le slicing pour extraire des sous-tableaux :
tableau = np.array([10, 20, 30, 40, 50])
sous_tableau = tableau[1:4] # Résultat : array([20, 30, 40])
Voici quelques fonctions couramment utilisées avec NumPy :
np.zeros(shape): crée un tableau rempli de zéros avec la forme spécifiée.np.ones(shape): crée un tableau rempli de uns avec la forme spécifiée.np.arange(start, stop, step): crée un tableau avec des valeurs espacées réguliÚrement.np.linspace(start, stop, num): crée un tableau avec un nombre spécifié de valeurs espacées réguliÚrement entre deux bornes.
tableau_zeros = np.zeros((3, 4)) # Tableau 3x4 rempli de zéros
print(tableau_zeros)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
tableau_uns = np.ones((2, 5)) # Tableau 2x5 rempli de uns
print(tableau_uns)
[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
tableau_arange = np.arange(0, 10, 2) # Résultat : array([0, 2, 4, 6, 8])
print(tableau_arange)
[0 2 4 6 8]
tableau_linspace = np.linspace(0, 1, 5) # Résultat : array([0. , 0.25, 0.5 , 0.75, 1. ])
print(tableau_linspace)
[0. 0.25 0.5 0.75 1. ]
NumPy permet de filtrer les Ă©lĂ©ments dâun tableau rapidement selon des conditions logiques, sans devoir utiliser de boucles explicitement!
La syntaxe est la suivante :
tableau [ tableau operateur_de_comparaison expression ]
Le résultat est un nouveau tableau NumPy filtré.
temperatures = np.array([-5, 2, 10, -3, 15])
positives = temperatures[temperatures > 0]
print(positives) # Résultat : [2, 10, 15]
Combiner plusieurs conditions
On peut combiner plusieurs conditions logiques ensemble.
L'exemple ci-dessous applique 2 conditions Ă l'aide d'un ET logique.
tableau = np.array([5, 12, 18, 25, 30])
filtre = tableau[(tableau > 10) & (tableau < 25)]
print(filtre) # Résultat : [12, 18]
Les tableaux NumPy permettent dâutiliser directement les opĂ©rateurs arithmĂ©tiques +, -, *, /, **, etc.
Ces opĂ©rations sâappliquent Ă©lĂ©ment par Ă©lĂ©ment et gĂ©nĂšrent un nouveau tableau sans besoin de boucle for!
x = np.array([10,20,30,40,50])
y = x * 2
z = x * 2 + 5
print(y) # Résultat : [20, 40, 60, 80, 100]
print(z) # Résultat : [25, 45, 65, 85, 105]
Ceci est particuliÚrement utile pour générer une liste y pour alimenter vos graphiques avec Matplotlib!
On peut combiner la lecture de fichiers CSV avec NumPy pour analyser des données numériques efficacement.
import csv
import numpy as np
jours = []
heures_ensoleillement = []
temperature_moyenne = []
precipitations = []
with open("monfichier.csv", "r") as f:
lecteur_csv = csv.reader(f)
next(lecteur_csv) # Ignorer la ligne d'en-tĂȘte
for ligne in lecteur_csv:
jours.append(ligne[0])
heures_ensoleillement.append(float(ligne[1]))
temperature_moyenne.append(float(ligne[2]))
precipitations.append(float(ligne[3]))
# Convertir les listes en tableaux NumPy
heures_ensoleillement_np = np.array(heures_ensoleillement)
temperature_moyenne_np = np.array(temperature_moyenne)
precipitations_np = np.array(precipitations)
print("Heures d'ensoleillement :", heures_ensoleillement_np)
print("Températures moyennes :", temperature_moyenne_np)
print("Précipitations :", precipitations_np)
NumPy s'intÚgre bien avec d'autres bibliothÚques Python populaires pour l'analyse de données et le machine learning, comme Pandas, Matplotlib et Scikit-learn.
- Par exemple, Pandas utilise des tableaux NumPy en interne pour stocker les données dans ses DataFrames.
- Matplotlib peut tracer des graphiques directement Ă partir de tableaux NumPy.
- Scikit-learn utilise NumPy pour manipuler les données d'entraßnement et de test.
Nous verrons comment utiliser NumPy avec Pandas et Scikit-learn au prochain cours.
Matplotlib s'intĂšgre bien avec NumPy, ce qui permet de tracer facilement des graphiques Ă partir de tableaux NumPy.
Par exemple, il est trÚs facile de tracer une fonction mathématique en utilisant NumPy pour générer les données et Matplotlib pour les afficher. Voici 2 exemples :
import numpy as np
import matplotlib.pyplot as plt
# Créer des données avec NumPy
x = np.linspace(0, 10, 100) # crée un tableau NumPy de 100 points entre 0 et 10
y = np.sin(x) # crée un tableau NumPy avec les valeurs du sinus de chaque élément de x
# Tracer le graphique
plt.plot(x, y)
plt.title("Graphique de la fonction sinus")
plt.xlabel("x")
plt.ylabel("sin(x)")
plt.grid()
plt.show()

Supposons que nous voulons représenter graphiquement la fonction .
Grùce aux pouvoirs des opérateurs arithmétiques sur des tableaux NumPy, on peut facilement créer un tableau NumPy y des résultats :
import numpy as np
import matplotlib.pyplot as plt
# Créer des données avec NumPy
x = np.linspace(-10, 100, 1000) # créer un tableau NumPy de 1000 points entre -10 et 100
y = 2 * x - 15 # créer un tableau NumPy avec la formule y = 2x - 15
# (grùce aux pouvoirs des opérateurs arithmétiques sur le tableau NumPy x)
# Tracer le graphique
plt.plot(x, y)
plt.title("Graphique de la fonction linéaire : y = 2x - 15")
plt.xlabel("x")
plt.ylabel("y")
plt.grid()
plt.show()

âïž Exercices de comprĂ©hensionâ
Soit le tuple suivant :
mon_tuple = (10, 20, 30, 40, 50)
- Quel est le type de
mon_tuple? - Quel est l'élément à l'index 2 ?
- Quel est l'élément à l'index -2 ?
- Peut-on modifier l'élément à l'index 0 pour qu'il vale 100? Comment? Justifiez.
đš Exercices de crĂ©ationâ
Un chercheur suit la température moyenne enregistrée chaque mois dans une réserve naturelle.
Les donnĂ©es sont stockĂ©es sous forme dâune liste de tuples, oĂč chaque tuple contient :
- le nom du mois
- la température moyenne en °C
Votre objectif :
- Extraire les noms des mois et les températures depuis la liste de tuples ci-dessous.
- Créer par programmation une liste pour les noms des mois et une liste pour les valeurs.
- La compréhension de liste peut vous aider à créer ces 2 listes rapidement.
- Afficher ces donnĂ©es dans un graphique linĂ©aire pour visualiser lâĂ©volution de la tempĂ©rature au fil des mois.
- Ajouter un titre, une grille et des Ă©tiquettes dâaxes claires en lien avec le graphique.
temperatures = [
("Janvier", 2.5),
("Février", 3.0),
("Mars", 6.2),
("Avril", 10.5),
("Mai", 15.3),
("Juin", 19.1),
("Juillet", 22.4),
("Août", 21.9),
("Septembre", 17.0),
("Octobre", 12.1),
("Novembre", 6.8),
("Décembre", 3.4)
]
Exemple de graphique attenduâ

Vous devez analyser les populations de différentes espÚces animales dans une réserve naturelle.
Pour chaque espÚce, une liste du nombre d'individus observés pour chacune des 4 saisons est fournie :
populations = {
"Cerfs": [32, 45, 50, 41],
"Renards": [12, 15, 13, 10],
"Lapins": [85, 102, 98, 76],
"Aigles": [5, 7, 6, 5]
}
saisons = ["Printemps", "ĂtĂ©", "Automne", "Hiver"]
ĂTAPE 1 - VOLET CONSOLEâ
Calculez et affichez à la console le résultat ci-dessous.
Les valeurs doivent ĂȘtre calculĂ©es Ă partir des donnĂ©es de la variable population.
Recensement pour les 4 espĂšces :
Cerfs : moyenne par saison = 42.0 individus
Renards : moyenne par saison = 12.5 individus
Lapins : moyenne par saison = 90.2 individus
Aigles : moyenne par saison = 5.8 individus
EspĂšce la plus nombreuse : Lapins (90.2 individus en moyenne)
NOTE : Votre code doit afficher l'espÚce la plus nombreuse en fonction des données fournies, pas les lapins à chaque fois!
ĂTAPE 2 - VOLET GRAPHIQUEâ
Générez le graphique ci-dessous.

Les données de température d'une journée d'une ville sont stockées sous forme de dictionnaire.
info = {
"lieu": "Raccon City",
"date": "2025-07-12",
"temperatures_C": {
"matin": 18.2,
"midi": 22.5,
"apres_midi": 24.1,
"soir": 20.3
}
}
Ăcrivez un programme prĂ©sentant ces informations sous la forme suivante (exactement, y compris les espaces, les lignes vides et les indentations) :
Températures à Raccon 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
Un biologiste Ă©tudie les tempĂ©ratures enregistrĂ©es dans une forĂȘt pendant plusieurs jours, les donnĂ©es sont enregistrĂ©es dans un fichier texte.
- Téléchargez le fichier temperatures.txt
- Placez-le dans le mĂȘme dossier que votre script Python.
En utilisant un script Python, vous devez :
- Lire le contenu de ce fichier
- Calculer la température moyenne
- Enregistrer le résultat dans un nouveau fichier nommé moyenne.txt
- Téléchargez le fichier Turing.csv
- Placez-le dans le mĂȘme dossier que votre script Python.
- Il contient tous les gagnants du Prix Turing.
En utilisant un script Python, vous devez:
- afficher le nombre total de lauréats
- afficher les lauréats dont la contribution mentionne le mot
intelligence - afficher les années avec 3 lauréats ou plus
RĂ©sultat attendu :â
Nombre total de lauréats : 79
Lauréats avec 'intelligence' dans la contribution :
Marvin Minsky
Allen Newell
Herbert A. Simon
Raj Reddy
Années avec 3 lauréats ou plus :
2002
2007
2018
Générez un graphique affichant ces 3 fonctions mathématiques sur l'intervalle de -10 à 10 :
- (fonction quadratique)
- (fonction linéaire)
- (fonction sinus)
Utilisez NumPy pour créer les données et Matplotlib pour tracer le graphique.
Utilisez 3 couleurs différentes pour chaque fonction et ajoutez une légende pour les identifier.
đŻ Solutions des exercices
Un solutionnaire possible pour chaque exercice est disponible en format vidĂ©o avec des explications. Vous pouvez vous en servir pour comparer votre solution avec une solution possible jugĂ©e optimale et vous dĂ©bloquer aprĂšs un long moment bloquĂ© sur un exercice (ex. 20 minutes) et aprĂšs avoir utilisĂ© le dĂ©gogueur pour essayer par vous-mĂȘme de trouver le problĂšme.
Il est tout Ă fait normal que certains problĂšmes demandent du temps, de la rĂ©flexion, et parfois mĂȘme un peu de frustration. Câest prĂ©cisĂ©ment dans ces moments dâeffort que lâapprentissage sâancre rĂ©ellement.
Consulter un solutionnaire avant dâavoir tentĂ© lâexercice par soi-mĂȘme, ou le parcourir trop rapidement, revient Ă court-circuiter le processus dâapprentissage. Ce nâest pas simplement contre-productif, câest pĂ©dagogiquement dĂ©sastreux.
En sautant lâĂ©tape de la rĂ©flexion personnelle, on prive son cerveau de lâoccasion de construire des connexions durables. Et Ă force de rĂ©pĂ©ter ce rĂ©flexe, on risque de passer Ă cĂŽtĂ© des compĂ©tences essentielles, ce qui peut mener Ă des Ă©checs plus tard, mĂȘme si tout semble facile sur le moment. Alors oui, prenez le temps. Lâerreur fait partie du jeu. Câest en cherchant, en tĂątonnant, en doutant, quâon devient rĂ©ellement compĂ©tent. Le solutionnaire doit ĂȘtre un outil de validation, pas un raccourci.
đš Solution des exercices de crĂ©ation :
Tuple,
Dictionnaire 1,
Dictionnaire 2,
Fichiers texte,
Prix turing,
Numpy et matplotlib