Classes et objets

Pourquoi une classe ?

Jusqu'ici, vos données et vos fonctions vivaient séparément : un dictionnaire pour le compte d'Alice d'un côté, une fonction deposer() de l'autre. Ça marche, mais dès que les objets se multiplient, on s'y perd. Une classe permet de regrouper au même endroit les données et les comportements qui vont ensemble.

L'image classique : la classe est un moule, et chaque objet créé à partir d'elle est un gâteau sorti de ce moule. Un seul moule, autant de gâteaux que vous voulez, chacun avec ses propres valeurs.

Définir une classe : class, __init__ et self

On définit une classe avec le mot-clé class. La méthode spéciale __init__ est le constructeur : Python l'appelle automatiquement à chaque création d'objet pour l'initialiser.

class Compte:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.solde = solde

# On crée deux instances DISTINCTES à partir de la même classe
c = Compte("Alice", 100)
autre = Compte("Bob", 0)

print(c.titulaire)   # Alice
print(c.solde)       # 100
print(autre.solde)   # 0

Le paramètre self représente l'objet en cours de manipulation : « mon propre titulaire », « mon propre solde », pas ceux du voisin. C'est lui qui rend chaque compte indépendant.

Attributs d'instance et méthodes

Les variables stockées sur l'objet (self.titulaire, self.solde) sont ses attributs. Les fonctions définies dans la classe sont ses méthodes : elles prennent toujours self en premier paramètre, ce qui leur donne accès à l'état de l'objet.

class Compte:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self.solde = solde

    def deposer(self, montant):
        self.solde += montant

    def afficher_solde(self):
        print(f"Solde de {self.titulaire} : {self.solde} euros")

c = Compte("Alice", 100)
c.deposer(50)
c.afficher_solde()   # Solde de Alice : 150 euros

# Bob a son propre état, indépendant
bob = Compte("Bob")
bob.afficher_solde()  # Solde de Bob : 0 euros

On appelle une méthode avec la notation pointée : c.deposer(50). Là encore, self est passé automatiquement : tu ne donnes que montant.

__str__ : un affichage lisible

Que se passe-t-il si on fait print() directement sur un objet ? Par défaut, Python affiche quelque chose d'illisible :

class Compte:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.solde = solde

c = Compte("Alice", 150)
print(c)   # <__main__.Compte object at 0x7f3a...>

Pour obtenir un affichage propre, on définit la méthode spéciale __str__. Elle doit renvoyer une chaîne, que print() utilisera automatiquement :

class Compte:
    def __init__(self, titulaire, solde):
        self.titulaire = titulaire
        self.solde = solde

    def __str__(self):
        return f"Compte de {self.titulaire} : {self.solde} euros"

c = Compte("Alice", 150)
print(c)   # Compte de Alice : 150 euros

Même principe que __init__ : c'est une méthode « magique » (encadrée de doubles soulignés) que Python appelle pour vous au bon moment, ici dès qu'on tente d'afficher l'objet ou de le convertir en texte avec str().

L'héritage : une classe qui prolonge une autre

Parfois, deux classes partagent une base commune. Un Chien est un Animal : il a un nom, il peut se présenter, ET il peut en plus aboyer. Plutôt que de tout réécrire, on fait hériter Chien de Animal.

class Animal:
    def __init__(self, nom):
        self.nom = nom

    def se_presenter(self):
        print(f"Je suis {self.nom}")

class Chien(Animal):          # Chien herite d Animal
    def __init__(self, nom, race):
        super().__init__(nom)  # le parent s occupe du nom
        self.race = race       # Chien ajoute la race

    def aboyer(self):
        print(f"{self.nom} dit : Ouaf !")

rex = Chien("Rex", "Labrador")
rex.se_presenter()  # Je suis Rex     <- methode heritee
rex.aboyer()        # Rex dit : Ouaf ! <- methode propre a Chien

class Chien(Animal): signifie « Chien prolonge Animal ». super().__init__(nom) appelle le constructeur du parent : on ne réécrit pas ce qu'il fait déjà, on l'invoque et on ajoute ce qui est spécifique au chien. Si on définit une méthode du même nom que dans le parent, elle la remplace (on parle de redéfinition).

Récap

• class Nom: définit le moule.
• __init__(self, ...) est le constructeur, appelé à chaque création d'objet.
• self désigne l'objet courant ; il est passé automatiquement, jamais à la main.
• Les attributs (self.x) sont les données ; les méthodes (fonctions avec self) sont les comportements.
• __str__(self) renvoie une chaîne lisible utilisée par print().
• class Enfant(Parent): hérite ; super().__init__(...) invoque le constructeur parent.