Niveau 06 — Programmation orientée objet

Objectif du niveau

À la fin de ce niveau, tu sais créer tes propres types de données : définir une classe avec class, initialiser ses objets avec __init__, leur donner des attributs et des méthodes, et les afficher proprement avec __str__. Tu sais faire collaborer des objets par composition (un objet qui en contient d'autres), protéger un minimum leurs données, et — tout aussi important — tu sais reconnaître les cas où la POO n'apporte rien et où des fonctions et des dicts suffisent.

Prérequis

Niveau 04 — fonctions : paramètres, return, scope. Une méthode est une fonction — tout le niveau 04 doit être solide.
Niveau 03 — mutabilité : un objet est mutable ; deux variables peuvent pointer vers le même objet. Sans 03-4 bien compris, self sera incompréhensible.
Niveau 05 — modules : on rangera les classes dans leurs propres fichiers.
Notions clés : mutabilité et références (03-4), return vs print, découpage en responsabilités (04-5).

Durée indicative et avertissement honnête

2 semaines minimum — prévois-les vraiment, et ne t'étonne pas si c'est trois.

Disons-le sans détour : self est LA difficulté n°1 de tout l'apprentissage de Python. Pourquoi ce premier paramètre partout ? Pourquoi on ne le passe pas à l'appel ? Pourquoi self.x et pas x ? Presque tous les débutants passent par une phase où « ça compile mais je ne comprends pas ce que je fais ». C'est normal, c'est documenté, et le plan du niveau le prévoit : la leçon 06-2 est entièrement consacrée à self et aux erreurs qu'il provoque, et les leçons suivantes le re-travaillent. Le déclic vient par la pratique répétée, pas par la relecture de la théorie. Si au bout de la leçon 06-2 c'est encore flou, continue quand même : 06-3 et 06-4 sont conçues pour faire mûrir la notion.

Leçons prévues

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

N°	Titre	Notions couvertes	Statut
06-1	Pourquoi des classes	Le problème : des dicts + fonctions qui se baladent ensemble ; classe = données + comportement ; classe vs objet (instance) ; premier `class`, premier objet ; vocabulaire (attribut, méthode, instance)	✅
06-2	`__init__` et `self` ⚠️ LA difficulté n°1	`__init__`, `self` expliqué trois fois de trois façons (schéma mémoire, sucre syntaxique `Classe.methode(obj)`, analogie), attributs d'instance, erreurs `self` typiques (`missing 1 required positional argument`, oubli de `self.`)	✅
06-3	Attributs et méthodes	Attributs vs variables locales des méthodes, méthodes qui lisent/modifient l'état, méthodes qui s'appellent entre elles, `__str__` pour un affichage propre, attributs de classe (rapidement, pour lire du code)	✅
06-4	Encapsulation simple et composition	Convention `_prive`, valider dans les méthodes plutôt que toucher les attributs partout, composition : un objet qui contient une liste d'objets (ex. `Bibliotheque` contient des `Livre`), faire dialoguer les objets	✅
06-5	Quand NE PAS faire de POO	Signes qu'une classe est inutile (pas d'état, une seule méthode, `__init__` + un getter), classe vs dict vs fonctions : critères de choix, relecture critique de code sur-objet, refactor dans les deux sens	✅

Pièges et erreurs emblématiques du niveau

Oublier self dans la signature : def avancer(): puis TypeError: avancer() takes 0 positional arguments but 1 was given — le message le plus déroutant du niveau, décodé en détail en 06-2.
Oublier self. devant un attribut : nom = nom dans __init__ crée une variable locale qui disparaît ; l'objet n'a pas d'attribut. Bug silencieux jusqu'au AttributeError plus loin.
Confondre la classe et l'instance : appeler Chien.aboyer() au lieu de mon_chien.aboyer(), ou modifier un attribut de classe en croyant modifier une instance.
Oublier les parenthèses à l'instanciation : c = Chien au lieu de c = Chien("Rex") — c est la classe elle-même, sans erreur immédiate.
Attribut de classe mutable partagé : une liste définie au niveau de la classe est partagée par TOUTES les instances — retour direct de la mutabilité du niveau 03.
La classe fourre-tout : tout mettre dans une classe « parce qu'il faut de la POO ». La leçon 06-5 existe précisément contre ce réflexe.

Mini-projets du niveau

Fiches détaillées dans /projects.

Compte bancaire — classe Account : dépôt, retrait avec validation, historique des opérations, __str__ lisible.
Bibliothèque — composition : Library contient des Book, emprunt/retour, recherche par titre, état persistant optionnel (niveau 05).
Personnage de jeu — Character avec points de vie, inventaire (liste d'objets), combat simplifié entre deux instances.

Critères de sortie

Je sais écrire une classe avec __init__, deux attributs et deux méthodes, sans modèle.
Je sais expliquer ce qu'est self à quelqu'un d'autre, avec un schéma.
Je sais diagnostiquer takes 0 positional arguments but 1 was given et AttributeError en moins de cinq minutes.
Je sais faire la différence entre un attribut d'instance (self.x) et une variable locale de méthode.
Je sais écrire un __str__ et expliquer quand il est appelé.
Je sais construire une composition : une classe qui gère une liste d'objets d'une autre classe.
Je sais valider les données dans les méthodes au lieu de modifier les attributs de partout.
Devant un problème, je sais dire si une classe se justifie ou si fonctions + dict suffisent — et justifier.

Commit de fin de niveau

git add lessons/level-06-poo
git commit -m "exercises: complete level 06 (object-oriented programming)"