Python sans paniquer — 5 jours pour comprendre ce que tu tapes

Du calcul à la main au programme

Programme, algorithme, langage. Un algorithme est une suite d'étapes précises qui résout un problème. Celui de Yanis :

1. multiplier chaque note par son coefficient ;
2. additionner ces produits ;
3. additionner les coefficients ;
4. diviser la première somme par la deuxième.

Un langage est une façon d'écrire ces étapes pour qu'un ordinateur les exécute ; un programme est l'algorithme écrit dans ce langage. Python exécute les lignes dans l'ordre, de haut en bas.

note_maths = 12
note_bio = 15.5
note_chimie = 8
coef_maths = 2
coef_bio = 3
coef_chimie = 1
total = note_maths * coef_maths + note_bio * coef_bio + note_chimie * coef_chimie
somme_coefs = coef_maths + coef_bio + coef_chimie
moyenne = total / somme_coefs
print(moyenne)
print(round(moyenne, 2))

Affiche 13.083333333333334, puis 13.08.

Les variables. note_maths = 12 pose le nom note_maths sur la valeur 12. Le signe = range une valeur ; il ne compare pas. Une variable peut changer : note = note + 4 calcule note + 4, puis range le résultat dans note. Les noms s'écrivent en minuscules, sans espace ni accent, avec _ entre les mots.

Les types de base.

type(…) donne le type d'une valeur : print(type(12), type(15.5), type("12"), type(12 > 10)) affiche <class 'int'> <class 'float'> <class 'str'> <class 'bool'>.

Les opérateurs et les priorités.

Comme en maths, * et / passent avant + et - : 12 + 15 / 2 vaut 19.5, alors que (12 + 15) / 2 vaut 13.5. Dans une moyenne, les parenthèses comptent.

Les conversions. int("14") donne le nombre 14, float("12.5") donne 12.5, str(14) donne le texte "14". Et round(x, 2) arrondit x à 2 chiffres après la virgule.

Pourquoi 0.1 + 0.2 n'affiche pas 0.3. Essaie : print(0.1 + 0.2) affiche 0.30000000000000004. L'ordinateur range les nombres à virgule en binaire, et 0,1 ne s'écrit pas exactement en binaire (comme 1/3 ne s'écrit pas exactement en décimal). L'écart est minuscule ; pour une moyenne, il suffit d'arrondir à l'affichage : round(0.1 + 0.2, 2) affiche 0.3.

Lancer, puis lire une erreur en 3 questions

1. Choisir un environnement.

• Dans le navigateur, sans compte : Basthon. Rien à installer.
• Au lycée : Capytale, si ton établissement l'utilise, accessible depuis l'ENT avec le code d'activité donné par ton professeur.
• Sur ton ordinateur : Thonny, un éditeur pour débuter, à télécharger uniquement depuis son site officiel, thonny.org (si tu es mineur, avec un adulte). Les installateurs officiels incluent Python.
• En TP : tu croiseras peut-être des notebooks Jupyter ; on y exécute le code cellule par cellule, mais tout ce que tu apprends ici s'y applique.

2. Console ou script. La console (le >>>) exécute une ligne tout de suite : parfait pour essayer. Le script est un fichier .py qu'on écrit en entier, qu'on enregistre, puis qu'on lance.

3. Afficher et demander. print("Moyenne :", moyenne) affiche plusieurs valeurs séparées par des espaces. input("Note 1 : ") affiche la question, attend la réponse… et la renvoie toujours sous forme de texte. Pour un nombre, on convertit : float(input("Note 1 : ")).

print("Calcul de la moyenne de 3 notes")
note1 = float(input("Note 1 : "))
note2 = float(input("Note 2 : "))
note3 = float(input("Note 3 : "))
moyenne = (note1 + note2 + note3) / 3
print("Moyenne :", round(moyenne, 2))

Essai réel :

4. Lire une erreur en 3 questions.

1. Quelle ligne ? Le message donne le fichier et le numéro de ligne (line 2).
2. Quel type d'erreur ? C'est le premier mot de la dernière ligne du message.
3. Qu'est-ce qui ne va pas à cet endroit ? La fin de la dernière ligne l'explique ; les ^ montrent où regarder.

Le message de Yanis, lu avec la méthode : ligne 2 (points = note * 1.5) ; TypeError ; can't multiply sequence by non-int of type 'float' = « impossible de multiplier une séquence par un nombre non entier ». La séquence, c'est note : du texte, car input renvoie toujours du texte. Correction : note = float(input("Note de biologie : ")).

L'ordinateur suit ton texte à la lettre et s'arrête à la première chose qu'il ne peut pas faire. Le message d'erreur décrit ce moment précis : où, quoi, pourquoi. Le lire d'abord évite de modifier au hasard un code qui n'avait qu'une seule faute, ou de coller une « solution » trouvée en ligne qui répond à un autre problème. Depuis Python 3.10, les messages sont plus précis et proposent parfois la correction : Did you mean: 'moyenne'? (« Voulais-tu dire : moyenne ? »).

Bon réflexe ou piège ?

Les conditions et les boucles

Comparer. Une comparaison donne True ou False : == (égal), != (différent), <, <=, >, >=. On les combine avec and (et), or (ou), not (non) : avec note = 15, note >= 0 and note <= 20 vaut True, note < 0 or note > 20 vaut False.

Décider : if / elif / else.

moyenne = 13.08
if moyenne >= 16:
    print("Mention très bien")
elif moyenne >= 14:
    print("Mention bien")
elif moyenne >= 12:
    print("Mention assez bien")
else:
    print("Pas de mention")

Affiche Mention assez bien. Les conditions sont testées dans l'ordre ; la première vraie s'exécute, les autres sont ignorées. elif veut dire « sinon, si » ; else (« sinon ») est facultatif. Chaque ligne de test finit par deux-points :, et ce qui en dépend est décalé de 4 espaces.

Le piège de l'ordre. Le même programme avec les tests dans l'autre sens :

moyenne = 17
if moyenne >= 12:
    print("Mention assez bien")
elif moyenne >= 14:
    print("Mention bien")
elif moyenne >= 16:
    print("Mention très bien")
else:
    print("Pas de mention")

Affiche Mention assez bien pour 17 ! Le premier test (17 >= 12) est vrai : Python s'arrête là. On teste donc du seuil le plus haut au plus bas.

Répéter un nombre connu de fois : for.

total = 0
for i in range(3):
    note = float(input("Note : "))
    total = total + note
    print("Tour", i, "- total provisoire :", total)
print("Total :", total)

Essai réel :

range(3) donne 0, 1, 2 : trois valeurs, en commençant à 0, sans jamais atteindre 3. range(2, 5) donne 2, 3, 4. La variable total, créée avant la boucle et augmentée à chaque tour, est un accumulateur.

Répéter tant qu'une condition est vraie : while.

note = float(input("Note sur 20 : "))
while note < 0 or note > 20:
    print("Une note est comprise entre 0 et 20.")
    note = float(input("Note sur 20 : "))
print("Note enregistrée :", note)

Essai réel :

Tant que la note est impossible, on la redemande. Attention : si rien ne change dans la boucle, la condition reste vraie pour toujours. C'est une boucle infinie : arrête le programme avec le bouton Stop (ou Ctrl+C).

Les mentions. Au baccalauréat, la mention assez bien correspond à une moyenne d'au moins 12 (et moins de 14), bien à au moins 14 (et moins de 16), très bien à au moins 16 ; la mention « très bien avec les félicitations du jury » s'ajoute à partir de 18. En licence, c'est le règlement des examens de ton université qui fixe les règles : vérifie-le avant de les programmer.

« Une étape, un test, un cas connu »

Rappels : conversions et priorités (voir épisode 1), lecture d'erreur (voir épisode 2), for et accumulateurs (voir épisode 3).

1. Le cas de référence : calcule une moyenne à la main. Ici : 12 (coef 2), 15,5 (coef 3), 8 (coef 1) → (24 + 46,5 + 8) / 6 = 78,5 / 6 ≈ 13,08.
2. Une étape : demander le nombre de matières, puis la boucle de saisie, puis le calcul, puis l'affichage.
3. Un test après chaque étape, avec le cas de référence.
4. On compare l'obtenu et l'attendu. Seulement si c'est juste, on passe à l'étape suivante.

Le calculateur :

nb_matieres = int(input("Nombre de matières : "))
total = 0
somme_coefs = 0
for i in range(nb_matieres):
    print("Matière", i + 1)
    note = float(input("  Note sur 20 : "))
    coef = float(input("  Coefficient : "))
    total = total + note * coef
    somme_coefs = somme_coefs + coef
moyenne = total / somme_coefs
print("Moyenne :", round(moyenne, 2))

Essai réel avec le cas de référence :

Obtenu = attendu. Le cas de référence a aussi démasqué les deux bugs de Yanis (sorties réelles) :

• total = 0 placé dans la boucle : le total repart de zéro à chaque matière → Moyenne : 1.33 ;
• division par nb_matieres au lieu de somme_coefs → Moyenne : 26.17 (une moyenne sur 20 ne dépasse jamais 20 : c'est un signal d'alarme).

Quand on ajoute une seule étape à la fois, une erreur apparaît juste après l'étape qui l'a introduite : on sait où chercher. Et le cas calculé à la main transforme « ça a l'air de marcher » en « c'est juste » : un résultat plausible peut être faux, comme 13,5 au lieu de 13,08. C'est la même démarche qu'en TP de sciences : on vérifie un protocole sur un échantillon dont on connaît la réponse avant de l'appliquer au reste.

Bon réflexe ou piège ?