Niveau 05 — Fichiers, exceptions et modules

Objectif du niveau

À la fin de ce niveau, tes programmes survivent à l'arrêt : tu sais lire et écrire des fichiers texte avec with open(...), manipuler des chemins avec pathlib, et gérer l'encodage UTF-8 explicitement. Tu sais gérer les erreurs proprement avec try/except/else/finally au lieu de laisser le programme planter, et lever tes propres exceptions quand une situation est anormale. Enfin, tu sais découper un projet en plusieurs fichiers .py (modules), les importer les uns dans les autres, et organiser un petit projet multi-fichiers.

Prérequis

Niveau 04 — fonctions : tout ce niveau écrit des fonctions ; les modules sont des collections de fonctions.
Niveau 03 — listes et dicts (on lit des fichiers vers des listes, on écrit des dicts vers des fichiers).
Niveau 00 — terminal : savoir où on est (pwd), notion de dossier courant — cruciale pour les chemins relatifs.
Notions clés : return, découpage en fonctions, lire un traceback (on va en lire beaucoup, volontairement).

Durée indicative et avertissement honnête

2 à 3 semaines à raison de 30–60 min par jour.

Ce niveau est moins conceptuel que la mutabilité ou le scope, mais il a deux zones de friction bien réelles. Un : les chemins — « ça marche dans VS Code mais pas dans le terminal » vient presque toujours du dossier courant, et sous Windows les \ compliquent tout (raison pour laquelle on utilise pathlib dès le départ). Deux : le réflexe try/except — la syntaxe est facile, mais savoir QUOI attraper, OÙ, et surtout ne pas écrire except: nu qui avale tout, demande de la pratique et un peu de recul. Les imports, eux, sont simples tant qu'on respecte la règle « lancer le programme depuis la racine du projet ».

Leçons prévues

Chaque leçon suivra le template 17 sections (lessons/TEMPLATE_LECON.md).

N°	Titre	Notions couvertes	Statut
05-1	Lire et écrire des fichiers	`open`, modes `r`/`w`/`a`, `read`/`readlines`, itérer sur les lignes, `write`, `with` (et pourquoi c'est obligatoire ici), `strip` des `\n`, encodage `utf-8` explicite	✅
05-2	Chemins avec `pathlib`	`Path`, chemins relatifs vs absolus, le dossier courant, `/` pour joindre, `exists`, `mkdir`, `glob`, `read_text`/`write_text`, pièges Windows (`\`, encodage)	✅
05-3	Exceptions — `try/except/else/finally`	Anatomie d'une exception, attraper une exception précise, plusieurs `except`, `else` et `finally`, `raise` et `ValueError` maison, pourquoi `except:` nu est interdit, valider `input()` proprement	✅
05-4	Modules et projet multi-fichiers	`import`, `from ... import`, ses propres modules, `if __name__ == "__main__":`, organiser un petit projet (un module par responsabilité), lancer depuis la racine, `ModuleNotFoundError`	✅

Pièges et erreurs emblématiques du niveau

Mode "w" qui écrase : ouvrir en écriture VIDE le fichier immédiatement, même si on n'écrit rien ensuite. Perte de données classique — "a" pour ajouter.
FileNotFoundError alors que « le fichier est là » : le chemin relatif part du dossier courant du terminal, pas du dossier du script. LE piège chemins.
Oublier encoding="utf-8" : accents cassés ou UnicodeDecodeError sous Windows (encodage par défaut différent). On le met TOUJOURS.
except: nu : attrape tout, y compris les vraies erreurs de code et Ctrl+C — le bug est masqué au lieu d'être corrigé. Toujours nommer l'exception.
try géant autour de 30 lignes : impossible de savoir quelle ligne a levé quoi. Le try doit entourer le strict minimum.
Import circulaire ou ModuleNotFoundError : deux modules qui s'importent mutuellement, ou un script lancé depuis le mauvais dossier.

Mini-projets du niveau

Fiches détaillées dans /projects.

Journal de bord persistant — ajouter des entrées horodatées dans un fichier texte, les relire, chercher un mot (with, append, pathlib).
Liste de courses sauvegardée — reprendre le projet du niveau 03 et le faire survivre au redémarrage (charger/sauver dans un fichier, gérer le fichier absent au premier lancement).
Nettoyeur de fichier — lire un fichier « sale » (lignes vides, espaces), écrire une version propre, avec gestion d'erreurs complète.

Critères de sortie

Je sais lire un fichier ligne par ligne et écrire dans un fichier, avec with et encoding="utf-8", sans modèle.
Je sais expliquer la différence entre les modes r, w et a, et lequel détruit les données.
Je sais construire un chemin avec pathlib.Path et expliquer pourquoi un chemin relatif « marche ici mais pas là ».
Je sais attraper une exception précise avec try/except et je sais pourquoi except: nu est une faute.
Je sais lever une ValueError avec un message clair quand une entrée est invalide.
Je sais découper un programme en deux ou trois modules et les importer correctement.
Je sais expliquer à quoi sert if __name__ == "__main__": et où le mettre.
Je sais diagnostiquer un FileNotFoundError et un ModuleNotFoundError en moins de cinq minutes.

Commit de fin de niveau

git add lessons/level-05-fichiers-exceptions-modules
git commit -m "exercises: complete level 05 (files, exceptions, modules)"