Programmation
orientée objet.

• Définir une classe et créer des objets.
• Modéliser un capteur, un vecteur, un robot, un simulateur.
• Utiliser l’héritage pour partager du code entre classes proches.
• Comprendre enfin ce que sont liste.append() et "abc".upper().

Quand vous écrivez r1.avancer(10), Python passe automatiquement r1 comme premier argument : c’est self. Dans la méthode, self.x est « le x de cet objet ». Sans self., x serait une variable locale qui disparaît à la fin de la méthode. Oublier self dans la liste des paramètres est l’erreur n°1 de cette séance (TypeError: avancer() takes 1 positional argument but 2 were given).

En Python, chaque valeur est un objet : entier, chaîne, liste, fonction, module, classe. Le point . donne accès à ses attributs et méthodes. Écrire une classe, c’est ajouter un nouveau type à Python, avec ses propres méthodes. Rien de magique : list est une classe comme Robot, simplement écrite en C.

print(temp) afficherait <__main__.Capteur object at 0x7f…> : inutile. Définir __repr__ rend le débogage agréable ; convention : une chaîne qui ressemble au code pour recréer l’objet. Les méthodes entourées de doubles tirets bas (« dunder ») sont appelées par Python lui-même dans des situations précises : __init__ à la création, __repr__ à l’affichage, __len__ par len(), __eq__ par ==…

Là, on avait des tuples et des fonctions ajouter(u, v). Ici, u + v. Le code qui utilise des vecteurs devient lisible comme des maths. C’est exactement ainsi que NumPy (séance 19) rend a + b possible sur des tableaux. Notez que les méthodes renvoient de nouveaux vecteurs sans modifier self : un vecteur immuable évite les surprises de la séance 06.

Un robot a des capteurs et des moteurs : on les crée dans __init__ et on y accède par self.distance, self.gauche. Chaque classe est petite, testable seule, et remplaçable : pour passer au vrai robot, on réécrit Capteur.lire et Moteur.regler pour parler au matériel, sans toucher à Robot.cycle. Cette séparation est le principe de conception le plus important en robotique : la logique ne dépend pas du matériel.

Quand une classe est un cas particulier d’une autre (un capteur de distance est un capteur). La classe fille récupère tout de la mère et peut redéfinir ce qui diffère (lire). super() désigne la classe mère. L’intérêt : du code qui traite des Capteur en général (une boucle sur capteurs) fonctionne avec tous les types, y compris ceux inventés plus tard. C’est le polymorphisme. Règle de prudence : préférez la composition (« a un ») à l’héritage (« est un ») en cas de doute ; les hiérarchies profondes sont un piège classique.

Trois classes, chacune avec une responsabilité : la physique, la décision, l’orchestration. Pour tester un autre contrôleur, on écrit une classe avec une méthode commande(mobile) et rien d’autre ne change. Pour un mobile en 2D, on change Mobile. Pour enregistrer les résultats dans un fichier, Simulation. Comparez avec les lambda et variables globales de la séance 15 : c’était plus court, mais impossible à faire grandir.

Un attribut de classe sert aux constantes et compteurs partagés. Le préfixe _ signale « ne pas toucher de l’extérieur » (Python ne l’interdit pas, la convention suffit). @property transforme une méthode en attribut calculé. @dataclass écrit pour vous le __init__ et le __repr__ d’une classe qui ne fait que porter des données : utilisez-le systématiquement pour ce cas. Le @ est un décorateur : une fonction qui modifie une fonction ou une classe. On en verra d’autres en séance 17.

class Pile:
    def __init__(self):
        self._elements = []
    def empiler(self, x):
        self._elements.append(x)
    def depiler(self):
        if not self._elements:
            raise IndexError("pile vide")
        return self._elements.pop()
    def sommet(self):
        return self._elements[-1] if self._elements else None
    def __len__(self):
        return len(self._elements)          # rend aussi bool(pile) correct
    def __repr__(self):
        return f"Pile({self._elements})"

Une pile ne permet d’accéder qu’au dernier élément ajouté (LIFO). C’est la structure de la pile d’appels (séance 12) et du bouton « annuler ». Séance 18 pour son usage dans les algorithmes.

class Vehicule:
    def __init__(self, nom, vitesse_max):
        self.nom, self.vitesse_max, self.x = nom, vitesse_max, 0.0
    def vitesse(self):
        return self.vitesse_max
    def avancer(self, dt):
        self.x += self.vitesse() * dt
    def __repr__(self):
        return f"{type(self).__name__}({self.nom}, x={self.x:.1f})"

class Rover(Vehicule):
    def __init__(self, nom, vitesse_max, terrain="dur"):
        super().__init__(nom, vitesse_max); self.terrain = terrain
    def vitesse(self):
        return self.vitesse_max / 2 if self.terrain == "sable" else self.vitesse_max

class Drone(Vehicule):
    def __init__(self, nom, vitesse_max):
        super().__init__(nom, vitesse_max); self.altitude = 0
    def decoller(self): self.altitude = 10
    def atterrir(self): self.altitude = 0
    def vitesse(self):
        return self.vitesse_max if self.altitude > 0 else 0

class Bateau(Vehicule):
    def __init__(self, nom, vitesse_max, courant=0.3):
        super().__init__(nom, vitesse_max); self.courant = courant
    def avancer(self, dt):
        super().avancer(dt)
        self.x += self.courant * dt

flotte = [Rover("R1", 2), Rover("R2", 2, "sable"), Drone("D1", 5), Bateau("B1", 1.5)]
flotte[2].decoller()
for _ in range(10):
    for v in flotte:
        v.avancer(1)
print(flotte)
print("Le plus loin :", max(flotte, key=lambda v: v.x))

La boucle for v in flotte: v.avancer(1) ne sait pas quel type de véhicule elle manipule : chaque objet applique sa propre version. C’est le polymorphisme, et c’est ce qui permet d’ajouter un sous-marin demain sans toucher à la boucle. Remarquez la méthode vitesse() introduite dans la classe mère pour que les filles n’aient qu’à la redéfinir.

class Fraction:
    def __init__(self, num, den=1):
        if den == 0:
            raise ZeroDivisionError("dénominateur nul")
        if den < 0:
            num, den = -num, -den
        g = gcd(num, den)
        self.num, self.den = num // g, den // g

    @staticmethod
    def _conv(x):
        return x if isinstance(x, Fraction) else Fraction(x)

    def __repr__(self):
        return f"{self.num}" if self.den == 1 else f"{self.num}/{self.den}"
    def __add__(self, o):
        o = Fraction._conv(o); return Fraction(self.num * o.den + o.num * self.den, self.den * o.den)
    def __sub__(self, o):
        o = Fraction._conv(o); return Fraction(self.num * o.den - o.num * self.den, self.den * o.den)
    def __mul__(self, o):
        o = Fraction._conv(o); return Fraction(self.num * o.num, self.den * o.den)
    def __truediv__(self, o):
        o = Fraction._conv(o); return Fraction(self.num * o.den, self.den * o.num)
    __radd__ = __add__
    __rmul__ = __mul__
    def __rsub__(self, o):  return Fraction._conv(o) - self
    def __rtruediv__(self, o): return Fraction._conv(o) / self
    def __eq__(self, o):
        o = Fraction._conv(o); return (self.num, self.den) == (o.num, o.den)
    def __lt__(self, o):
        o = Fraction._conv(o); return self.num * o.den < o.num * self.den
    def __float__(self):
        return self.num / self.den

print(Fraction(1, 3) + Fraction(1, 6) == Fraction(1, 2))
h = sum((Fraction(1, k) for k in range(1, 21)), Fraction(0))
print(h, float(h))
print(Fraction(1, 10) + Fraction(2, 10) == Fraction(3, 10))
print(1 + Fraction(1, 2), Fraction(1, 2) < 1)

Grâce à la réduction dans __init__, l’égalité se teste sur les couples (num, den). __radd__ gère 1 + f : Python essaie int.__add__(1, f), échoue, puis f.__radd__(1). La somme harmonique H₂₀ = 55835135/15519504 est exacte, ce qu’aucun flottant ne peut donner. Le module standard fractions.Fraction fait tout cela (et plus) ; l’avoir écrit soi-même est le meilleur moyen de comprendre les opérateurs. Ouverture : écrire de même une classe Polynome ou Matrice2x2 — vous verrez que le produit de matrices est exactement la composition des rotations de la séance 14.