đ Scripts et fonctions
- Script
- Débogueur
- Trace
- Fonctions
- f-strings
- Modules et bibliothĂšques
- Liste (list)
- Précision des flottants
- Activités
- *Matplotlib*
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.
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.
La console affiche :
bonjour bonjour cher maitre humain
Ca va aujourd'hui?
12.0
đ€ Que voyez-vous? Avant de lire l'explication, essayez de rĂ©pondre :
- Le script contient 11 lignes. Pourquoi la console n'affiche-t-elle que 3 lignes?
- Pourquoi rien ne s'affiche pour la ligne 4, alors que c'est un calcul?
Voir l'explication
L'interpréteur 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 calcul4 / 5 * (9 + 6), soit12.0. - 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.
đĄ Mode interactif ou script? En mode interactif (dans la console), taper 6 / 2 * (1 + 2) affiche automatiquement 9.0.
Dans un script, rien ne s'affiche sans print() : c'est pourquoi la ligne 4 n'affiche rien!
Ă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.
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-pushreste nécessaire.
Si le curseur devient un bloc ⟠et que chaque caractÚre tapé remplace celui qui suit au lieu de s'ajouter, vous avez appuyé par mégarde sur la touche Inser (au-dessus de Suppr). Le clavier est alors en mode refrappe.
- â
Appuyez une autre fois sur
Inserpour revenir au mode normal (le curseur redevient une barre mince). - â©ïž Utilisez
Ctrl + Zpour rĂ©cupĂ©rer les caractĂšres effacĂ©s. - đą La touche
0du pavĂ© numĂ©rique fait la mĂȘme chose quand Verr Num est dĂ©sactivĂ©.
đ Voir les dĂ©tails dans l'aide-mĂ©moire âšïž Symboles au clavier.
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 ?
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.
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 Development 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, dans le script Python créé Ă la section Script, mettez un point d'arrĂȘt sur la ligne 3, la premiĂšre instruction (les commentaires ne sont pas des instructions) :
# 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 Debug ).
- 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 continuez Ă 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 observez les variables qui sont créées et affichĂ©es dans la fenĂȘtre de dĂ©bogage, ainsi que leurs modifications. En particulier, notez le changement du contenu des variables x et y lorsqu'elles sont modifiĂ©es.
â±ïž La ligne surlignĂ©e n'est pas encore exĂ©cutĂ©e. Quand la ligne x = 6 est surlignĂ©e, la variable x n'existe pas encore : elle apparaĂźt dans la liste des variables seulement aprĂšs un Step Over.
Gardez ce dĂ©calage en tĂȘte quand vous comparez le dĂ©bogueur Ă votre trace!
đ„ïž OĂč voir l'affichage des print? En mode dĂ©bogage, PyCharm montre d'abord la liste des variables. Le texte affichĂ© par vos print se trouve dans l'onglet Console de la fenĂȘtre de dĂ©bogage.
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.
Vous pouvez exécuter les actions de débogage plus rapidement en utilisant des raccourcis clavier.
| Action | IcĂŽne | Windows | macOS |
|---|---|---|---|
| Lancer le débogage | Maj + F9 | Ctrl + D | |
| Step Over | F8 | F8 | |
| Resume | F9 | â„ Option + â Command + R | |
| Stop | Ctrl + F2 | â Command + F2 |
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.
đ Ă vous de jouer! Le programme suivant contient des erreurs de syntaxe. Chaque ligne fautive est signalĂ©e par un commentaire.
- Copiez ce code dans un script PyCharm et observez les soulignements rouges.
- Pour chaque ligne signalée, essayez de trouver l'erreur et de la corriger.
- Exécutez le script (avec ou sans le débogueur) aprÚs chaque correction.
nombre1 = 10
print("Le nombre1 est :", nombre1)
nombre2 20 # â Une erreur se cache sur cette ligne
print("Le nombre2 est :", nombre2 # â Une erreur se cache sur cette ligne
somme nombres = nombre1 + nombre2 # â Une erreur se cache sur cette ligne
print("La somme de nombre1 et nombre2 est :", somme nombres) # â Une erreur se cache sur cette ligne
Si vous exécutez le programme sans rien corriger, vous obtenez ce message :
File "...\mon_script.py", line 4
nombre2 20
^^
SyntaxError: invalid syntax
đ Remarquez que Python ne signale que la premiĂšre erreur (ligne 4), mĂȘme s'il y en a d'autres plus bas!
Il faut donc corriger, réexécuter, et recommencer jusqu'à ce que le programme fonctionne.
Voir les corrections
- Ligne 4 : le symbole d'assignation
=est manquant. - Ligne 5 : il manque une parenthĂšse fermante
). - Lignes 7 et 8 : le nom de la variable
somme nombresest invalide, car les espaces sont interdites : utilisez plutĂŽt des traits de soulignement (somme_nombres).
nombre1 = 10
print("Le nombre1 est :", nombre1)
nombre2 = 20
print("Le nombre2 est :", nombre2)
somme_nombres = nombre1 + nombre2
print("La somme de nombre1 et nombre2 est :", somme_nombres)
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 ?
La trace est un outil qui permet de suivre l'exécution d'un programme en notant 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.
Lisez la recette Produire une trace pour apprendre à rédiger une trace, et imprimez la feuille de 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 ligne 3, la premiĂšre ligne qui s'exĂ©cute (les lignes 1 et 2 sont des commentaires, que Python ignore).
- Lancez l'exécution en mode débogage.
- Avancez de ligne en ligne avec le bouton Step Over
(
F8) et comparez avec votre trace (valeurs des variables, instructions exécutées, affichage).
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 :
| portée globale | |||||
|---|---|---|---|---|---|
| #ligne | contexte | x | y | resultat | affichage |
| 3 | globale | bonjour bonjour cher maitre humain | |||
| 4 | globale | ||||
| 5 | globale | Ca va aujourd'hui? | |||
| 6 | globale | 12.0 | |||
| 7 | globale | 6 | |||
| 8 | globale | 6 | 7 | ||
| 9 | globale | 6 | 7 | 42 | |
| 10 | globale | 0 | 7 | 42 | |
| 11 | globale | 0 | 42 | 42 | |
- Pourquoi la trace commence-t-elle Ă la ligne 3? Les lignes 1 et 2 sont des commentaires : Python les ignore, elles n'apparaissent donc pas dans la trace.
- Pourquoi la ligne 4 est-elle vide? Python calcule bien
6 / 2 * (1 + 2)(ce qui donne9.0), mais le résultat n'est ni affiché (pas deprint) ni stocké (pas de variable) : il est perdu. Rien ne change dans la trace. - Pourquoi
12.0et non12Ă la ligne 6? La division/donne toujours un nombre Ă virgule (float), mĂȘme quand le rĂ©sultat tombe juste. - Pourquoi
resultatvaut-il encore42aux lignes 10 et 11? Ă la ligne 9, Python calcule6 * 7et range la valeur42dansresultat. La variable ne reste pas « reliĂ©e » Ăxety: changerxensuite ne recalcule rien!
Les explications de cette section étaient-elles claires ?
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 valeurs Ă mettre entre
()) - Est-ce qu'elle retourne une valeur qu'on peut stocker?
- Y a-t-il des cas limites ou erreurs possibles (exceptions)?
Par exemple, int() convertit une chaßne de caractÚres en entier⊠mais seulement si la chaßne représente un entier :
valeur = int("3.41")
Traceback (most recent call last):
File "...\r02_fonctions.py", line 1, in <module>
valeur = int("3.41")
ValueError: invalid literal for int() with base 10: '3.41'
Pour convertir "3.41", il faut plutĂŽt utiliser float("3.41").
đŻ Les paramĂštresâ
Pour appeler une fonction :
nom_de_fonction(valeur1, valeur2, ...)
âĄïž Le nombre et l'ordre des valeurs transmises 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) # mon_age_arrondi vaut 18
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() retournent la plus petite ou la plus grande des valeurs reçues.
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 recevoir un nombre variable de valeurs, contrairement Ă la plupart des fonctions qui attendent un nombre fixe de paramĂštres.
Elles fonctionnent aussi avec une liste (voir l'onglet Liste).
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
len() donne aussi le nombre d'éléments d'une liste (voir l'onglet Liste).
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") # 3
valeur_flottant = float("3.41") # 3.41
chaine_texte = str(42) # '42' (une chaĂźne de caractĂšres)
# Puissances et arrondi
valeur_puissance = pow(2, 3) # 8 (équivalent à 2 ** 3)
valeur_arrondie = round(3.14159, 2) # 3.14
# Type d'une variable
type_variable = type(longueur_prenom) # <class 'int'>
â ïž int() coupe les dĂ©cimales, il n'arrondit pas : int(3.99) donne 3 (et int(-3.99) donne -3).
Pour arrondir, utilisez round() : round(3.99) donne 4.
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 valeur d'entrĂ©e 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 :
- La fonction
str(42)convertit le nombre entier42en une chaĂźne de caractĂšres"42", - puis la fonction
len(...)calcule la longueur de cette chaĂźne, qui est2, - 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 recevoir un nombre variable de valeurs, séparées par des virgules, qu'elle affiche séparées par des espaces.
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 plusieurs valeurs
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)
Les deux versions affichent Le résultat de 6 x 7 est : 42. Les f-strings sont expliquées dans l'onglet f-strings.
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 argument 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 d'argument nommé (comme end=) sera étudié dans l'onglet ParamÚtres de 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
\nIl est également possible de faire un saut de ligne à l'aide du caractÚre spécial \n (une barre oblique inversée, ou backslash, suivie de la lettre n).
Si vous exécutez ce code :
print("A\nB\nC")
La console affichera :
A
B
C
âšïž Sur le clavier canadien français, la barre oblique inversĂ©e \ s'obtient avec AltCar + #. Voir l'aide-mĂ©moire Symboles au clavier.
" à 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'une barre oblique inversée \. On dit qu'on échappe le caractÚre.
print("Elle a dit : \"Bonjour!\"")
La console affichera :
Elle a dit : "Bonjour!"
La barre oblique inversĂ©e \ 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 une barre oblique inversée
đĄ 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 ?
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.
On pourrait obtenir un résultat semblable avec la concaténation (+) ou en séparant les éléments par des virgules dans print() :
x = 3.14159
print("Résultat : " + str(x)) # Concaténation : il faut convertir le nombre avec str()
print("Résultat :", x) # Virgules : print() ajoute une espace entre les éléments
print(f"Résultat : {x}") # f-string : la plus lisible
Les trois lignes affichent Résultat : 3.14159.
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.
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 |
| :.0% | Pourcentage (multiplie par 100 et ajoute %) | 0.15 â 15% / :.1% : 0.256 â 25.6% |
| :.2e | Notation scientifique avec 2 dĂ©cimales | 602214076000000000000000 â 6.02e+23 / 0.000123 â 1.23e-04 |
| :, | 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 |
- Notation scientifique :
6.02e+23se lit « 6,02 Ă 10ÂČÂł », et1.23e-04se lit « 1,23 Ă 10â»âŽ Â». - Combiner les options : on peut les combiner, par exemple
{1234567.891:,.2f}affiche1,234,567.89. d= entier seulement :f"{3.5:05d}"provoque une erreur (ValueError: Unknown format code 'd' for object of type 'float'). Pour unfloat, utilisezf.- Séparateur de milliers :
:,suit la convention anglaise (1,000,000). En français, on écrit1 000 000; pour l'obtenir :f"{nombre:,}".replace(",", " ").
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.
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).
đ C'est d'ailleurs la stratĂ©gie 1 de l'onglet PrĂ©cision des flottants pour cacher les 0.30000000000000004.
â ïž :.0f arrondit comme round() : une valeur exactement Ă mi-chemin va vers le nombre pair (f"{2.5:.0f}" affiche 2).
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
đŹ Des guillemets dans une f-string : dans f"{'Nom':<10}", le texte entre accolades est Ă©crit avec des guillemets simples, parce que la f-string elle-mĂȘme est entre guillemets doubles. Alternez toujours les deux types de guillemets pour Ă©viter les erreurs.
Aligner des nombres : on peut combiner l'alignement et le nombre de décimales. Pour une colonne de nombres, on aligne généralement à droite, pour que les décimales tombent les unes sous les autres :
print(f"{'Café':<10}{3.5:>8.2f} $")
print(f"{'Sandwich':<10}{12.75:>8.2f} $")
print(f"{'Repas':<10}{125.0:>8.2f} $")
Café 3.50 $
Sandwich 12.75 $
Repas 125.00 $
đ 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 ?
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 (et parfois des constantes) organisĂ©es autour d'un thĂšme.
Pour utiliser les fonctions d'un module, il existe deux approches principales :
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 (5 radians)
print(math.pi) # Résultat : 3.141592653589793 (une constante)
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)
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 (5 radians)
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.
Vous verrez peut-ĂȘtre from math import * (l'Ă©toile importe tout le module). Ăvitez-le : en lisant le code, on ne sait plus de quel module vient chaque fonction.
Oublier l'import :
print(math.sqrt(16))
Traceback (most recent call last):
File "...\r02_modules.py", line 1, in <module>
print(math.sqrt(16))
^^^^
NameError: name 'math' is not defined. Did you forget to import 'math'?
Python vous le suggĂšre d'ailleurs Ă la fin du message : Did you forget to import 'math'?
Oublier le préfixe du module (avec la méthode #1) :
import math
print(sqrt(16))
Traceback (most recent call last):
File "...\r02_modules.py", line 3, in <module>
print(sqrt(16))
^^^^
NameError: name 'sqrt' is not defined
Avec import math, il faut écrire math.sqrt(16). Pour écrire sqrt(16) directement, il faut la méthode #2 : from math import sqrt.
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)
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.
Ouvrez Copilot đ§ et essayez le prompt suivant :
Agis comme un formateur expert en Python.
Je suis étudiant en sciences 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.
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 ou des constantes spécifiques.
- Pour utiliser une bibliothÚque externe, il faut d'abord l'installer. Les bibliothÚques du cours (NumPy, Pandas, Matplotlib, etc.) font normalement déjà partie de l'environnement virtuel créé à la rencontre 1. Si ce n'est pas déjà fait, suivez la recette pour installer une bibliothÚque (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)
On peut donner un surnom (un alias) à un module, à une bibliothÚque ou à une fonction avec le mot-clé as.
C'est trÚs courant en Python, surtout pour les noms longs, et certains alias sont devenus de véritables conventions (np pour NumPy, pd pour Pandas, plt pour Matplotlib).
# Donner un alias Ă une bibliothĂšque
import numpy as np
print(np.array([1, 2, 3])) # np au lieu de numpy
# Donner un alias à une fonction spécifique
from time import sleep as pause
pause(2) # Le programme s'arrĂȘte pendant 2 secondes
Les explications de cette section étaient-elles claires ?
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]
đ Dans les commentaires # Affiche ... de cet onglet, on Ă©crit exactement ce que Python affiche : un Ă©lĂ©ment texte seul s'affiche sans guillemets (Mario), mais une liste s'affiche avec des guillemets simples autour de ses textes (['Link', 'Kirby']).
C'est aussi ce que vous devez écrire dans la colonne affichage d'une trace.
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)
print(heros[-2:]) # Affiche ['Kirby', 'Sonic'] (les 2 derniers)
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])
Traceback (most recent call last):
File "...\r02_listes.py", line 2, in <module>
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.
On peut modifier un élément en utilisant son index :
heros = ["Mario", "Link", "Kirby", "Sonic"]
heros[0] = "Samus"
print(heros) # Affiche ['Samus', 'Link', 'Kirby', 'Sonic']
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 :
ma_variable.ma_methode()
ma_variable.ma_methode(argument1)
Les méthodes disponibles varient selon le type de la variable. Par exemple, voici des méthodes propres aux chaßnes de caractÚres (ici, les guillemets dans les commentaires servent seulement à voir les espaces) :
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
La méthode append() ajoute un élément à la fin de la liste :
heros = ["Mario", "Link", "Kirby", "Sonic"]
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']
La méthode insert() ajoute un élément à une position précise : les éléments suivants sont décalés vers la droite.
heros = ["Mario", "Link", "Kirby", "Sonic", "Pikachu"]
heros.insert(1, "Samus") # InsĂšre "Samus" Ă l'index 1
print(heros) # Affiche ['Mario', 'Samus', 'Link', 'Kirby', 'Sonic', 'Pikachu']
La méthode remove() supprime la premiÚre occurrence d'une valeur :
heros = ["Mario", "Samus", "Link", "Kirby", "Sonic", "Pikachu"]
heros.remove("Samus")
print(heros) # Affiche ['Mario', 'Link', 'Kirby', 'Sonic', 'Pikachu']
â ïž Si la valeur n'est pas dans la liste, remove() provoque une erreur. Par exemple, un deuxiĂšme heros.remove("Samus") donnerait :
ValueError: list.remove(x): x not in list
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']
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
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
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.
print(sorted(["mario", "Link", "kirby"])) # Affiche ['Link', 'kirby', 'mario']
sorted() vs sort()sorted(liste): crĂ©e une nouvelle liste triĂ©e. La liste de dĂ©part ne change pas.liste.sort(): trie la liste elle-mĂȘme. Elle ne crĂ©e rien et retourneNone(« rien »).
notes = [3, 1, 2]
triees = sorted(notes) # on récupÚre la nouvelle liste dans "triees"
print(triees) # Affiche [1, 2, 3]
print(notes) # Affiche [3, 1, 2] (inchangée)
notes.sort() # la liste "notes" est triée directement
print(notes) # Affiche [1, 2, 3]
Erreur fréquente : sort() ne retourne rien, donc il ne faut pas stocker son résultat.
notes = [3, 1, 2]
notes = notes.sort()
print(notes) # Affiche None (la liste est perdue!)
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']
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]
Python offre des fonctions intégrées pratiques pour analyser rapidement une liste :
max(liste): retourne la valeur la plus grandemin(liste): retourne la valeur la plus petitesum(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
max() et min() fonctionnent aussi avec du texte : elles utilisent alors l'ordre alphabétique.
heros = ["Mario", "Link", "Kirby", "Sonic"]
print(max(heros)) # Affiche Sonic
print(min(heros)) # Affiche Kirby
sum()ne fonctionne qu'avec des nombres : on ne peut pas additionner du texte.max()etmin()ne fonctionnent pas avec des types mélangés (ex. :["a", 1]), car Python ne peut pas comparer un texte et un nombre.
heros = ["Mario", "Link", "Kirby", "Sonic"]
print(sum(heros)) # TypeError: unsupported operand type(s) for +: 'int' and 'str'
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]
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"
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 |
| Sous-liste (slicing) | sous_liste = heros[1:3] | ĂlĂ©ments d'index 1 et 2 (3 exclu) |
| Premiers éléments | premiers = heros[:4] | Les 4 premiers éléments (index 0 à 3) |
| Derniers éléments | derniers = heros[-2:] | Les 2 derniers éléments |
| 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 (ordre alphabétique pour du texte) |
| Minimum | valeur_min = min(heros) | Plus petite valeur (ordre alphabétique pour du texte) |
| Somme | total = sum(notes) | Somme de tous les éléments (nombres seulement) |
Les explications de cette section étaient-elles claires ?
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.
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...).
En binaire, 0.1 est une fraction périodique infinie :
0.1 (décimal) = 0.0001100110011001100110011001100110011001100110011001101... (binaire)
L'ordinateur doit donc la couper et stocker une approximation. Vous pouvez voir la valeur réellement stockée avec le module decimal :
from decimal import Decimal
print(Decimal(0.1)) # Affiche 0.1000000000000000055511151231257827021181583404541015625
C'est extrĂȘmement proche de 0.1, mais pas exactement Ă©gal. Et quand on additionne plusieurs de ces approximations, l'erreur s'accumule et peut devenir visible.
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!
Ce problÚme peut causer des bogues 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 calculs financiers ou scientifiques :
prix = 1.15
taxe = 0.15
total = prix + taxe
print(total) # Affiche 1.2999999999999998 au lieu de 1.3
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
round()round() réduit l'erreur visible, mais n'élimine pas les approximations internes :
print(round(2.675, 2)) # Affiche 2.67, et non 2.68 : 2.675 est en réalité stocké comme 2.67499999...
De plus, quand une valeur est exactement à mi-chemin, Python arrondit vers le nombre pair (on parle d'« arrondi bancaire ») :
print(round(2.5)) # Affiche 2, et non 3!
print(round(3.5)) # Affiche 4
print(round(0.5)) # Affiche 0
Pour des comparaisons fiables, préférez la stratégie 3.
â
StratĂ©gie 3 : Comparer avec math.isclose()â
Pour vérifier si deux flottants sont « pratiquement égaux », le module math offre la fonction isclose() :
import math
a = 0.1 + 0.2
b = 0.3
print(math.isclose(a, b)) # Affiche True â la diffĂ©rence est nĂ©gligeable
math.isclose() vérifie si l'écart entre les deux valeurs est trÚs petit par rapport à leur grandeur : elle tolÚre les minuscules erreurs des flottants.
â
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
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 : vous l'avez vu plus haut, Decimal(0.1) donne 0.1000000000000000055511...!
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.
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
==ouround()et préférermath.isclose().
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 ?
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 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.
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â
đš 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.
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.
Variables, réaffectation, module math (racine carrée), opérateurs arithmétiques (/, **), f-strings, trace d'exécution
đŻ Solutionnaire
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
đš Exercices de crĂ©ationâ
Pour chacun des exercices de cette section, vous devez créer des fichiers .py avec les noms indiqués.
Pour les exercices de cette section, vous pouvez consulter librement la documentation du site web du cours.
đ CrĂ©ez un fichier 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!
Variables, calculs et affectation, exécution en mode débogage (débogueur)
đ 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 :
â Sortie attendue
Masse sur Terre (kg) : 50
Le poids sur Mars est de 185.5 N.
Variables, opérateurs arithmétiques
đ 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â
- Déclarez une liste
mesurescontenant les 3 valeurs de pression systolique (matin, midi, soir) :mesures = [125, 130, 180] - Affichez chaque mesure en accédant aux éléments de la liste par leur index (
mesures[0],mesures[1],mesures[2]). - Calculez la moyenne Ă l'aide des fonctions
sum()etlen()appliquées directement sur la liste. - Affichez le résultat de façon claire et lisible.
Validez le bon fonctionnement de votre programme en modifiant les valeurs dans la 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
Listes, accĂšs par index, sum(), len()
đ 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 ?
Variables, module random (nombre entier aléatoire entre deux bornes), lecture de documentation
đ 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â
- Déclarez une liste vide :
nombres = []
- Ajoutez 5 nombres aléatoires (entre 0 et 100 inclusivement) à la liste, un à la fois, en utilisant la méthode
.append(). - 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.
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.)
Listes, liste vide, .append(), module random, accĂšs Ă la documentation
đ 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 et est :
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 .
Pour réaliser la racine carrée de la formule, vous aurez besoin d'une fonction du module math.
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
Listes imbriquées (liste de listes), accÚs par double index, module math (racine carrée), opérateurs arithmétiques (**), round()
đ 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
Variables, puissances de 10 (**), opérateurs arithmétiques, types numériques
đ 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$
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.54billets = [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 // 100395 // 1000
- Qu'est-ce qui reste? â soustrayez du montant restant la valeur des billets donnĂ©s :
restant = restant - nb * coupure.
(Le modulorestant % coupuredonne directement ce mĂȘme reste, si vous prĂ©fĂ©rez.)
- Combien de billets entiers? â la division entiĂšre (
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.
Listes, accÚs par index, division entiÚre (//) et modulo, opérateurs arithmétiques, variables intermédiaires
đ 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â
- 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 ]
« 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.
Si vous ajoutez une Ă©valuation, ajoutez-la dans les quatre listes, Ă la mĂȘme position. Un dĂ©calage fausse tout le calcul.
- 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.
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).
- 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!
Listes parallÚles, accÚs par index, opérateurs arithmétiques, accumulation dans une variable, round(), f-strings
âïž Exercices sur papierâ
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.
Ăcrivez (sur papier) un programme qui calcule la vitesse dâimpact () dâun objet en chute libre Ă partir dâune hauteur () 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 :
Note : utilisez 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 ) :
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.
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.
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 :
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Ă©s.
Cela dit, cet onglet vaut la peine d'ĂȘtre lu! Vous allez produire des graphiques plus tard dans ce cours avec cette bibliothĂšque.
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.
Voici un exemple simple, testez-le dans un script Python!
Ne vous inquiétez pas si vous ne comprenez pas le code pour l'instant : Matplotlib sera vu en détail à la rencontre 9, et l'aide-mémoire Matplotlib résume les principales fonctions.
đ Vous reconnaĂźtrez pourtant plusieurs notions de cette rencontre :
import ... as plt: l'importation d'un module avec un alias (onglet Modules et bibliothĂšques);ageettaille: des listes (onglet Liste);plt.plot(...),plt.title(...): des appels de fonctions (onglet Fonctions).
Les écritures comme marker="o" ou label="..." sont des arguments nommés : vous les verrez à la rencontre 3.
Pour utiliser une bibliothĂšque Python comme Matplotlib, il faut d'abord l'installer dans votre environnement de travail.
Matplotlib fait normalement partie de l'environnement virtuel créé à la rencontre 1. Si ce n'est pas déjà fait, suivez les étapes pour installer la bibliothÚque avant d'exécuter l'exemple ci-dessous.
# 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="blue", 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 ?