đ Fichiers, đą NumPy
- Tuple (tuple)
- Dictionnaire (dict)
- Fichier
- Fichier texte
- NumPy
- NumPy et Matplotlib
- Activités
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
- chaque fichier utilise un encodage de caractÚres du fichier (le standard étant l'UTF-8).
- c'est un peu comme la « table de traduction » permettant à l'ordinateur de transformer les bits (0 et 1) en lettres et en accents.
- sans le bon encodage, les caractÚres spéciaux comme le « é » ou le « à » s'afficheront mal.
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", encoding="utf-8")
# 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", encoding="utf-8") 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", encoding="utf-8") 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", encoding="utf-8") 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", encoding="utf-8") 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", encoding="utf-8") 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", encoding="utf-8") as f:
f.write("\n".join(lignes))
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!
La bibliothÚque NumPy servira principalement pour l'entraßnement de modÚles dans le cadre du cours 420-4A4 : Réseaux de neurones et sciences.
Son utilisation sera limitée, dans ce cours-ci, à la réalisation de graphiques.
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()

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 R10. 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â
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.
- Définissez les dimensions du graphique à 12x5 pouces en utilisant
plt.figure(...).- Cette instruction doit ĂȘtre placĂ©e avant toutes les autres instructions de traçage de votre 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)
REMARQUES
- Votre code doit afficher l'espÚce la plus nombreuse en fonction des données fournies, pas les lapins à chaque fois!
- Votre code doit fonctionner peu importe le nombre d'animaux dans le dictionnaire
populations. - Les couleurs des courbes seront automatiquement les bonnes.
INDICES
- Vous aurez besoin d'une variable pour conserver la moyenne la plus grande trouvée ainsi qu'une autre pour le nom de l'espÚce correspondante;
- L'algorithme est un peu similaire à celui utilisé pour l'exercice "CALCULER DES STATISTIQUES V1" de la rencontre R09.
Ă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,
"AprĂšs-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
Il est possible d'obtenir un alignement similaire en utilisant les options de formatage des chaĂźnes de caractĂšres des f-string
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 ligne par ligne
- Convertir chaque ligne en un float (ceci va retirer le saut de ligne automatiquement)
- Calculer la température moyenne
- Enregistrer le résultat dans un nouveau fichier nommé moyenne.txt
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.
EXEMPLE DE RĂSULTAT ATTENDU

âïž Exercices de comprĂ©hensionâ
Sur papier, sans ordinateur, écrivez le code permettant de connaitre le nombre de valeurs supérieures à 50 dans une liste.
Prenez la liste suivante comme référence :
liste = [20, 60, 50, 10, 70, 90]
Le programme devrait afficher le résultat suivant :
Contenu de la liste : [20, 60, 50, 10, 70, 90]
Nombre de valeurs supérieures à 50 : 3
Votre programme doit fonctionner peu importe le nombre d'éléments dans la liste et quels que soient ces nombres.
Validez votre réponse à l'aide de Pycharm.
Sur papier, sans ordinateur, écrivez le code permettant de résoudre le problÚme ci-dessous.
On dispose d'une liste nommée liste contenant des tuples. Chaque tuple est composé d'une lettre et d'un nombre.
On dispose également d'une variable lettre qui contient le caractÚre à rechercher.
liste = [("a", 1), ("b", 2), ("a", 3), ("c", 4), ("b", 5)]
lettre = "a"
Votre objectif est d'écrire la suite du programme pour que celui-ci affiche la somme des deuxiÚme éléments de chaque tuple,
mais uniquement lorsque le premier élément du tuple correspond à la valeur stockée dans la variable lettre.
Résultats attendus
Voici les résultats attendues selons différentes lettres :
- si
lettre = "a"âĄïž votre programme doit afficher : 4 - si
lettre = "b"âĄïž votre programme doit afficher : 7 - si
lettre = "c"âĄïž votre programme doit afficher : 4 - si
lettre = "d"âĄïž votre programme doit afficher : 0
Votre programme doit fonctionner correctement quelles que soient les valeurs contenues dans liste et dans lettre.
Validez votre réponse à l'aide de Pycharm.
Sur papier, sans ordinateur, tracez le graphique correspondant au code suivant le plus fidĂšlement possible. Graduez vos axes.
import matplotlib.pyplot as plt
x = [0, 1, 2, 3, 4, 5]
y = [0, 1, 4, 9, 16, 25]
plt.plot(x, y, marker='o', label='y = x^2')
plt.title("Graphique de la fonction y = x^2")
plt.xlabel("x")
plt.ylabel("y")
plt.grid()
plt.legend()
plt.show()
Une fois votre graphique tracé sur papier, validez votre réponse à l'aide de Pycharm.
Sur papier, sans ordinateur, tracez le graphique correspondant au code suivant le plus fidĂšlement possible. Graduez vos axes.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-10, 10, 100)
y = x ** 2
plt.plot(x, y, label='y = x^2')
plt.title("Graphique de la fonction y = x^2")
plt.xlabel("x")
plt.ylabel("y")
plt.grid()
plt.legend()
plt.show()
đĄ La courbe n'a pas besoin d'ĂȘtre parfaite, mais elle doit passer par des points clĂ©s.
Une fois votre graphique tracé sur papier, validez votre réponse à l'aide de Pycharm.
đŻ 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 :