📚 Scripts et fonctions

Script

Retour sur le mode interactif

Le mode interactif (dans la console) est pratique pour tester des idées, mais :

• Tout disparaît dès qu'on ferme la console (ou PyCharm).
• On ne peut pas conserver notre code.
• On doit tout retaper à chaque fois.

C'est pourquoi, à partir de maintenant, nous allons créer des scripts Python, c'est-à-dire des fichiers .py dans lesquels nous allons écrire et conserver tout notre code.

---

Bonjour le monde en python, dans un fichier texte

On va vite vouloir donner plein d'ordres à l'ordinateur en lui parlant en Python.

Ça devient pénible de les écrire les uns après les autres en mode interactif.
Alors, on va écrire les ordres les uns après les autres dans un fichier.

On va appeler ça un script Python.
Concrètement, c'est juste un fichier texte avec des instructions en Python.
On va faire terminer son nom par .py pour éviter de le mélanger avec les fichiers .pdf, .jpg, etc.

On va taper dans la zone du fichier les instructions, une par ligne.
Par exemple :

# ceci est un commentaire, cette ligne est pour les humains
# l'ordinateur va l'ignorer car elle commence par un "#"
print("bonjour bonjour cher maitre humain")
6 / 2 * (1 + 2)
print("Ca va aujourd'hui?")
print( 4 / 5 * (9 + 6) )
x = 6
y = 7
resultat = x * y
x = 0
y = resultat

On va ensuite exécuter notre script (il ne s'agit pas de le tuer).
On demande à python de suivre nos ordres, d'exécuter nos instructions, une par une.

En suivant cette recette, créez un script Python, copiez-y le code ci-haut, et exécutez-le.

Que voyez-vous?

• L'interpréteur a affiché trois lignes. Pourquoi?
• Il a exécuté les instructions ligne par ligne, de haut en bas.
• Il n'exécute rien pour les 2 premières lignes, car elles sont des commentaires.
• Il a exécuté la ligne 3, qui est une instruction print(), et il a affiché le texte entre guillemets.
• Il a ensuite exécuté la ligne 4, qui est un calcul, mais comme on ne lui a pas demandé d'afficher le résultat, il ne l'affiche pas.
• Il a ensuite exécuté la ligne 5, qui est encore une instruction print(), et il a affiché le texte entre guillemets.
• Il a ensuite exécuté la ligne 6, qui est encore une instruction print(), et il a affiché le résultat du calcul entre parenthèses.
• Il a ensuite exécuté les lignes 7 à 11, qui sont des affectations de variables. Comme on ne lui a pas demandé d'afficher quoi que ce soit, il n'affiche rien.

---

🚀 Pourquoi écrire des scripts?

Écrire notre code dans des fichiers .py permet de :

• ✅ Conserver nos programmes.
• ✅ Pouvoir les exécuter autant de fois qu'on veut.
• ✅ Pouvoir les améliorer petit à petit.

---

💾 Sauvegarde automatique

PyCharm sauvegarde automatiquement vos fichiers à chaque modification.
Inutile d'appuyer sur Ctrl + S ou de chercher une option Enregistrer. Vos changements sont toujours préservés sur votre poste.

⚠️ Attention toutefois : cette sauvegarde est locale. Pour envoyer vos modifications vers GitHub, un commit-push reste nécessaire.

---

▶️ Vérifiez toujours quel fichier sera exécuté

Les boutons d'exécution lancent le fichier indiqué à leur gauche, et non nécessairement celui que vous êtes en train de modifier!
Assurez-vous que ce sélecteur affiche toujours la valeur "Current File".

Parfois, PyCharm modifie cette valeur pour indiquer le nom d'un fichier script en particulier.
PyCharm exécutera alors ce fichier-là plutôt que celui ouvert, ce qui peut mener à des résultats inattendus.

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Débogueur

Pourquoi utiliser le débogueur

Le débogueur est un outil puissant qui permet de suivre l'exécution de votre code pas à pas. Il vous permet de voir la valeur des variables, d'arrêter l'exécution à des points spécifiques (points d'arrêt), et de comprendre comment votre programme fonctionne en détail.

Utiliser le débogueur est essentiel pour :

• Comprendre le flux d'exécution de votre programme.
• Analyser le comportement de votre code dans des situations spécifiques.
• Identifier et corriger les erreurs dans votre code.

---

Bonjour le monde dans un environnement de développement

On va être honnête, vos scripts ne vont pas souvent faire ce que vous voulez. Par contre, ils vont faire exactement ce que vous avez écrit. On va donc avoir besoin d'une méthode efficace pour comprendre ce qui se passe dans notre code.

Dans un environnement de développement (ou IDE, Integrated Developpement Environment) comme PyCharm, on va pouvoir :

• arrêter le temps!
• et voir à l'intérieur de l'ordinateur!

Lisez la section Déboguer pour apprendre à utiliser le débogueur dans PyCharm.

Ensuite, mettez un point d'arrêt à la ligne de la première instruction (les commentaires ne sont pas des instructions) dans le script Python créé à la section Script, donc à la ligne print("bonjour... :

# ceci est un commentaire, cette ligne est pour les humains
# l'ordinateur va l'ignorer car elle commence par un "#"
print("bonjour bonjour cher maitre humain")
6 / 2 * (1 + 2)
print("Ca va aujourd' hui?")
print( 4 / 5 * (9 + 6) )
x = 6
y = 7
resultat = x * y
x = 0
y = resultat

Roulez votre script, mais cette fois, en mode débogage (en cliquant sur l'icône du bug 🪲).

• L'exécution va s'arrêter sur le point d'arrêt.
• La ligne de code où se trouve le point d'arrêt sera mise en surbrillance et n'aura pas encore été exécutée.
• Si vous cliquez sur le bouton Step Over , l'instruction sera exécutée et vous pourrez voir le résultat dans la console.
• Si vous continuer à cliquer sur , vous pourrez exécuter le script ligne par ligne et observer son comportement.
• Si vous avez plus d'un point d'arrêt, vous pouvez cliquer sur le bouton Resume qui permet de continuer l'exécution jusqu'au prochain point d'arrêt.
• Vous pouvez également arrêter l'exécution à tout moment en cliquant sur le bouton Stop .

Avancez une ligne à la fois et, lorsque vous arrivez à la ligne x = 6, observez les variables qui sont créées et affichées dans la fenêtre de débogage, ainsi que leurs modification. En particulier, notez le changement du contenu des variables x et y lorsqu'elles sont modifiées.

À l'aide!

Si vous avez des difficultés à utiliser le débogueur, n'hésitez pas à demander de l'aide à votre enseignant.e ou à vos camarades de classe.

---

Raccourcis clavier

Vous pouvez exécuter les actions de débogage plus rapidement en utilisant des raccourcis clavier.

Action	Icône	Windows	macOS
Step Over		F8	F8
Resume		F9	⌥ Option + ⌘ Command + R
Stop		Ctrl + F2	⌘ Command + F2

---

Débogueur inutilisable en présence d'erreurs de syntaxe

Lorsqu’une erreur de syntaxe apparaît en rouge dans PyCharm, Python est incapable d’exécuter votre script, que ce soit en mode normal ou en mode débogage. Le programme ne comprend tout simplement pas ce qu’il doit faire. Pour le débogueur, il faut garder en tête que :

• Le débogueur ne fonctionne que sur un programme valide, c'est-à-dire sans erreur de syntaxe, même si le code contient des erreurs de logique.
• Une erreur de syntaxe empêche le code d’être transformé en instructions compréhensibles pour l'ordinateur.
• Tant que la syntaxe n’est pas corrigée, le débogueur reste inutilisable.

Par exemple, si vous tentez d'exécuter le programme suivant, avec ou sans le débogueur :

Vous obtiendrez un message indiquant une erreur de syntaxe à la ligne 4 :

Les erreurs de syntaxe à corriger dans cet exemple sont :

• Ligne 4 : Le symbole d'assignation = est manquant
• Ligne 5 : Il manque une parenthèse fermante )
• Ligne 7 : Le nom de la variable est invalide, les espaces sont interdites, utilisez plutôt des underscores _

Il faut aussi garder en tête que Python fait réellement de son mieux pour identifier l’emplacement exact d’une erreur. Selon la nature du problème, ce n’est pas toujours simple pour lui : l’erreur peut se trouver avant ou après la ligne indiquée. Il arrive donc que le numéro de ligne signalé ne corresponde pas parfaitement à la source du problème.

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Trace

Pourquoi faire une trace

La trace est un outil qui permet de suivre l'exécution d'un programme en affichant les valeurs des variables et les instructions exécutées à chaque étape. C'est un excellent moyen de comprendre comment votre code fonctionne et de détecter les erreurs.

---

Création d'une trace

Lisez la section Trace d'exécution pour apprendre à rédiger une trace.

Ensuite, avec un crayon et du papier, générez la trace (en tableau) pour le script Python créé à la section Script, montré ci-bas.

Une fois votre trace faite, vous allez exécuter le code pour valider qu'elle est correcte, en suivant ces étapes :

• Placez un point d'arrêt sur la première ligne qui s'exécute.
• Lancez l'exécution en mode débogage.
• Sautez de ligne en ligne pour voir si la trace est correcte (valeurs des variables, instructions exécutées).

ATTENTION

Il faut d'abord faire la trace à la main, sans regarder le débogueur, pour que ce soit un véritable exercice de compréhension du code. C'est seulement après avoir fait votre propre trace que vous devez utiliser le débogueur pour vérifier votre travail. À l'examen, vous n'aurez pas accès au débogueur, donc il est important de s'entraîner à faire des traces à la main

# ceci est un commentaire, cette ligne est pour les humains
# l'ordinateur va l'ignorer car elle commence par un "#"
print("bonjour bonjour cher maitre humain")
6 / 2 * (1 + 2)
print("Ca va aujourd' hui?")
print( 4 / 5 * (9 + 6) )
x = 6
y = 7
resultat = x * y
x = 0
y = resultat

Vous devriez normalement obtenir cette trace :

# ligne	x	y	resultat	affichage
3				bonjour bonjour cher maitre humain
4
5				Ca va aujourd' hui?
6				12
7	6
8	6	7
9	6	7	42
10	0	7	42
11	0	42	42

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Fonctions

📌 Fonctions

Une fonction est un ensemble d’instructions réutilisables regroupées sous un nom.
👉 Le nom doit être significatif : par exemple, on devine que print() sert à afficher quelque chose.

---

⚡ Comprendre une fonction

Quand on utilise une fonction, il n’est pas nécessaire de connaître tout son code interne.
Il faut surtout comprendre :

• Quels paramètres attend-elle ? (les infos entre ())
• Est-ce qu’elle retourne une valeur qu’on peut stocker ?
• Y a-t-il des cas limites ou erreurs possibles (exceptions) ?

---

🎯 Les paramètres

Pour appeler une fonction : nom_de_fonction(param1, param2, ...)
➡️ Le nombre et l’ordre des paramètres sont importants.

---

💾 Conserver une valeur de retour

On peut stocker le résultat d’une fonction dans une variable, par exemple :

mon_age_arrondi = round(17.8)

---

📌 Quelques fonctions utiles

Vous trouverez dans la section Fonctions utiles de l'aide-mémoire une liste non-exhaustive de fonctions utiles.

Découvrons-en quelques-unes :

---

Les fonctions min() et max()

Les fonctions min() et max() permettent de connaître le paramètre ayant la plus petite ou la plus grande valeur.
Ces deux fonctions doivent être utilisées avec des paramètres.

Par exemple :

# Trouver le plus petit
note1 = 85
note2 = 72
note3 = 91
plus_petite = min(note1, note2, note3)
print(f"La plus petite note est : {plus_petite}")  # 72

# Trouver le plus grand
plus_grande = max(note1, note2, note3)
print(f"La plus grande note est : {plus_grande}")  # 91

À noter : les fonctions min() et max() sont particulières en ce sens qu'elles peuvent prendre un nombre variable de paramètres, contrairement à la plupart des fonctions qui attendent un nombre fixe de paramètres.

---

La fonction len()

La fonction len() permet de calculer la longueur d'une chaîne de caractères (le nombre de caractères qu'elle contient).
Elle prend une chaîne de caractères en paramètre et retourne un entier représentant le nombre de caractères.

prenom = "Alice"
longueur_prenom = len(prenom)
print(f"La longueur du prénom {prenom} est : {longueur_prenom}")  # La longueur du prénom Alice est : 5

---

Diverses fonctions

Voici quelques exemples de fonctions utiles en Python, qui prennent différents nombres de paramètres :

# Conversion de types
valeur_entier = int("3")
valeur_flottant = float("3.41")
chaine_texte = str(42)

# Puissances et arrondi
valeur_puissance = pow(2, 3)
valeur_arrondie = round(3.14159, 2)

# Type d’une variable
type_variable = type(longueur_prenom)

---

Appels imbriqués

On peut imbriquer les appels de fonctions pour combiner plusieurs opérations en une seule ligne.
Ainsi, la valeur retournée par une fonction peut être utilisée directement comme paramètre d'une autre fonction.

print(len(str(42)))

Dans cet exemple, où trois appels de fonctions sont imbriqués, l'exécution se fait de l'intérieur vers l'extérieur :

1. La fonction str(42) convertit le nombre entier 42 en une chaîne de caractères "42",
2. puis la fonction len(...) calcule la longueur de cette chaîne, qui est 2,
3. et enfin la fonction print(...) affiche ce résultat.

---

La fonction print()

Comme on a déjà vu, la fonction print() permet d'afficher du texte ou des valeurs dans la console.
Elle peut prendre un nombre variable de paramètres, séparés par des virgules, qu'elle concaténera avec des espaces par défaut.

Par exemple, roulez ce code dans un script Python pour voir comment elle fonctionne :

# Exemple d’entrées numériques
nombre1 = 6
nombre2 = 7

# Fonction avec paramètres multiples
print("Le résultat de", nombre1, "x", nombre2, "est :", nombre1 * nombre2)

# Variante moderne : f-string
message = f"Le résultat de {nombre1} x {nombre2} est : {nombre1 * nombre2}"
print(message)

Par défaut, le contenu affiché à la console par la fonction print() est suivi d’un saut de ligne.

print("1")
print("2")
print("3")

La console affichera :

1
2
3

Il est possible de remplacer le saut de ligne automatique en ajoutant un paramètre nommé end.
Par exemple :

print("1", end=" ") # Remplacer le saut de ligne par une espace " "
print("2", end=" ")
print("3", end=" ")

La console affichera :

1 2 3

Le concept de paramètre nommé (comme end=) sera étudié dans la prochaine rencontre.

Il est possible de créer une ligne vide en utilisant la fonction print() sans lui passer de valeur.
Par exemple :

print("Hello")
print()
print("World")

La console affichera :

Hello

World

saut de ligne à l'aide du caractère \n

Il est également possible de faire un saut de ligne à l'aide du caractère spécial \n (un backslash suivi de la lettre n).

Si vous exécutez ce code :

print("A\nB\nC")

La console affichera :

A
B
C

afficher un guillemet " à l'aide du caractère \

Comme une chaîne de caractères est délimitée par des guillemets ("), écrire un guillemet à l'intérieur de cette chaîne poserait problème : Python croirait que la chaîne se termine là.

Pour insérer un guillemet dans la chaîne, on le fait précéder d'un backslash \. On dit qu'on échappe le caractère.

print("Elle a dit : \"Bonjour!\"")

La console affichera :

Elle a dit : "Bonjour!"

Le backslash \ permet d'échapper d'autres caractères spéciaux de la même façon :

• \' pour afficher une apostrophe dans une chaîne délimitée par des apostrophes
• \\ pour afficher un backslash

💡 Une autre astuce consiste à délimiter la chaîne avec des apostrophes (') si elle contient des guillemets (ou l'inverse) :

print('Elle a dit : "Bonjour!"')

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

f-strings

✨ Les f-strings, c'est quoi?

Une f-string (ou formatted string), c'est similaire à une phrase à trous : on écrit le texte normalement, et partout où on veut insérer une valeur, on laisse un trou avec des accolades {}. Python remplit ensuite chaque trou avec la valeur correspondante.

Pour créer une f-string, on place un f juste avant les guillemets. Par exemple, dans f"Le résultat de {nombre1} x {nombre2} est : {nombre1 * nombre2}", les trois trous {nombre1}, {nombre2} et {nombre1 * nombre2} sont remplis par leurs valeurs.

nombre1 = 3.14159265
nombre2 = 2
print(f"Le résultat de {nombre1} x {nombre2} est : {nombre1 * nombre2}.")

Cet exemple affiche le résultat :

Le résultat de 3.14159265 x 2 est : 6.2831853.

🤔 Pourquoi utiliser une f-string?

On pourrait obtenir un résultat semblable avec la concaténation (+) ou en séparant les éléments par des virgules dans print(). Mais la f-string est souvent plus lisible et évite d'avoir à convertir les nombres en str soi-même : on insère directement les variables et les expressions entre accolades, et Python s'occupe du reste.

---

🔢 Formatage des nombres

Les f-strings permettent un contrôle très précis de la présentation des nombres entiers et flottants.
Il suffit d’ajouter, à l’intérieur des accolades {}, après l’expression, un : suivi d’options pour contrôler le format.

Voici différentes options permettant de contrôler le format :

Syntaxe	Effet	Exemple
:.2f	Arrondi à 2 décimales, complété par des 0	3.14159265 → 3.14 / 3.5 → 3.50
:.0f	Arrondi sans décimale	3.99 → 4
:,	Spécifier le séparateur de milliers	1000000 → 1,000,000
:05d	Entier sur 5 chiffres, complété par des 0	42 → 00042
:+.2f	Affiche le signe + ou - et conserve 2 décimales	3.5 → +3.50 / -2 → -2.00

Par exemple, le code ci-dessous :

# le résultat est arrondi à 2 décimales :
nombre1 = 3.14159265
nombre2 = 2
print(f"Le résultat de {nombre1} x {nombre2} est : {nombre1 * nombre2:.2f}.")

affiche le résultat de la multiplication arrondi à deux décimales :

Le résultat de 3.14159265 x 2 est : 6.28.

📌 Le format change l'affichage, pas la valeur

Ces options modifient seulement la façon dont le nombre est affiché.
La variable, elle, garde sa valeur et son type d'origine (un float reste un float).

---

🔤 Formatage des chaînes de caractères

Il est possible de forcer une chaîne de caractères à occuper un certain nombre de positions et de contrôler son alignement. Ceci est particulièrement utile lorsque l’alignement vertical entre plusieurs lignes affichées dans la console doit être respecté (par exemple, lors de l’affichage d’un tableau en console).

Voici différentes options permettant de contrôler l'alignement :

Syntaxe	Effet	Exemple
:<10	Aligné à gauche sur 10 caractères	Mots → Mots
:>10	Aligné à droite sur 10 caractères	Mots →       Mots
:^10	Centré sur 10 caractères	Mots →    Mots

Par exemple, le code ci-dessous :

prenom1 = "John"
prenom2 = "Dessendre"
nom1 = "Doe"
nom2 = "Renoir"

print(f"{'Nom':<10} {'Prénom':<10}") # Affiche la str "Nom" et "Prénom" sur 10 caractères chacun
print(f"{nom1:<10} {prenom1:<10}")   # Affiche le contenu des variables nom1 et prenom1 sur 10 caractères chacun
print(f"{nom2:<10} {prenom2:<10}")   # Affiche le contenu des variables nom2 et prenom2 sur 10 caractères chacun

affiche les noms et les prénoms sur 10 caractères chacun, alignés à gauche, séparés d'une espace :

Nom        Prénom
Doe        John
Renoir     Dessendre

👉 C'est cette technique d'alignement qui vous permettra d'afficher des données bien lisibles dans la console, en alignant proprement les valeurs les unes sous les autres.

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Modules et bibliothèques

Les modules en Python

Python contient de nombreuses fonctions prêtes à l’emploi pour effectuer des calculs, manipuler des fichiers, gérer du texte, produire des nombres aléatoires, etc.
Cependant, elles ne sont pas toutes chargées automatiquement au démarrage. Pourquoi? Pour garder Python plus léger et éviter de charger inutilement des outils dont on n’a pas besoin.

👉 Ces fonctions sont regroupées dans des fichiers Python (.py) appelés modules.
👉 Un module, c’est donc un fichier qui contient des fonctions organisées autour d’un thème.

Pour utiliser les fonctions d’un module, il existe deux approches principales :

MÉTHODE #1

Importer le module complet

# Importer le module "math"
import math

print(math.sqrt(16)) # Résultat : 4.0
print(math.cos(5))   # Résultat : 0.28366218546322625

C’est la méthode la plus courante.
On accède aux fonctions du module avec la syntaxe :

nom_du_module.nom_de_la_fonction()

Par exemple :

math.sqrt(16)

MÉTHODE #2

Importer une fonction spécifique

# Importer juste les fonctions "sqrt" et "cos"
from math import sqrt, cos

print(sqrt(16)) # Résultat : 4.0
print(cos(5))   # Résultat : 0.28366218546322625

Cette méthode est utile lorsqu’on utilise seulement quelques fonctions précises d’un module.

L’avantage est qu’on n’a pas besoin de répéter le nom du module devant chaque fonction.

👉 En général, on écrit les import et les from au début du fichier Python.
Pourquoi? Quand quelqu’un ouvre le fichier, il peut voir immédiatement quels modules le programme utilise.

---

Les alias

On peut donner un surnom à un module ou à une fonction avec le mot-clé as.
C’est très courant en Python, surtout pour les modules dont le nom est long.

# Donner un alias à un module
import random as rd

print(rd.randint(1, 10))

# Donner un alias à une fonction spécifique
from time import sleep as pause

pause(2)  # Le programme s'arrête pendant 2 secondes

---

📚 Modules utiles en Python

Vous trouverez la documentation officielle des modules de base sur le site officiel de Python.
Il n'est pas nécessaire de la consulter pour l'instant : elle est très technique et peut être difficile à apprivoiser lorsqu'on débute la programmation.

• math → fonctions mathématiques avancées (racines, logarithmes, trigonométrie, etc.) - (documentation officielle)
• random → génération de nombres aléatoires, choix au hasard, tirages probabilistes - (doc)
• os → interaction avec le système d’exploitation (fichiers, dossiers, etc.) - (doc)
• sys → informations sur l’environnement du programme, gestion des entrées/sorties - (doc)
• time → manipulation du temps et des dates (mesurer le temps écoulé, conversions de format) - (doc)
• csv → lecture/écriture de fichiers CSV (format courant pour stocker des données tabulaires) - (doc)

---

🤖 Vulgariser des modules et des fonctions avec l’IA

Si bien utilisés, des outils d’intelligence artificielle (comme Copilot, ChatGPT, Claude, Gemini, etc.) peuvent vous aider à mieux comprendre le fonctionnement de modules et de fonctions Python.

Cela peut être particulièrement utile lorsque la documentation officielle vous semble complexe ou si vous avez des doutes sur l’utilisation d’une fonction.

Accédez à Copilot 🧠 à l’aide de ce lien et essayez le prompt suivant :

Agis comme un formateur expert en Python.
Je suis étudiant en science de la nature débutant l'apprentissage de la programmation.

Peux-tu me donner une liste des principales fonctions du module Python math ?
Pour chaque fonction, je souhaite :
    - Une explication simple (vulgarisée).
    - Un exemple de code court et commenté.

Répétez ce prompt pour explorer d’autres modules comme random et time.

---

Bibliothèques 📚

Parfois, plusieurs modules sont regroupés ensemble pour former un tout réutilisable et partageable facilement.
Nous appelons ce regroupement une bibliothèque.

⚡ Points clés :

• Chaque module d’une bibliothèque peut contenir des fonctions, classes ou constantes spécifiques.
• Pour utiliser une bibliothèque externe, il faut d'abord l'installer avec la ligne de commande pip install nom_de_la_bibliothèque.
• Une fois installée, on peut importer ses modules comme pour un module Python classique :

import numpy # Importer la bibliothèque "numpy"
print(numpy.array([1, 2, 3]))

Voici quelques bibliothèques populaires en Python :

• numpy → calculs numériques avancés, manipulation de tableaux multidimensionnels - (documentation officielle)
• pandas → manipulation et analyse de données tabulaires (DataFrames) - (doc)
• matplotlib → création de graphiques et visualisation de données - (doc)
• scikit-learn → apprentissage automatique (machine learning), modèles prédictifs - (doc)
• keras → création et entraînement de réseaux de neurones pour l'apprentissage profond (deep learning) - (doc)

---

Alias de bibliothèque

On peut donner un alias à une bibliothèque lors de son importation pour simplifier son utilisation.
Par exemple, on peut importer la bibliothèque numpy avec l'alias np pour faciliter son utilisation dans le code et éviter d'écrire numpy au long.

Il suffit d'utiliser le mot-clé as lors de l'importation :

import numpy as np          # Importer la bibliothèque "numpy" avec l'alias "np"
print(np.array([1, 2, 3]))  # Utiliser l'alias "np" (au lieu d'écrire numpy) pour accéder à la fonction "array()"

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Liste (list)

Introduction aux listes

Jusqu'ici nous avons vu 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

Python propose aussi des types de données plus complexes, comme les listes. Une liste permet de stocker plusieurs valeurs dans une seule variable, dans un ordre précis.

Les listes sont définies par des crochets [], avec les éléments séparés par des virgules :

heros = ["Mario", "Link", "Kirby", "Sonic"]
annees_creation = [1981, 1986, 1992, 1991]

Les éléments d'une liste peuvent être de n'importe quel type (str, int, float, bool).

Une liste peut même contenir des éléments de types différents :

melange = ["Alice", 42, 3.14, True]

---

Accéder aux éléments d'une liste

Chaque élément d'une liste est associé à un index (sa position), qui commence à 0.

heros  → ["Mario", "Link", "Kirby", "Sonic"]
index  →     0        1       2        3

On accède à un élément en écrivant le nom de la liste suivi de l'index entre crochets :

print(heros[0])   # Affiche "Mario"
print(heros[2])   # Affiche "Kirby"

Les index négatifs permettent de compter à partir de la fin :

heros          → ["Mario", "Link", "Kirby", "Sonic"]
index          →     0        1       2        3
index négatif  →    -4       -3      -2       -1

print(heros[-1])  # Affiche "Sonic" (dernier élément)
print(heros[-2])  # Affiche "Kirby" (avant-dernier)

La notation de tranche (slicing) permet d'extraire une sous-liste.
On indique l'index de départ (inclus) et l'index de fin (exclus). Le dernier élément retourné est donc celui juste avant cet index :

print(heros[1:3])  # Affiche ["Link", "Kirby"] (index 1 et 2, pas 3)
print(heros[:2])   # Affiche ["Mario", "Link"] (depuis le début)
print(heros[2:])   # Affiche ["Kirby", "Sonic"] (jusqu'à la fin)

IndexError : index hors limites

Si on essaie d'accéder à un index qui n'existe pas, Python génère une erreur IndexError :

heros = ["Mario", "Link", "Kirby", "Sonic"]
print(heros[4])  # IndexError: list index out of range

La liste heros contient 4 éléments, donc les index valides sont 0, 1, 2 et 3 (ou -4, -3, -2, -1).
Pour éviter cette erreur, on peut vérifier la longueur avec len() avant d'accéder à un index.

---

Modifier les éléments d'une liste

On peut modifier un élément en utilisant son index :

annees_creation[2] = 1992
print(annees_creation)  # Affiche [1981, 1986, 1992, 1991]

---

Ajouter des éléments

La méthode append() ajoute un élément à la fin de la liste :

heros.append("Pikachu")
print(heros)  # Affiche ["Mario", "Link", "Kirby", "Sonic", "Pikachu"]

append() est particulièrement utile pour construire une liste progressivement à partir d'une liste vide :

ma_liste = []
ma_liste.append("Mario")
ma_liste.append("Link")
ma_liste.append("Kirby")
print(ma_liste)  # Affiche ["Mario", "Link", "Kirby"]

---

Qu'est-ce qu'une méthode?

Plusieurs opérations sur les listes utilisent des méthodes. Une méthode est une fonction rattachée à un type de données en particulier. On l'appelle en faisant suivre le nom de la variable d'un point et du nom de la méthode :

maVariable.maMethode()
maVariable.maMethode(parametre1)

Les méthodes disponibles varient selon le type de la variable. Par exemple, voici des méthodes propres aux chaînes de caractères :

texte = "python est génial   "
print(texte.upper())                        # "PYTHON EST GÉNIAL   "   │ MAJUSCULES
print(texte.capitalize())                   # "Python est génial   "   │ Première lettre en majuscule
print(texte.strip())                        # "python est génial"      │ Supprime les espaces au début et à la fin
print(texte.strip().upper())                # "PYTHON EST GÉNIAL"      │ On peut enchaîner les méthodes
print(texte.replace("génial", "adorable"))  # "python est adorable   " │ Remplace un mot par un autre

---

Supprimer des éléments

La méthode remove() supprime la première occurrence d'une valeur :

heros.remove("Samus")
print(heros)  # Affiche ["Mario", "Link", "Kirby", "Sonic", "Pikachu"]

La méthode pop() supprime et retourne l'élément à une position donnée. Sans argument, elle supprime le dernier élément. On peut aussi lui passer un index :

heros = ["Mario", "Link", "Kirby", "Sonic", "Pikachu"]

dernier = heros.pop()     # Supprime le dernier
print(dernier)            # Affiche "Pikachu"
print(heros)              # Affiche ["Mario", "Link", "Kirby", "Sonic"]

premier = heros.pop(0)    # Supprime l'élément à l'index 0
print(premier)            # Affiche "Mario"
print(heros)              # Affiche ["Link", "Kirby", "Sonic"]

---

Longueur d'une liste

La fonction len() retourne le nombre d'éléments dans une liste :

heros = ["Mario", "Link", "Kirby", "Sonic"]
annees_creation = [1981, 1986, 1992, 1991]

print(len(heros))            # Affiche 4
print(len(annees_creation))  # Affiche 4

---

Vérification de présence

L'opérateur in permet de vérifier si une valeur est présente dans une liste. Il retourne True ou False :

mario_present = "Mario" in heros
print(mario_present)  # Affiche True

---

Tri d'une liste

La fonction sorted() retourne une nouvelle liste triée sans modifier l'originale :

annees_creation = [1981, 1986, 1992, 1991]

annees_triees = sorted(annees_creation)
print(annees_triees)    # Affiche [1981, 1986, 1991, 1992]
print(annees_creation)  # Affiche [1981, 1986, 1992, 1991] (originale non modifiée)

La méthode sort() trie la liste en place (modifie la liste directement) :

annees_creation.sort()
print(annees_creation)  # Affiche [1981, 1986, 1991, 1992]

Pour trier en ordre décroissant, on ajoute le paramètre reverse=True :

heros = ["Mario", "Link", "Kirby", "Sonic"]
heros.sort(reverse=True)
print(heros)  # Affiche ["Sonic", "Mario", "Link", "Kirby"]

Si les éléments de la liste sont des chaînes de caractères, le tri se fait par ordre alphabétique (en respectant la casse : les majuscules sont triées avant les minuscules).

---

Concaténation de listes

On peut combiner deux listes avec l'opérateur + :

nintendo = ["Mario", "Link"]
sega = ["Sonic", "Knuckles"]
tous = nintendo + sega
print(tous)  # Affiche ["Mario", "Link", "Sonic", "Knuckles"]

---

Copie de liste

Attention : assigner une liste à une nouvelle variable ne crée pas une copie, mais une deuxième référence vers la même liste. Modifier l'une modifie l'autre :

liste_a = [1, 2, 3]
liste_b = liste_a
liste_b.append(4)
print(liste_a)  # Affiche [1, 2, 3, 4]  (liste_a est aussi modifiée!)

Pour faire une vraie copie indépendante, on peut utiliser la méthode copy() :

liste_a = [1, 2, 3]
liste_b = liste_a.copy()
liste_b.append(4)
print(liste_a)  # Affiche [1, 2, 3]
print(liste_b)  # Affiche [1, 2, 3, 4]

---

Fonctions utiles sur les listes de nombres

Python offre des fonctions intégrées pratiques pour analyser rapidement une liste de nombres :

• max(liste) : retourne la valeur la plus grande
• min(liste) : retourne la valeur la plus petite
• sum(liste) : retourne la somme de tous les éléments

annees_creation = [1981, 1986, 1992, 1991]

print(max(annees_creation))  # Affiche 1992
print(min(annees_creation))  # Affiche 1981
print(sum(annees_creation))  # Affiche 7950

On peut aussi combiner sum() et len() pour calculer une moyenne :

moyenne = sum(annees_creation) / len(annees_creation)
print(moyenne)  # Affiche 1987.5

Ces fonctions ne fonctionnent qu'avec des nombres

Si la liste contient des chaînes de caractères ou des types mixtes, Python lèvera une erreur :

heros = ["Mario", "Link", "Kirby", "Sonic"]
print(sum(heros))  # TypeError: unsupported operand type(s) for +: 'int' and 'str'

---

Répétition d'une liste

L'opérateur * permet de répéter les éléments d'une liste plusieurs fois :

zeros = [0] * 5
print(zeros)  # Affiche [0, 0, 0, 0, 0]

---

Listes de listes

On a dit qu'une liste peut contenir des éléments de n'importe quel type (int, float, str, bool, etc.).
Donc, elle peut même contenir... d'autres listes!
Et cela est très utile pour représenter des données en tableau, comme un horaire ou une grille.

Par exemple, on peut représenter un tableau de héros avec une liste de héros, où chaque héros est lui-même une liste contenant son nom, son année de création et sa plateforme de première apparition. Chaque ligne du tableau est donc une liste, et l'ensemble du tableau est une liste de listes :

heros = [
    ["Mario", 1981, "Arcade"],
    ["Link", 1986, "NES"],
    ["Kirby", 1992, "Game Boy"],
]

Pour accéder à un élément, on utilise deux index : le premier pour choisir la ligne, le second pour choisir la colonne :

print(heros[0])     # Affiche ["Mario", 1981, "Arcade"]
print(heros[0][0])  # Affiche "Mario"
print(heros[1][1])  # Affiche 1986
print(heros[2][2])  # Affiche "Game Boy"

heros[0]    → ["Mario", 1981, "Arcade"]
heros[0][0] → "Mario"
heros[0][1] → 1981
heros[0][2] → "Arcade"

---

AIDE-MÉMOIRE : listes

Liste ordonnée et modifiable, définie avec des crochets [].

Opération	Syntaxe	Description
Créer	heros = ["Mario", "Link"]	Nouvelle liste
Accéder	element = heros[0]	Élément à l'index 0
Modifier	heros[0] = "Samus"	Remplacer un élément
Longueur	nb_elements = len(heros)	Nombre d'éléments
Présence	est_present = "Mario" in heros	Retourne True ou False
Ajouter (fin)	heros.append("Pikachu")	Ajoute à la fin
Insérer	heros.insert(1, "Samus")	Insère à l'index 1
Supprimer (valeur)	heros.remove("Samus")	Supprime la 1re occurrence
Supprimer (dernier)	element_retire = heros.pop()	Supprime et retourne le dernier élément
Supprimer (index)	element_retire = heros.pop(0)	Supprime et retourne l'élément à l'index 0
Trier (nouvelle liste)	liste_triee = sorted(heros)	Retourne une copie triée
Trier (en place)	heros.sort()	Modifie la liste directement
Combiner	liste_combinee = liste1 + liste2	Concatène deux listes
Copier	liste_copie = heros.copy()	Copie indépendante
Maximum	valeur_max = max(heros)	Plus grande valeur (nombres seulement)
Minimum	valeur_min = min(heros)	Plus petite valeur (nombres seulement)
Somme	total = sum(heros)	Somme de tous les éléments (nombres seulement)

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Précision des flottants

⚠️ Les nombres flottants ne sont pas toujours exacts

Essayez ce code dans un script Python :

resultat = 0.1 + 0.2
print(resultat)

Vous obtiendrez :

0.30000000000000004

Surprenant? Pourtant, Python n'a pas fait d'erreur.
C'est le comportement normal et attendu de tous les langages qui utilisent les nombres flottants selon la norme internationale IEEE 754.

---

🔬 Pourquoi ça arrive?

Les ordinateurs stockent les données en binaire (des 0 et des 1). Or, certaines fractions décimales simples, comme 0.1, ne peuvent pas être représentées exactement en binaire, tout comme 1/3 ne peut pas être écrit exactement en décimal (0.333333...).

Quand Python écrit 0.1 en mémoire, il stocke en réalité quelque chose comme :

0.1000000000000000055511151231257827021181583404541015625

pourquoi?

C'est parce que 0.1 est une fraction décimale qui ne peut pas être représentée exactement en binaire.
En binaire, 0.1 est une fraction périodique infinie, et l'ordinateur doit faire un compromis en stockant une approximation très proche de 0.1, mais pas exactement égale :

0.1 (décimal) = 0.0001100110011001100110011001100110011001100110011001101... (binaire)

C'est infiniment proche de 0.1, mais pas exactement égal. Et quand on additionne plusieurs de ces approximations, l'erreur s'accumule et peut devenir visible.

Analogie

Imaginez que vous devez mesurer 1 litre d'eau, mais votre seul outil est une cuillère à thé de 5 ml légèrement imprécise (5,002 ml). Chaque mesure introduit une toute petite erreur. Au bout de 200 cuillères, l'erreur accumulée devient perceptible. C'est exactement ce qui se passe avec les flottants!

---

💥 Impacts concrets

Ce problème peut causer des bugs subtils et difficiles à détecter.

Comparaison de flottants : ne jamais comparer des flottants avec == !

a = 0.1 + 0.2
b = 0.3

print(a)        # Affiche 0.30000000000000004
print(b)        # Affiche 0.3
print(a == b)   # Affiche False  ← les deux valeurs semblent identiques, pourtant!

👉 L'opérateur == vérifie si deux valeurs sont exactement identiques et retourne True (vrai) ou False (faux). Il sera étudié à la rencontre 4.

Accumulation d'erreurs dans un calcul répété :

# Additionner 0.1 dix fois devrait donner 1.0... mais :
total = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
print(total)        # Affiche 0.9999999999999999 au lieu de 1.0
print(total == 1.0) # Affiche False

Résultats inattendus dans des conditions financières ou scientifiques :

prix = 1.15
taxe = 0.05
total = prix + taxe
print(total)        # Affiche 1.1999999999999998 au lieu de 1.2

---

🛠️ Comment y remédier

Il existe plusieurs stratégies selon le contexte.

---

✅ Stratégie 1 : Arrondir l'affichage avec les f-strings

Si le problème est uniquement visuel, on peut simplement contrôler le nombre de décimales affichées :

resultat = 0.1 + 0.2
print(f"Résultat : {resultat:.2f}")  # Affiche : Résultat : 0.30

C'est la solution la plus simple et suffisante dans la grande majorité des cas de ce cours.

---

✅ Stratégie 2 : Arrondir avec round()

La fonction round() permet de limiter la précision d'un nombre flottant :

resultat = round(0.1 + 0.2, 2)
print(resultat)  # Affiche : 0.3

Attention

round() réduit l'erreur visible, mais n'élimine pas complètement les approximations internes.
Pour des comparaisons fiables, préférez la stratégie 3.

---

✅ Stratégie 3 : Comparer avec une tolérance

Pour vérifier si deux flottants sont "pratiquement égaux", on compare leur différence à un seuil très petit :

a = 0.1 + 0.2
b = 0.3
tolerance = 1e-9              # 0.000000001

difference = abs(a - b)
print(difference)             # Affiche 5.551115123125783e-17  (quasi zéro)
print(difference < tolerance) # Affiche True  ← la différence est négligeable

👉 L'opérateur < vérifie si la valeur de gauche est plus petite que celle de droite. Il sera étudié à la rencontre 4.

---

✅ Stratégie 4 : Utiliser le module decimal

Quand la précision absolue est critique, Python offre le module decimal qui effectue les calculs en base 10, comme le ferait un humain :

from decimal import Decimal

a = Decimal("0.1")
b = Decimal("0.2")
print(a + b)        # Affiche exactement : 0.3

remarque

Notez que les valeurs sont passées comme des chaînes de caractères ("0.1" et non 0.1).
Si on passait 0.1 directement, Python convertirait d'abord le flottant imprécis, et le problème reviendrait.

attention

Alors, pourquoi ne pas utiliser decimal systématiquement?
👉 Parce que c'est beaucoup plus lent et plus complexe à manipuler que les flottants classiques.
Sur des quantités massives de données, cela peut ralentir considérablement les calculs.

---

💡 À retenir pour ce cours

Dans ce cours d'introduction, les deux réflexes essentiels sont :

• Afficher des flottants → utiliser :.2f (ou un autre nombre de décimales) dans une f-string pour contrôler la présentation.
• Comparer des flottants → éviter == ou round() et préférer une tolérance.

Le module decimal est réservé aux situations où la précision absolue est indispensable (ex. calculs scientifiques précis, logiciels bancaires).
Pour la majorité des calculs pédagogiques, arrondir l'affichage est tout à fait suffisant.

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair

Activités

Le modèle de la classe inversée : maximiser votre apprentissage!

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

🧠 Auto-validation des connaissances

Ce formulaire sert à vérifier votre compréhension des éléments les plus importants de la rencontre R02. 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.

attention

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 compréhension

Exercice - Trace simple

🖨 Pour réaliser cet exercice, imprimez le tableau de trace d'exécution.

En situation d'examen, vous devrez compléter une trace d'exécution sur papier sans utiliser d'ordinateur.

Sans exécuter le code, déterminez ce que le programme ci-dessous va afficher dans la console.
En suivant la recette simplifiée, complétez le tableau de trace d'exécution ligne par ligne.
La feuille de trace contient plus de colonnes que la recette simplifiée : laissez vides celles qui ne sont pas dans la recette.

import math

a = 16
b = math.sqrt(a)
a = a + 4
c = (a / b) ** 2
print(c)
a = 4
print(c)
b = b * 2
print(f"{a} {b} {c}")

Validez ensuite votre trace en exécutant le programme en mode débogage.
Avancez pas à pas et observez l'évolution de chaque variable à chaque ligne.

Notions visées

Variables, réaffectation, module math (racine carrée), opérateurs arithmétiques (/, **), f-strings, trace d'exécution

---

🎯 Solutionnaire

attention

Consultez le solutionnaire uniquement après avoir complété l'exercice par vous-même.
Comparer votre réponse avec une solution vous permet de valider votre raisonnement et de corriger vos erreurs.
Consulter la solution avant d'avoir tenté l'exercice prive votre cerveau de l'occasion de construire des connexions durables.

• Trace simple — solutionnaire.pdf

🏫 Activités à faire en classe

🔨 Exercices de création

Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.

Documentation autorisée

Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.

Exercice - Free style

📁 Créez un fichier r02_free_style.py pour votre réponse.

Dans un fichier, écrivez une dizaine de lignes de commandes Python.
Vous pouvez inclure :

• des déclarations de variables
• des calculs avec affectation des résultats dans des variables
• des affichages avec print()

Exécutez votre code en mode débogage pour vous familiariser avec le débogueur.
👉 Ce sera l'outil le plus utile de votre vie pour programmer!

Notions visées

Variables, calculs et affectation, exécution en mode débogage (débogueur)

---

Exercice - QUESTION DE GRAVITÉ

📁 Créez un fichier r02_question_de_gravite.py pour votre réponse.

La gravité sur Mars est d’environ 3,71 m/s².
Écrivez un programme pour convertir une masse (en kilogrammes) en son poids correspondant sur Mars, en newtons (N).

Le début de votre programme est le suivant :

masse = 50

Vous devez écrire le reste du programme.
Le programme doit afficher le bon poids peu importe le contenu de la variable.

💡 Formule : $\text{poids}=\text{masse}\times\text{gravité}$

✅ Sortie attendue

Masse sur Terre (kg) : 50
Le poids sur Mars est de 185.5 N.

Notions visées

Variables, opérateurs arithmétiques

---

Exercice - MOYENNE PRESSION SYSTOLIQUE

📁 Créez un fichier r02_pression_systolique.py pour votre réponse.

Créez un programme calculant la moyenne de la pression systolique d'un patient.

🛠️ INSTRUCTIONS

1. Déclarez une liste mesures contenant les 3 valeurs de pression systolique (matin, midi, soir) :

   mesures = [125, 130, 180]

2. Affichez chaque mesure en accédant aux éléments de la liste par leur index (mesures[0], mesures[1], mesures[2]).
3. Calculez la moyenne à l'aide des fonctions sum() et len() appliquées directement sur la liste.
4. Affichez le résultat de façon claire et lisible.

Validez le bon fonctionnement de votre programme en modifiant les valeurs dans la liste.

💡 Pourquoi une liste?

Les trois mesures sont des données du même type (des pressions) collectées de façon répétée. Une liste les regroupe naturellement. De plus, utiliser sum() et len() rend votre calcul généralisant : il fonctionnerait sans modification avec 4, 5 ou 10 mesures dans la liste.

✅ Sortie attendue

Pression systolique

Mesure du matin : 125
Mesure du midi : 130
Mesure du soir : 180

Moyenne de la pression systolique : 145.0 mmHg

Notions visées

Listes, accès par index, sum(), len()

---

Exercice - GÉNÉRER UN NOMBRE ALÉATOIRE

📁 Créez un fichier r02_nombre_aleatoire.py pour votre réponse.

Vous devez générer un nombre entier aléatoire compris entre 2 variables :

valeur_min = 50
valeur_max = 100

✅ Sortie attendue

Nombre le plus bas : 50
Nombre le plus haut : 100

Nombre aléatoire généré : 56

Le module random sera nécessaire :

• Approche courageuse : Vous pouvez lire la (documentation) du module pour trouver la fonction et des exemples.
• Approche plus simple : Vous pouvez demander à ChatGPT ou un autre outil d'IA quelle fonction utiliser pour générer un nombre compris entre deux bornes inclusives, et de vous expliquer son fonctionnement.

🧠 Exemple de prompt :

Quelle est la fonction du module random en Python qui permet de générer
un nombre entier aléatoire compris entre deux valeurs données (inclusivement) ?
Peux-tu m’expliquer comment elle fonctionne et me donner un exemple d’utilisation ?

Notions visées

Variables, module random (nombre entier aléatoire entre deux bornes), lecture de documentation

---

Exercice - REMPLIR UNE LISTE ALÉATOIREMENT

📁 Créez un fichier r02_liste_aleatoire.py pour votre réponse.

Créez un programme qui part d’une liste vide et lui ajoute 5 nombres entiers aléatoires compris entre 0 et 100.

🛠️INSTRUCTIONS

1. Déclarez une liste vide :

   nombres = []

2. Ajoutez 5 nombres aléatoires (entre 0 et 100 inclusivement) à la liste, un à la fois, en utilisant la méthode .append().
3. Affichez la liste dans la console.

Le module random sera nécessaire. Si vous ne savez pas quelle fonction utiliser, référez-vous à l’exercice précédent ou consultez la documentation.

💡 Pour les curieux

Vous remarquerez que les 5 appels à .append() sont presque identiques. C’est précisément ce genre de répétition qu’une boucle for élimine : en quelques lignes, elle exécuterait automatiquement l’ajout autant de fois que souhaité que ce soit 5 ou 500 nombres. Vous verrez ça bientôt!

✅ Sortie attendue

Liste de nombres aléatoires : [42, 7, 91, 55, 23]

(Les valeurs seront différentes à chaque exécution.)

Notions visées

Listes, liste vide, .append(), module random, accès à la documentation

---

Exercice - CALCUL DE LA DISTANCE ENTRE 2 POINTS

📁 Créez un fichier r02_distance_2_points.py pour votre réponse.

Créez un programme calculant et affichant la distance entre les 2 points, arrondie à 2 décimales.
La formule de la distance entre 2 points $A(x_1, y_1)$ et $B(x_2, y_2)$ est :

$$d = \sqrt{(x_2 - x_1) ^ 2 + (y_2 - y_1) ^ 2}$$

Représentez les deux points dans une seule liste points contenant deux sous-listes :

points = [
    [50, 70],   # point A : [x1, y1]
    [80, 60],   # point B : [x2, y2]
]

Accédez aux coordonnées via les index : points[1][0] pour $x_2$.
Pour réaliser la racine carrée de la formule, vous aurez besoin d'une fonction du module math.

💡 Pourquoi une liste de listes?

Chaque point est lui-même une liste [x, y], et points regroupe tous les points du problème. Cette structure, appelée liste de listes (ou liste imbriquée), reflète naturellement la réalité : un ensemble de points, chacun défini par ses coordonnées. points[0] est le point A, points[1] est le point B.

✅ Sortie attendue

Point A
X1 : 50
Y1 : 70

Point B
X2 : 80
Y2 : 60

Distance : 31.62

Notions visées

Listes imbriquées (liste de listes), accès par double index, module math (racine carrée), opérateurs arithmétiques (**), round()

---

Exercice – CONSTRUIRE UN NOMBRE DÉCIMAL

📁 Créez un fichier r02_nombre_decimal.py pour votre réponse.

En utilisant les 2 variables suivantes :

chiffre = 5             # Choisissez un chiffre entre 1 et 9
position_decimale = 3   # Choisissez une position décimale (un entier positif)

Écrivez un programme qui génère un nombre décimal dont le chiffre est à la position décimale indiquée.

Par exemple :

• Si le chiffre est 5 et la position décimale est 3, le résultat doit être 0.005.
• Si le chiffre est 2 et la position décimale est 1, le résultat doit être 0.2.

Indice : les puissances de 10 peuvent vous aider.

✅ Sortie attendue

chiffre : 5
position décimale : 3

Le nombre généré est : 0.005

Notions visées

Variables, puissances de 10 (**), opérateurs arithmétiques, types numériques

---

Exercice - DÉCOMPOSER UN MONTANT EN BILLETS

📁 Créez un fichier r02_montant_billets.py pour votre réponse.

Écrivez un programme permettant de décomposer un montant en billets de 100, 50, 20, 10 et 5$.
Le programme doit privilégier les billets de plus grandes valeurs.

Voici un exemple d'exécution :

Montant : 376.54
Billets :
3 x 100$
1 x 50$
1 x 20$
0 x 10$
1 x 5$
Reste 1.54$

💡 D'abord, trouvez l'algorithme (sans ordinateur)

Avant d'écrire une seule ligne, jouez le rôle du caissier qui doit remettre 376.54$ en utilisant le moins de billets possible. Sur papier, remplissez ce tableau à la main :

Coupure	Combien de billets?	Montant restant après
100$	3	76.54
50$	?	?
20$	?	?
10$	?	?
5$	?	?

La première ligne est remplie en exemple : 376.54 − (3 × 100) = 76.54.

👉 Deux constats à faire avant de coder :

• Chaque coupure travaille toujours sur le montant qu'a laissé la précédente : la variable « montant restant » est le cœur de l'algorithme.
• Vous refaites exactement les deux mêmes gestes pour chaque coupure : (1) combien de billets entiers? (2) qu'est-ce qui reste ensuite?

Indices :

• Le début de votre programme est le suivant, déclarez les coupures disponibles dans une liste :

  montant_initial = 376.54
  billets = [100, 50, 20, 10, 5]  # coupures disponibles, du plus grand au plus petit

• Traitez les coupures une à la fois, en commençant par billets[0].
• Accédez à chaque valeur de coupure via son index : billets[0] pour 100$, billets[1] pour 50$, etc.
• Créez autant de variables que vous le croyez nécessaire (ex : montant_restant, nb_billets_requis, etc.)
• Les deux gestes à répéter pour chaque coupure se traduisent ainsi :
  • Combien de billets entiers? → la division entière (//)
    • 376 // 100 $\longrightarrow$ 3
    • 95 // 100 $\longrightarrow$ 0
  • Qu'est-ce qui reste? → soustrayez du montant restant la valeur des billets donnés : restant = restant - nb * coupure.
    (Le modulo restant % coupure donne directement ce même reste, si vous préférez.)

💡 Pourquoi une liste?

Les valeurs de coupures forment une série naturellement ordonnée. Les stocker dans une liste rend l'intention du code plus claire. Vous verrez lors d'un prochain cours qu'une boucle for permettrait de traiter automatiquement toutes les coupures, peu importe leur nombre, en quelques lignes seulement.

Notions visées

Listes, accès par index, division entière (//) et modulo, opérateurs arithmétiques, variables intermédiaires

---

Exercice - CALCUL DE LA NOTE FINALE DU COURS

📁 Créez un fichier r02_note_finale.py pour votre réponse.

Créez un programme qui calcule la note finale obtenue par un étudiant dans ce cours.
La règle de la double sanction n'est pas à appliquer dans cet exercice, car les notions nécessaires n'ont pas encore été vues.

🛠️ INSTRUCTIONS

1. Déclarez une variable pour le nom de l'étudiant et quatre listes parallèles :

   nom_etudiant = "Nicola Tesla"
   evaluations  = ["TP1",  "TP2",  "Examen 1", "Examen 2", "Contrôles"]
   notes        = [8,      9,      90,         95,         9          ]
   sur          = [10,     10,     100,        100,        10         ]
   ponderations = [0.15,   0.25,   0.20,       0.30,       0.10       ]

💡 Comment lire des listes parallèles

« Parallèles » veut dire que le même index pointe vers une seule et même évaluation dans les quatre listes. Lisez-les comme un tableau, colonne par colonne :

index i	evaluations[i]	notes[i]	sur[i]	ponderations[i]
0	"TP1"	8	10	0.15
1	"TP2"	9	10	0.25
2	"Examen 1"	90	100	0.20
3	"Examen 2"	95	100	0.30
4	"Contrôles"	9	10	0.10

👉 Pour « tout savoir sur le TP1 », on lit la même position dans les quatre listes.

Garder les listes synchronisées

Si vous ajoutez une évaluation, ajoutez-la dans les quatre listes, à la même position. Un décalage fausse tout le calcul.

2. Calculez la note finale en additionnant la contribution de chaque évaluation (voir l'encadré ci-dessous), à partir des éléments des listes accédés par leur index.

La note finale est une somme de contributions : chaque évaluation rapporte un certain nombre de points à la note sur 100.

$$\text{note\_finale} = \sum \left( \frac{\text{note}}{\text{sur}} \times 100 \times \text{pondération} \right)$$

Décortiquons la formule sur le TP1 (note de 8 sur 10, qui vaut 15 % de la session) :

Étape	Calcul	Résultat	Ce que ça veut dire
1. Fraction réussie	8 / 10	0.8	l'étudiant a réussi 80 % du TP
2. Note sur 100	0.8 * 100	80	sa note ramenée sur 100
3. Pondérée	80 * 0.15	12.0	ce que le TP rapporte à la session

Le TP1 contribue donc pour 12 points.
On refait ces trois mêmes étapes pour chaque évaluation,
puis on additionne toutes les contributions dans une variable de cumul (par exemple note_finale, qui démarre à 0).

3. Affichez un résumé clair des notes de chaque évaluation et de la note finale, arrondie à 2 décimales.

Vous pouvez créer d'autres variables si vous le jugez nécessaire (par exemple une variable contribution recalculée pour chaque évaluation).

✅ Sortie attendue

Étudiant : Nicola Tesla

TP1         (15%) : 8/10
TP2         (25%) : 9/10
Examen 1    (20%) : 90/100
Examen 2    (30%) : 95/100
Contrôles   (10%) : 9/10

Note obtenue pour ce cours : 90.00/100
Attention, l'application de la double sanction n'a pas été réalisée!

Notions visées

Listes parallèles, accès par index, opérateurs arithmétiques, accumulation dans une variable, round(), f-strings

---

✏️ Exercices sur papier

Documentation interdite et sans PyCharm

Faites ces exercices d'abord sur papier (ou dans un éditeur de texte simple) et sans aucune documentation, comme à l'examen.
Vous pouvez valider votre réponse dans PyCharm à la fin — un luxe que vous n'aurez pas le jour de l'examen, d'où l'importance de vous entraîner sans lui.

Exercice - Vitesse d'impact

Écrivez (sur papier) un programme qui calcule la vitesse d’impact ($v$) d’un objet en chute libre à partir d’une hauteur ($h$) donnée en mètres.

(On néglige la résistance de l’air et on suppose que l’objet est lâché sans vitesse initiale.)

Formule :

$$v = \sqrt{2 \cdot g \cdot h}$$

Note : utilisez $g = 9.81$ pour la constante de gravité.

Contraintes techniques :

• Déclarez une variable pour la hauteur.
• Importez le module nécessaire pour les calculs mathématiques.
• Arrondissez le résultat à 2 décimales.
• Affichez le résultat selon le format ci-dessous.

Exemple attendu (pour $h = 5$) :

Hauteur : 5
La vitesse d'impact est de 9.90 m/s

📁 Une fois votre code écrit sur papier, vous pouvez écrire votre poème dans un script r02_vitesse_impact.py et le rouler pour valider que votre code fonctionne correctement.

Notions visées

Variables, module math (racine carrée), opérateurs arithmétiques, round()

---

🎯 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ébogueur pour essayer par vous-même de trouver le problème.

attention

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 :

• Question de gravité
• Moyenne pression systolique
• Générer un nombre aléatoire
• Remplir une liste aléatoirement
• Calcul de la distance entre 2 points
• Construire un nombre décimal
• Calcul de la note finale du cours
• Décomposer un montant en billets

✏️ Solution des exercices de compréhension :

• Vitesse d'impact

*Matplotlib*

Onglet facultatif

Les onglets dont le titre est entouré d'étoiles (comme celui-ci) sont facultatifs : ils ne font pas partie de la matière évaluée de la rencontre et peuvent être lus à votre rythme ou même ignoré. Cela dit, cet onglet vaut la peine d'être lu! Vous allez produire des graphiques plus tard dans ce cours avec cette bibliothèque.

---

Générer des graphiques 📊

Nous allons utiliser Matplotlib, une bibliothèque Python très flexible pour la visualisation de données.
Elle permet de créer des graphiques simples ou complexes et de personnaliser pratiquement tous les éléments :

• Graphiques à lignes, à barres, histogrammes, nuages de points
• Superposition de plusieurs graphiques sur une seule figure
• Compatibilité avec d'autres bibliothèques scientifiques comme NumPy, Pandas ou SciPy

Il existe aussi d'autres excellentes bibliothèques de visualisation graphique, comme Seaborn ou ggplot2.

Voici un exemple simple, testez-le dans un script Python!
Ne vous inquiétez pas si vous ne comprenez le code pour l'instant, on verra plus en détail comment faire des graphiques dans un prochain cours.

Installer Matplotlib

Pour utiliser une bibliothèque Python comme Matplotlib, il faut d’abord l’installer dans votre environnement de travail.
Avant d’exécuter l’exemple ci-dessous, assurez-vous d’avoir suivi les étapes nécessaires pour installer la bibliothèque Matplotlib.

# Importer le module "pyplot" de la bibliothèque "matplotlib" et l'utiliser sous l'alias "plt"
import matplotlib.pyplot as plt

# Âge en années
# Liste de données pour l'axe horizontal (axe des abscisses), 11 éléments
age = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Taille correspondante en cm (exemple fictif)
# Liste de données pour l'axe vertical (axe des ordonnées), 11 éléments
taille = [50, 75, 85, 95, 105, 112, 118, 124, 130, 135, 140]

# Création du graphique

# Création d'une courbe (11 points)
plt.plot(age, taille, marker='o', color='g', label="Taille en fonction de l'âge")

# Ajout de titres et labels
plt.xlabel("Âge (années)")                    # Ajout d'un label sur l'axe horizontal
plt.ylabel("Taille (cm)")                     # Ajout d'un label sur l'axe vertical
plt.title("Courbe de croissance de l'enfant") # Ajout d'un titre au graphique
plt.grid(linestyle="--")                      # Ajout d'une grille en pointillé
plt.legend()                                  # Générer une légende

# Affichage du graphique
plt.show()

Les explications de cette section étaient-elles claires ?

1 = Pas du tout clair·5 = Très clair