Programmation orientée objet, pour de vrai.

• Modéliser un système (robot, jeu, simulation) en classes aux responsabilités claires.
• Choisir entre héritage et composition, et justifier.
• Écrire une hiérarchie abstraite avec abc et un polymorphisme sans if type(x) == ….
• Reconnaître et appliquer cinq patrons de conception.

Références : Design Patterns (Gamma et al.), Fluent Python (Ramalho), cours MIT 6.0001, freeCodeCamp « Object Oriented Programming ».

Si tout le programme peut écrire batterie._charge = -50, il faut vérifier la validité partout. Si seule la classe peut l’écrire, on vérifie une fois, dans le setter. L’invariant « 0 ≤ charge ≤ max » est garanti par construction. Python ne force rien (pas de private comme en Java/C++), mais la convention _nom est respectée par tous, et @property permet de commencer avec un attribut simple et d’ajouter une validation plus tard sans changer l’interface. Un double underscore __nom déclenche le « name mangling » (_Batterie__nom) : à réserver pour éviter les collisions dans les hiérarchies.

Sans lui, on écrirait if isinstance(f, Rectangle): … elif isinstance(f, Disque): … partout où on manipule des formes, et il faudrait modifier tous ces if à chaque nouvelle forme. Avec lui, ajouter Triangle = écrire une classe, point. C’est le principe ouvert/fermé : ouvert à l’extension, fermé à la modification. Le MRO (method resolution order) est l’ordre dans lequel Python cherche une méthode : Carre → Rectangle → Forme → object.

C’est ainsi que NumPy fait a @ b, que pathlib fait Path("a") / "b", et que PyTorch rend tenseur.backward() possible. Une classe bien écrite se comporte comme un type natif.

• dataclass : un objet qui est surtout des données (mesure, point, configuration). Génère __init__, __repr__, __eq__, et order=True les comparaisons ; frozen=True le rend hashable et immuable.
• Gestionnaire de contexte (with) : tout ce qui s’ouvre et doit se fermer — fichier, port série, verrou, chronomètre, connexion. Garantit la fermeture même en cas d’exception.
• Itérateur : un objet qu’on peut parcourir. __iter__ renvoyant un générateur est la façon la plus simple.
• NamedTuple (typing.NamedTuple) : un tuple avec des noms, encore plus léger qu’une dataclass gelée.

Héritez quand la relation est « est un » et que la sous-classe peut remplacer la classe mère partout (principe de substitution de Liskov). Composez quand la relation est « a un » ou « utilise un ». L’héritage crée un couplage fort : changer la mère change toutes les filles. La composition permet d’assembler et de remplacer des pièces — comme un vrai robot. Le célèbre contre-exemple : class Carre(Rectangle) avec des setters de largeur et hauteur indépendants viole Liskov (fixer la largeur d’un carré change sa hauteur : une fonction écrite pour Rectangle se trompera).

Les interfaces graphiques (bouton.on_click(...)), le JavaScript (addEventListener), ROS (un topic auquel des nœuds s’abonnent), Qt (signaux/slots), les interruptions matérielles (module L18). L’émetteur ne sait pas qui écoute : c’est ce découplage qui permet d’ajouter un enregistreur, un affichage, un freinage d’urgence sans modifier le capteur.

• Single responsibility : une classe, une raison de changer.
• Open/closed : étendre sans modifier (polymorphisme, registre).
• Liskov : une sous-classe doit pouvoir remplacer sa mère partout.
• Interface segregation : plusieurs petites interfaces valent mieux qu’une grosse.
• Dependency inversion : dépendre d’abstractions (Capteur), pas d’implémentations (Ultrason) ; injecter les dépendances.

Ces principes ne sont pas des lois : ce sont des heuristiques qui rendent le code facile à changer. Le test ultime : « si le client demande X demain, combien de fichiers dois-je toucher ? »

class Duree:
    def __init__(self, secondes):
        if secondes < 0: raise ValueError("durée négative")
        self.secondes = int(secondes)
    def __add__(self, o): return Duree(self.secondes + o.secondes)
    def __lt__(self, o): return self.secondes < o.secondes
    def __eq__(self, o): return isinstance(o, Duree) and self.secondes == o.secondes
    def __str__(self):
        h, r = divmod(self.secondes, 3600); m, s = divmod(r, 60); return f"{h}:{m:02d}:{s:02d}"
    @classmethod
    def depuis_texte(cls, t):
        h, m, s = map(int, t.split(":")); return cls(3600 * h + 60 * m + s)

class Message(ABC):
    @abstractmethod
    def resume(self) -> str: ...
class Position(Message):
    def __init__(self, x, y): self.x, self.y = x, y
    def resume(self): return f"pos({self.x}, {self.y})"
class Batterie(Message):
    def __init__(self, p): self.p = p
    def resume(self): return f"batt {self.p}%"
class Alerte(Message):
    def __init__(self, t): self.t = t
    def resume(self): return f"ALERTE {self.t}"
def rapport(messages): return " | ".join(m.resume() for m in messages)

    def abonner(self, cb):
        self._abonnes.append(cb)
        def desabonner():
            if cb in self._abonnes: self._abonnes.remove(cb)
        return desabonner
    def emettre(self, *args):
        for cb in list(self._abonnes):
            try: cb(*args)
            except Exception: self.erreurs += 1

def forme(nom):
    def enregistrer(cls): REGISTRE[nom] = cls; return cls
    return enregistrer
def creer(description):
    d = dict(description); t = d.pop("type")
    if t not in REGISTRE: raise KeyError(t)
    return REGISTRE[t](**d)

class Compte(ABC):
    def __init__(self, titulaire, solde=0.0):
        self.titulaire, self._solde = titulaire, float(solde)
    @property
    def solde(self): return self._solde
    def deposer(self, m):
        if m <= 0: raise ValueError("montant positif attendu")
        self._solde += m
    @abstractmethod
    def retirer(self, m) -> bool: ...
    def __repr__(self): return f"{type(self).__name__}({self.titulaire}, {self._solde:.2f})"

class CompteCourant(Compte):
    DECOUVERT = -500
    def retirer(self, m):
        if self._solde - m < self.DECOUVERT: return False
        self._solde -= m; return True

class Livret(Compte):
    def retirer(self, m):
        if m > self._solde: return False
        self._solde -= m; return True
    def interets(self, taux): self._solde *= 1 + taux

def total(comptes): return sum(c.solde for c in comptes)

c, l = CompteCourant("Ana", 100), Livret("Ana", 1000)
assert c.retirer(550) and c.solde == -450 and not c.retirer(100)
assert not l.retirer(2000) and l.retirer(1000) and l.solde == 0
l.deposer(100); l.interets(0.03); assert abs(l.solde - 103) < 1e-9
assert total([c, l]) == -450 + 103

from dataclasses import dataclass
@dataclass
class Position: x: int; y: int
@dataclass
class Vie: points: int
@dataclass
class Attaque: degats: int
@dataclass
class Deplacement: vitesse: int

def distance(a, b):
    pa, pb = a.composants["position"], b.composants["position"]
    return abs(pa.x - pb.x) + abs(pa.y - pb.y)

def tour(entites, joueur):
    for e in entites:
        if e is joueur: continue
        if e.a("deplacement"):
            p, pj = e.composants["position"], joueur.composants["position"]
            v = e.composants["deplacement"].vitesse
            p.x += max(-v, min(v, pj.x - p.x)); p.y += max(-v, min(v, pj.y - p.y))
        if e.a("attaque") and distance(e, joueur) <= 1:
            joueur.composants["vie"].points -= e.composants["attaque"].degats
    entites[:] = [e for e in entites if not e.a("vie") or e.composants["vie"].points > 0]

joueur = Entite("joueur", position=Position(0, 0), vie=Vie(20))
monstre = Entite("monstre", position=Position(5, 0), vie=Vie(5), attaque=Attaque(2), deplacement=Deplacement(1))
tourelle = Entite("tourelle", position=Position(0, 1), attaque=Attaque(1))
entites = [joueur, monstre, tourelle]
for t in range(10):
    tour(entites, joueur)
print(joueur.composants["vie"])

C’est l’architecture Entité-Composant-Système (ECS) des moteurs de jeu (Unity, Bevy) : les données dans des composants, la logique dans des systèmes qui parcourent les entités possédant tel composant. Elle évite l’explosion des hiérarchies (« MonstreVolantQuiTire » hérite de quoi ?).

class Const(Expr):
    def __init__(self, v): self.v = v
    def evaluer(self, env): return self.v
    def derivee(self, x): return Const(0)
    def simplifier(self): return self
    def __repr__(self): return str(self.v)

class Var(Expr):
    def __init__(self, nom): self.nom = nom
    def evaluer(self, env): return env[self.nom]
    def derivee(self, x): return Const(1 if x == self.nom else 0)
    def simplifier(self): return self
    def __repr__(self): return self.nom

class Add(Expr):
    def __init__(self, a, b): self.a, self.b = a, b
    def evaluer(self, env): return self.a.evaluer(env) + self.b.evaluer(env)
    def derivee(self, x): return Add(self.a.derivee(x), self.b.derivee(x))
    def simplifier(self):
        a, b = self.a.simplifier(), self.b.simplifier()
        if isinstance(a, Const) and isinstance(b, Const): return Const(a.v + b.v)
        if isinstance(a, Const) and a.v == 0: return b
        if isinstance(b, Const) and b.v == 0: return a
        return Add(a, b)
    def __repr__(self): return f"{self.a} + {self.b}"

class Mul(Expr):
    def __init__(self, a, b): self.a, self.b = a, b
    def evaluer(self, env): return self.a.evaluer(env) * self.b.evaluer(env)
    def derivee(self, x):              # (uv)' = u'v + uv'
        return Add(Mul(self.a.derivee(x), self.b), Mul(self.a, self.b.derivee(x)))
    def simplifier(self):
        a, b = self.a.simplifier(), self.b.simplifier()
        if isinstance(a, Const) and isinstance(b, Const): return Const(a.v * b.v)
        for u, v in ((a, b), (b, a)):
            if isinstance(u, Const):
                if u.v == 0: return Const(0)
                if u.v == 1: return v
        if isinstance(a, Const) and isinstance(b, Mul) and isinstance(b.a, Const):
            return Mul(Const(a.v * b.a.v), b.b).simplifier()
        return Mul(a, b)
    def __repr__(self):
        def p(e): return f"({e})" if isinstance(e, Add) else str(e)
        return f"{p(self.a)}*{p(self.b)}"

class Pow(Expr):
    def __init__(self, a, n): self.a, self.n = a, n
    def evaluer(self, env): return self.a.evaluer(env) ** self.n
    def derivee(self, x):              # (u^n)' = n u^(n-1) u'
        return Mul(Mul(Const(self.n), Pow(self.a, self.n - 1)), self.a.derivee(x))
    def simplifier(self):
        a = self.a.simplifier()
        if self.n == 0: return Const(1)
        if self.n == 1: return a
        if isinstance(a, Const): return Const(a.v ** self.n)
        return Pow(a, self.n)
    def __repr__(self): return f"{self.a}**{self.n}"

x = Var("x")
f = 3 * x**2 + 2 * x + 1
print(f, "=", f.evaluer({"x": 2}))
print("f' =", f.derivee("x").simplifier())

Vous venez d’écrire le cœur d’un système de calcul formel (SymPy fait la même chose avec des milliers de règles) et le cœur de la différentiation automatique qui fait tourner PyTorch : un graphe d’expressions dérivé mécaniquement par la règle de la chaîne. Module L14 pour la suite.