Python module 1 : installer, écrire, faire réagir

Jour 1 — Installer Python et ouvrir le terminal

Objectif : installer Python 3.12+, ouvrir un terminal, et vérifier que la commande python --version répond.

Théorie (20 min)

Un programme est une suite d'instructions écrites dans un fichier texte, qu'on donne à la machine à exécuter. Python est un langage interprété : un programme appelé l'interpréteur Python lit votre fichier ligne par ligne et fait ce qu'il dit, immédiatement. Pas de compilation, pas d'étape intermédiaire.

Le terminal (aussi appelé console ou invite de commandes) est une fenêtre où l'on parle à l'ordinateur en tapant du texte au lieu de cliquer. On y tape une commande, on appuie sur Entrée, la machine répond en texte juste en dessous. C'est là que vous lancerez tous vos programmes.

• Sous Windows : installez Python depuis python.org/downloads et cochez « Add python.exe to PATH » sur le premier écran. Le PATH est la liste des dossiers où Windows cherche les commandes ; sans cette case, le terminal ne trouvera pas python. Ouvrez ensuite « Terminal » ou « Invite de commandes ».
• Sous macOS : ouvrez l'application Terminal, puis installez Python depuis python.org. La commande s'appellera python3.
• Sous Linux : Python est presque toujours déjà installé, sous le nom python3. Si la commande manque, installez le paquet python3 de votre distribution.

La version compte : ce parcours suppose Python 3.12 ou plus récent. Le numéro se lit « majeur.mineur.correctif » : 3.12.4 est la version 3, sous-version 12, quatrième correction.

Pratique (30 min)

1. Installez Python comme indiqué ci-dessus pour votre système.
2. Ouvrez un terminal. Tapez python --version (sous macOS/Linux : python3 --version) puis Entrée.
3. Critère de réussite : le terminal affiche quelque chose comme Python 3.12.4 ou plus récent. Si vous voyez « commande introuvable » ou « is not recognized », relancez l'installateur en cochant la case PATH, fermez le terminal et rouvrez-le.
4. Tapez maintenant python seul (ou python3) : vous entrez dans le REPL, le mode conversation de Python (le symbole >>> apparaît). Tapez 2 + 2, Entrée : il répond 4. Tapez exit() pour sortir.
5. Notez dans le carnet : votre système, la commande qui marche (python ou python3), la version installée. Vous utiliserez cette commande tous les jours — dans ce parcours, on l'écrira python ; adaptez si votre machine veut python3.

Tips agent : un agent LLM diagnostique un problème d'installation en une question : « voici ce que tape python --version : [sortie collée], quel est le problème ? ». Piège : il ne peut pas voir votre écran, collez la sortie exacte. Preuve à demander : la commande qui montre que c'est réparé, pas une explication.

Synthèse (10 min)

Trois lignes : ce qu'est l'interpréteur, ce qu'est le terminal, ce qu'est le PATH. Puis, sans notes : fermez le terminal, rouvrez-le, et retrouvez la version de Python.

Jour 2 — Votre premier programme

Objectif : écrire un fichier .py dans l'éditeur, le lancer depuis le terminal, et voir votre message s'afficher.

Théorie (20 min)

Hier, vous avez tapé des ordres un par un dans le REPL. Aujourd'hui, on les écrit dans un fichier pour les garder et les rejouer. Un fichier Python est un simple fichier texte dont le nom finit par .py.

La première instruction à connaître est print() : elle affiche quelque chose à l'écran. Entre les parenthèses, on met ce qu'on veut afficher. Un morceau de texte s'écrit entre guillemets — on l'appelle une chaîne de caractères (string en anglais, vous croiserez ce mot partout) :

print("Bonjour le monde")

Les guillemets ne s'affichent pas : ils disent juste à Python « ceci est du texte, pas une instruction ». print(Bonjour) sans guillemets serait une erreur, car Python chercherait quelque chose qui s'appelle Bonjour.

Le couple éditeur + terminal est votre atelier : vous écrivez et enregistrez dans l'éditeur, vous exécutez dans le terminal avec python nom_du_fichier.py. Le terminal exécute la commande dans le dossier courant — le dossier où il « se trouve ». La commande cd (change directory) sert à se déplacer : cd Documents\python sous Windows, cd Documents/python sous macOS/Linux.

Pratique (30 min)

1. Créez un dossier python dans vos Documents. Dans le terminal, placez-vous dedans avec cd.
2. Ouvrez votre éditeur, tapez exactement :

print("Bonjour le monde")
print("Je programme.")

3. Enregistrez sous le nom bonjour.py dans ce dossier (attention : pas bonjour.py.txt — si Windows cache les extensions, affichez-les dans les options de l'explorateur).
4. Dans le terminal : python bonjour.py.
5. Critère de réussite : les deux lignes s'affichent dans le terminal, sans les guillemets.
6. Modifiez le texte, enregistrez, relancez avec la flèche Haut du terminal (elle rappelle la dernière commande). Voyez le changement : vous venez de boucler le cycle écrire → enregistrer → exécuter, que vous ferez des centaines de fois.
7. Provoquez l'erreur volontairement : enlevez le guillemet fermant, relancez, lisez le message, corrigez.

Tips agent : « crée un fichier bonjour.py qui affiche deux phrases » est un ordre qu'un agent exécute en une seconde. Piège : il peut l'écrire dans un autre dossier que le vôtre. Preuve à demander : ls bonjour.py (ou dir bonjour.py) puis la sortie de python bonjour.py, collées toutes les deux.

Synthèse (10 min)

Trois lignes : ce que fait print, pourquoi les guillemets, ce qu'est le dossier courant. Puis, sans notes : recréez bonjour.py de mémoire et lancez-le.

Jour 3 — Les variables : des boîtes étiquetées

Objectif : stocker une valeur dans une variable, la réutiliser, la changer.

Théorie (20 min)

Une variable est un nom qui pointe vers une valeur. Imaginez une boîte avec une étiquette : l'étiquette, c'est le nom ; le contenu, c'est la valeur. On crée la boîte avec le signe = :

prenom = "Alice"
age = 30
print(prenom)
print(age)

prenom = "Alice" se lit « prenom reçoit Alice ». Attention : le = de Python n'est pas celui des maths, c'est une affectation — il range la valeur de droite dans le nom de gauche. Ensuite, partout où vous écrivez prenom, Python lit la valeur rangée dedans.

Règles de nommage : lettres minuscules, chiffres (pas en première position) et underscore _ ; pas d'espaces, pas d'accents de préférence. La convention Python est le snake_case : nom_de_famille, nombre_de_cafe. Un nom bien choisi rend le programme lisible : total vaut mieux que x.

Une variable peut changer de contenu : la boîte garde son étiquette, on remplace le contenu.

score = 0
score = score + 10
print(score)

Affiche 10 : Python calcule d'abord score + 10 avec l'ancienne valeur (0), puis range le résultat dans score.

Pratique (30 min)

1. Créez profil.py :

prenom = "Alice"
ville = "Lyon"
annee_naissance = 1994
age = 2026 - annee_naissance
print(prenom)
print(ville)
print(age)

2. Lancez-le. Critère de réussite : trois lignes s'affichent, la dernière étant l'âge calculé par la machine, pas par vous.
3. Remplacez les valeurs par les vôtres, relancez.
4. Ajoutez une variable annee_naissance fausse de 1 an, relancez, observez que l'âge suit : la variable propage sa valeur partout où elle est utilisée.
5. Écrivez un nom interdit (2e_place = 1), lancez, lisez l'erreur, corrigez.

Tips agent : demandez-lui « relis ce fichier et liste les variables avec ce qu'elles contiennent au moment du print ». Piège : il peut « exécuter de tête » et se tromper sur une réaffectation. Preuve : vous lancez le fichier vous-même et comparez ligne à ligne.

Synthèse (10 min)

Trois lignes : affectation vs égalité, règles de nommage, pourquoi réutiliser une variable dans sa propre affectation fonctionne. Refaites profil.py sans notes.

Jour 4 — Les nombres et les calculs

Objectif : distinguer entiers et décimaux, et faire calculer Python comme une calculette.

Théorie (20 min)

Python connaît deux sortes de nombres : les entiers (int, comme 7, -3, 1 000 000) et les décimaux (float, comme 3.14, -0.5 — avec un point, pas une virgule : la virgule a un autre sens en Python). Le type d'une valeur, c'est sa nature ; il décide de ce qu'on peut en faire. La fonction type() vous le dit : print(type(7)) affiche <class 'int'>.

Les opérations :

• + addition, - soustraction, * multiplication ;
• / division — donne toujours un float : 10 / 2 donne 5.0 ;
• // division entière : 10 // 3 donne 3 (on jette le reste) ;
• % reste de la division (on dit « modulo ») : 10 % 3 donne 1 ;
• ** puissance : 2 ** 10 donne 1024 ;
• les parenthèses fixent l'ordre : (2 + 3) * 4 donne 20, 2 + 3 * 4 donne 14.

Le modulo est le favori des programmeurs : n % 2 vaut 0 si n est pair, 1 s'il est impair. Et une bizarrerie à connaître : 0.1 + 0.2 affiche 0.30000000000000004. Les floats sont stockés en binaire et certaines valeurs décimales n'y ont pas d'écriture exacte — comme 1/3 en décimal. Pour de l'argent, on compte en centimes avec des entiers.

Pratique (30 min)

1. Dans le REPL (tapez python seul), calculez : 365 * 24 (les heures d'une année), 2 ** 16, 100 // 7, 100 % 7, (12 + 8) / 2.
2. Vérifiez type(10 / 2) puis type(10 // 2).
3. Créez budget.py :

salaire = 2100
loyer = 750
courses = 380
reste = salaire - loyer - courses
par_jour = reste / 30
print(reste)
print(par_jour)

4. Critère de réussite : le programme affiche 970 puis environ 32.33 — deux nombres calculés par Python.
5. Changez le salaire, relancez : les deux lignes suivent.

Tips agent : « calcule-moi X » est le pire usage d'un LLM : ils se trompent en arithmétique. Un agent sérieux écrit le calcul en Python et l'exécute. Preuve à demander : la commande lancée et sa sortie, jamais le résultat « de tête ».

Synthèse (10 min)

Trois lignes : int vs float, ce que / rend toujours, à quoi sert %. Sans notes : combien de semaines entières et de jours restants dans 100 jours ? (Écrivez les deux expressions, vérifiez au REPL.)

Jour 5 — Le texte : les chaînes de caractères

Objectif : assembler et mettre en forme du texte avec les f-strings.

Théorie (20 min)

Une chaîne de caractères est du texte entre guillemets : "Alice", "12 rue des Lilas", "123" (du texte, pas le nombre 123 !). On peut les coller bout à bout avec + — la concaténation :

prenom = "Alice"
message = "Bonjour " + prenom
print(message)

Mais coller des morceaux avec + devient vite illisible, et il faut convertir les nombres à la main. La méthode moderne est la f-string : un f collé devant le guillemet, et des accolades {} dans le texte où Python insère les valeurs :

nom = "Alice"
age = 30
print(f"{nom} a {age} ans.")
print(f"Dans 10 ans, {nom} aura {age + 10} ans.")

Entre les accolades, on peut mettre n'importe quelle expression — même un calcul. C'est la façon standard d'écrire du texte en Python aujourd'hui.

Quelques outils sur les chaînes (on dit des méthodes : des actions qu'on demande à une valeur avec un point) :

• len("Alice") → 5 : la longueur, en caractères ;
• "Alice".upper() → "ALICE", .lower() → "alice" ;
• " abc ".strip() → "abc" : enlève les espaces aux bords ;
• "a,b,c".split(",") → la liste ["a", "b", "c"] (on reverra les listes au module 2).

Pratique (30 min)

1. Créez carte.py :

nom = "Alice"
ville = "Lyon"
age = 30
print(f"Je m'appelle {nom}.")
print(f"J'habite à {ville}, {len(ville)} lettres.")
print(f"L'an prochain j'aurai {age + 1} ans.")
print(nom.upper())

2. Critère de réussite : quatre phrases s'affichent avec vos valeurs insérées — aucune accolade ne reste visible à l'écran.
3. Oubliez le f devant une chaîne, relancez : les accolades s'affichent telles quelles. C'est l'erreur n°1 des débutants — apprenez à la reconnaître.
4. Ajoutez print("Bonjour " + nom + ", tu as " + str(age) + " ans") : notez le str() obligatoire pour convertir le nombre, et pourquoi la f-string est plus confortable.

Tips agent : « transforme ces trois print avec + en f-strings » est une refonte parfaite pour un agent. Piège : il peut changer le texte affiché au passage. Preuve : lancez les deux versions et comparez les sorties caractère par caractère.

Synthèse (10 min)

Trois lignes : concaténation, f-string, ce que fait len(). Sans notes : affichez « Alice a 30 ans » à partir de deux variables, avec une f-string.

Jour 6 — Demander à l'utilisateur : input()

Objectif : écrire un programme qui pose une question et utilise la réponse.

Théorie (20 min)

Jusqu'ici, vos programmes disaient toujours la même chose. input() les rend interactifs : le programme s'arrête, affiche une invite, attend que l'utilisateur tape quelque chose et appuie sur Entrée, puis rend ce qui a été tapé :

nom = input("Comment tu t'appelles ? ")
print(f"Bonjour {nom} !")

Le point critique du jour : input() rend toujours une chaîne de caractères, même si l'utilisateur tape des chiffres. Tapez 25, vous recevez le texte "25", pas le nombre. Et "25" + 1 est une erreur : on ne peut pas additionner du texte et un nombre.

La solution : convertir avec int() (vers un entier) ou float() (vers un décimal) :

age = int(input("Ton âge ? "))
print(f"Dans dix ans : {age + 10}")

Si l'utilisateur tape « trente », int("trente") plante avec une ValueError. On apprendra à l'attraper au jour 26 ; aujourd'hui, tapez des chiffres.

Pratique (30 min)

1. Créez dialogue.py :

nom = input("Ton prénom ? ")
ville = input("Ta ville ? ")
annee = int(input("Ton année de naissance ? "))
age = 2026 - annee
print(f"Bonjour {nom} de {ville}, tu as environ {age} ans.")

2. Critère de réussite : le programme pose trois questions, attend vos réponses, puis affiche une phrase qui les utilise toutes les trois.
3. Retirez le int(...), relancez, lisez le TypeError : unsupported operand type(s) for -: 'int' and 'str'. Remettez-le. Vous savez désormais lire l'erreur la plus fréquente du débutant.
4. Ajoutez une quatrième question (« ton plat préféré ? ») et intégrez la réponse à la phrase finale.

Tips agent : collez à l'agent votre TypeError complet plus la ligne qui la produit, et demandez « pourquoi, en une phrase ». Piège : sans la ligne de code, il devine. Preuve : sa correction doit tourner chez vous, pas dans sa réponse.

Synthèse (10 min)

Trois lignes : ce que fait input, ce qu'il rend toujours, quand convertir. Sans notes : programme qui demande un nombre et affiche son double.

Jour 7 — Lire un message d'erreur sans paniquer

Objectif : reconnaître les trois erreurs les plus fréquentes du débutant et savoir où chercher dans un message d'erreur.

Théorie (20 min)

Quand Python ne comprend pas, il s'arrête et affiche un message d'erreur. Ce message n'est pas une punition : c'est un mode d'emploi. Il se lit de bas en haut : la dernière ligne dit le type d'erreur et la cause, les lignes au-dessus montrent où ça s'est passé (fichier, numéro de ligne, et une flèche ^ sous l'endroit précis).

Les trois erreurs que vous verrez le plus :

• SyntaxError : la phrase est mal formée — parenthèse ou guillemet oublié, faute de frappe sur un mot-clé (prin au lieu de print avec des parenthèses, c'est autre chose : voir NameError). Exemple : print("bonjour → SyntaxError: unterminated string literal. La flèche pointe l'endroit où Python s'est perdu.
• NameError : vous utilisez un nom qui n'existe pas — faute de frappe dans une variable, ou variable utilisée avant d'être créée. NameError: name 'prenon' is not defined se lit « je ne connais pas prenon ». Vérifiez l'orthographe exacte, majuscules comprises.
• TypeError : vous mélangez deux natures incompatibles, comme du texte et un nombre dans un calcul (vu hier). Le message nomme les deux types en présence.

La méthode, toujours la même : lire la dernière ligne, repérer le numéro de ligne indiqué, ouvrir le fichier à cette ligne, corriger, relancer. Une erreur corrigée est une leçon apprise ; notez-la dans le carnet avec sa cause.

Pratique (30 min)

1. Créez erreurs.py avec ce contenu volontairement cassé :

prenom = "Alice"
print(prenon)
age = int("trente")

2. Lancez, lisez le NameError, notez le numéro de ligne, corrigez prenon en prenom.
3. Relancez : nouvelle erreur, une ValueError sur int("trente"). Lisez sa dernière ligne. Remplacez par int("30").
4. Ajoutez la ligne print("fin" (parenthèse manquante), relancez : SyntaxError. Corrigez.
5. Critère de réussite : le fichier final s'exécute sans erreur, et votre carnet liste les trois erreurs rencontrées avec leur cause en une phrase chacune.

Tips agent : un agent excelle à traduire un message d'erreur en langage simple : collez le message ENTIER et le fichier. Piège : ne collez que la fin — il aurait la cause mais pas le contexte. Preuve : après sa correction, vous relancez et l'erreur a disparu.

Synthèse (10 min)

Trois lignes : comment on lit un message d'erreur, et les trois types du jour avec leur cause typique. Sans notes : écrivez un NameError volontaire et corrigez-le.

Jour 8 — Vrai ou faux : booléens et comparaisons

Objectif : comparer des valeurs et manipuler les deux valeurs True et False.

Théorie (20 min)

Avant de faire décider un programme (demain), il faut savoir lui poser des questions. Une comparaison est une question dont la réponse est vrai ou faux :

• == : égal ? (deux signes = ! Un seul = range une valeur, deux == comparent. C'est LA faute de frappe classique.)
• != : différent ?
• <, >, <=, >= : plus petit, plus grand, au plus, au moins.

La réponse à une comparaison est un booléen (du mathématicien George Boole) : une valeur qui ne peut être que True ou False — c'est le troisième type que vous rencontrez après les nombres et les chaînes. Notez les majuscules : true en minuscules est un NameError.

age = 20
print(age >= 18)
print(age == 18)
majeur = age >= 18
print(type(majeur))

Affiche True, False, puis <class 'bool'>. On peut ranger le résultat d'une comparaison dans une variable, comme ici majeur — c'est ce qui rendra nos décisions lisibles demain.

Les comparaisons marchent aussi sur le texte : "alice" == "Alice" est False (la casse compte), d'où le réflexe reponse.lower() == "oui" pour accepter « Oui », « OUI », « oui ».

Pratique (30 min)

1. Au REPL, testez : 10 > 5, 10 == 10.0, "a" == "A", 7 != 7, type(True).
2. Créez verif.py :

mot = input("Un mot de passe à tester : ")
assez_long = len(mot) >= 8
contient_chiffre = "0" in mot or "1" in mot
print(f"Assez long : {assez_long}")
print(f"Contient 0 ou 1 : {contient_chiffre}")

3. Critère de réussite : le programme affiche deux lignes True/False qui changent selon ce que vous tapez (testez « abc », puis « abcdef01 »).
4. in est nouveau : "0" in mot demande si le texte contient ce caractère. Ajoutez un test "!" in mot et une troisième ligne affichée.

Tips agent : « explique la différence entre = et == avec un exemple qui plante » : bon exercice à faire corriger par un agent. Piège : dans une vraie condition, if age = 18: est une SyntaxError immédiate — Python refuse, heureusement. Preuve : faites-lui produire l'exemple et l'erreur, lancez les deux.

Synthèse (10 min)

Trois lignes : ce qu'est un booléen, = vs ==, ce que fait in sur une chaîne. Sans notes : variable qui vaut True si un nombre est pair (indice : %).

Jour 9 — if / else : le programme décide

Objectif : exécuter du code seulement si une condition est vraie.

Théorie (20 min)

Le if (« si ») exécute un bloc de code seulement quand sa condition est vraie ; le else (« sinon »), optionnel, prend le relais quand elle est fausse :

age = int(input("Ton âge ? "))
if age >= 18:
    print("Tu es majeur.")
else:
    print("Tu es mineur.")
print("Fin du programme.")

Trois choses à voir : les deux-points : à la fin des lignes if et else ; le bloc sous le if est indenté — décalé de 4 espaces vers la droite, c'est comme ça que Python sait ce qui appartient au if ; et la dernière ligne, non indentée, s'exécute dans tous les cas. Les espaces font partie de la syntaxe en Python (séance 11 pour les détails).

La condition est n'importe quelle expression qui vaut True ou False : une comparaison, un booléen rangé dans une variable. On peut aussi tester directement une variable : if majeur: se lit « si majeur est vrai ».

Un piège de débutant : tout ce qui suit un if doit être exécutable dans les deux cas. Si vous créez une variable dans le bloc if et que la condition est fausse, elle n'existera pas après. Initialisez vos variables avant le if.

Pratique (30 min)

1. Retapez le programme du cours dans majeur.py, lancez-le avec 20 puis avec 15.
2. Critère de réussite : deux exécutions donnent deux sorties différentes, et « Fin du programme. » apparaît dans les deux cas.
3. Enlevez l'indentation du premier print, relancez : IndentationError. Corrigez — c'est la quatrième erreur de votre carnet.
4. Créez pair.py : demandez un nombre, affichez « pair » si n % 2 == 0, « impair » sinon. Testez avec 10 et 7.
5. Bonus : dans majeur.py, rangez age >= 18 dans une variable est_majeur et écrivez if est_majeur:. Même comportement, meilleure lecture.

Tips agent : « ajoute un else à ce script qui gère le cas vide » — un agent le fait bien. Piège : il peut réindenter tout le fichier à sa sauce. Preuve : le programme répond pareil aux mêmes entrées, plus le nouveau cas.

Synthèse (10 min)

Trois lignes : rôle des deux-points, rôle de l'indentation, quand le else s'exécute. Sans notes : programme qui dit « positif » ou « négatif ou nul » selon un nombre tapé.

Jour 10 — elif, and, or : décisions multiples

Objectif : gérer plus de deux cas, et combiner plusieurs conditions.

Théorie (20 min)

Quand il y a plus de deux cas, on enchaîne avec elif (contraction de « else if », sinon si) :

note = int(input("Ta note sur 20 ? "))
if note >= 16:
    print("Très bien")
elif note >= 14:
    print("Bien")
elif note >= 10:
    print("Passable")
else:
    print("Insuffisant")

Python teste les conditions dans l'ordre, de haut en bas, et s'arrête à la première vraie. Avec une note de 17, seul « Très bien » s'affiche, même si 17 ≥ 10 est vrai aussi. L'ordre des cas compte donc : du plus exigeant au moins exigeant. Le else final attrape tout ce qui reste.

Pour combiner des conditions : and (les deux doivent être vraies), or (au moins une), not (inverse) :

age = 25
a_un_permis = True
if age >= 18 and a_un_permis:
    print("Tu peux louer une voiture.")
if age < 12 or age >= 65:
    print("Tarif réduit.")

Priorité : not d'abord, puis and, puis or. Dès qu'une combinaison dépasse deux termes, mettez des parenthèses pour être sûr : (a or b) and c.

Pratique (30 min)

1. Retapez le programme de notes dans notes.py. Testez 17, 14, 10, 5.
2. Critère de réussite : quatre exécutions, quatre mentions différentes.
3. Inversez deux branches (mettez note >= 10 en premier), testez 17 : « Passable » s'affiche. Voilà pourquoi l'ordre compte. Rétablissez.
4. Créez cinema.py : demandez l'âge ; moins de 12 ans ou 65 ans et plus → « Tarif réduit : 5 € » ; étudiant (demandez aussi oui/non, comparez avec .lower() == "oui") → « Tarif étudiant : 7 € » ; sinon « Plein tarif : 10 € ». Testez les quatre chemins.

Tips agent : « écris la table de vérité de mes conditions et dis-moi quel cas n'est jamais atteint » : un agent repère bien les branches mortes. Piège : il suppose parfois l'ordre que vous « vouliez ». Preuve : exécutez chaque branche avec une entrée qui la déclenche.

Synthèse (10 min)

Trois lignes : ce que fait elif, pourquoi l'ordre des cas compte, and vs or. Sans notes : réécrivez le programme de notes à trois branches.

Jour 11 — L'indentation : pourquoi les espaces comptent

Objectif : comprendre les blocs indentés et ne plus jamais subir l'IndentationError.

Théorie (20 min)

En Python, l'indentation — le décalage en début de ligne — n'est pas décorative : elle définit la structure du programme. Là où d'autres langages utilisent des accolades {} pour grouper des instructions, Python utilise le décalage. Toutes les lignes décalées au même niveau après un if, un else (et plus tard for, while, def) forment un bloc.

if pluie:
    print("Prends un parapluie.")
    print("Et un ciré.")
print("Bon courage.")

Les deux premiers print forment le bloc du if ; le dernier, revenu au bord gauche, n'en fait plus partie. La convention — et c'est celle de tous les projets Python — est 4 espaces par niveau. Jamais de tabulation mélangée avec des espaces : visuellement identique, mais Python peut refuser le mélange. Réglez votre éditeur pour « insérer des espaces à la tabulation » (réglage par défaut de VSCodium).

Les blocs s'imbriquent : un if dans un if ajoute 4 espaces de plus. Deux niveaux suffisent dans la plupart des programmes ; au-delà de trois, c'est souvent le signe qu'on peut simplifier.

if age >= 18:
    if a_un_permis:
        print("Location possible.")
    else:
        print("Passe ton permis !")
else:
    print("Reviens dans quelques années.")

Pratique (30 min)

1. Retapez l'exemple imbriqué dans location.py, avec les deux variables définies en haut. Testez les quatre combinaisons (18+/permis, 18+/sans permis, 15, 15/sans permis).
2. Critère de réussite : quatre messages différents pour quatre situations.
3. Décalez une ligne d'un espace de trop au milieu d'un bloc, relancez : IndentationError. Lisez la ligne indiquée, corrigez.
4. Réécrivez le même programme avec des elif et un and, sans imbrication. Comparez : lequel se relit le plus vite ? Gardez cette version.

Tips agent : « réécris ce code imbriqué à plat avec des elif » est une refonte qu'un agent fait proprement. Piège : il peut inverser une condition au passage (≥ devient >). Preuve : votre table des quatre cas doit donner les mêmes messages avant et après.

Synthèse (10 min)

Trois lignes : ce qu'est un bloc, la règle des 4 espaces, le danger du mélange tabulations/espaces. Sans notes : un if imbriqué à deux niveaux qui affiche trois messages possibles.

Jour 12 — Mini-projet : la calculatrice de pourboire

Objectif : assembler variables, input, calculs, f-strings et if dans un programme utile.

Théorie (20 min)

Pas de notion nouvelle aujourd'hui : on assemble. Un vrai petit programme suit toujours le même squelette en trois temps :

1. Entrées : demander à l'utilisateur ce dont on a besoin (input, conversions).
2. Calculs : transformer ces entrées en résultats (opérations, conditions).
3. Sortie : afficher les résultats mis en forme (f-strings).

Deux outils de mise en forme utiles pour l'argent :

• round(x, 2) arrondit à deux décimales : round(12.345, 2) donne 12.35.
• Dans une f-string, {prix:.2f} affiche le nombre avec exactement deux décimales : f"{12.3:.2f}" donne "12.30". Pratique pour les prix.

Avant de coder, écrivez au brouillon (ou dans le carnet) les trois temps avec des mots : « je demande l'addition et le pourcentage de pourboire ; je calcule le pourboire et le total ; j'affiche les deux montants ». Un programme pensé en français s'écrit en Python presque tout seul.

Pratique (30 min)

1. Écrivez pourboire.py en suivant le squelette :

addition = float(input("Montant de l'addition (€) ? "))
qualite = input("Service : super / correct / mauvais ? ").lower()

if qualite == "super":
    taux = 0.15
elif qualite == "correct":
    taux = 0.10
else:
    taux = 0.0

pourboire = addition * taux
total = addition + pourboire
print(f"Pourboire : {pourboire:.2f} €")
print(f"Total à payer : {total:.2f} €")

2. Critère de réussite : avec une addition de 42,50 et « super », le programme affiche Pourboire : 6.38 € et Total à payer : 48.87 € (les floats arrondissent parfois de façon surprenante — souvenez-vous du jour 4). Vérifiez les trois niveaux de service.
3. Ajoutez une question « Nombre de personnes ? » et affichez la part par personne (total / personnes, toujours avec :.2f).
4. Que se passe-t-il si l'utilisateur tape « SUPER » ? Vérifiez que le .lower() absorbe la casse.

Tips agent : ce programme entier, un agent l'écrit en dix secondes à partir de la description en trois temps — c'est exactement pour ça qu'on l'a écrit à la main : vous devez pouvoir relire le sien. Piège : il peut choisir des taux différents des vôtres. Preuve : imposer vos trois montants de test et comparer les sorties.

Synthèse (10 min)

Trois lignes : le squelette entrées → calculs → sortie, et les deux façons d'arrondir un prix. Sans notes : réécrivez le programme avec seulement deux niveaux de service.

Jour 13 — Révisions guidées

Objectif : consolider tout le module 1 par des exercices courts, sans notion nouvelle.

Théorie (20 min)

Relisez vos notes des jours 1 à 12, puis le tableau récapitulatif :

Repérez la ligne du tableau que vous savez le moins expliquer à voix haute : c'est la séance à relire en entier. Apprendre, c'est réviser au moment où ça commence à s'effacer — aujourd'hui est ce moment pour les jours 3 à 6.

Pratique (30 min)

Quatre exercices, sans relire les séances — vérifiez en relançant chaque programme :

1. Devine l'âge : demandez prénom et année de naissance, affichez « X aura Y ans cette année ». Critère : la phrase utilise les deux entrées et le calcul est fait par Python.
2. Convertisseur : demandez des kilomètres (float), affichez les miles (1 km ≈ 0,621371 mile) avec deux décimales. Critère : 10 km → 6.21 miles.
3. Billets : demandez un montant en euros, affichez combien de billets de 20 (avec //) et quel reste (avec %). Critère : 95 → 4 billets, reste 15.
4. Accès : demandez un âge ; moins de 13 ans « trop jeune », 13 à 17 « avec un adulte », 18 et plus « bienvenue ». Critère : trois exécutions, trois messages.

Tips agent : collez vos quatre programmes à l'agent : « relis-les comme un prof, note-les sur 10, dis-moi la première chose à améliorer dans chacun, ne les réécris pas ». Piège : il réécrit au lieu de corriger — interdisez-le explicitement. Preuve : ses remarques doivent citer vos lignes.

Synthèse (10 min)

Trois lignes : l'exercice le plus dur des quatre, et pourquoi. Refaites « Billets » sans regarder.

Jour 14 — Bilan du module 1

Objectif : prouver les acquis du module par un programme complet écrit seul, et préparer le module 2.

Théorie (20 min)

Un dernier outil de présentation avant le bilan : les commentaires. Tout ce qui suit un # sur une ligne est ignoré par Python — c'est écrit pour les humains, pas pour la machine :

# Entrées : le prix et la quantité
prix = float(input("Prix ? "))  # float car il peut y avoir des centimes

Un bon commentaire explique le pourquoi, pas le quoi — le code dit déjà ce qu'il fait. # on ajoute 1 au-dessus de x = x + 1 est du bruit ; # la numérotation des pages commence à 0 est une information. Vos programmes du module 4 seront relus dans trois semaines (par vous) : ménagez-vous.

Et le réflexe qui change tout à partir de maintenant : écrire par petits pas. N'écrivez jamais 30 lignes d'un coup. Écrivez 4 lignes, lancez, voyez qu'elles marchent, continuez. Un programme qui plante après 4 lignes nouvelles a son bug dans ces 4 lignes.

Pratique (30 min)

Le programme bilan, à écrire seul, sans copier les séances : soiree.py, un estimateur de budget de soirée.

1. Demandez : le nombre d'invités, le budget boissons total, le budget nourriture total.
2. Calculez : le budget total, le coût par invité.
3. Décidez : si le coût par invité dépasse 25 €, affichez « Budget serré : prévois moins d'invités ou plus de sous » ; entre 10 et 25 €, « Budget confortable » ; sous 10 €, « Budget royal ».
4. Affichez le tout en f-strings avec deux décimales, et commentez les trois temps (entrées / calculs / sortie) avec des #.

Critère de réussite : avec 8 invités, 60 € de boissons et 140 € de nourriture, le programme affiche un total de 200.00 €, un coût par invité de 25.00 € et « Budget confortable » (25 n'est pas strictement au-dessus de 25 — choisissez vos comparaisons en conséquence, c'est fait exprès). Si vous avez écrit le programme sans rien recopier, le module 1 est acquis.

Tips agent : tenté de le faire écrire par un agent ? C'est précisément le jour où il ne faut pas. Demandez-lui plutôt ensuite : « voici mon programme et mes trois jeux de test, trouve un cas qui fait dire une bêtise à mon code ». Piège : il en invente parfois un qui n'en est pas — relancez le cas vous-même. Preuve : un jeu d'entrées + la sortie constatée.

Synthèse (10 min)

Trois lignes : à quoi sert un commentaire, la règle des petits pas, et le point du bilan qui vous a résisté. Demain : les boucles, ou comment faire répéter la machine sans se répéter soi-même.