Programmation orientee objet en Python : classes, heritage, encapsulation

Classes, attributs, heritage, encapsulation, polymorphisme, dataclasses

🏛️

Classe & instance

Definir une classe- __init__ est le constructeur : appele automatiquement a la creation d'un objet. 'self' represente l'instance courante et doit etre le premier parametre de chaque methode.

class Vehicule:
    def __init__(self, marque, vitesse_max):
        self.marque = marque              # attribut d'instance
        self.vitesse_max = vitesse_max
        self.vitesse_actuelle = 0
    def accelerer(self, delta):
        self.vitesse_actuelle = min(self.vitesse_actuelle + delta, self.vitesse_max)
voiture = Vehicule("Renault", 180)   # creation d'une instance
voiture.accelerer(50)
print(voiture.vitesse_actuelle)       # 50

Attribut de classe vs attribut d'instance- Un attribut de classe est partage par toutes les instances (une seule copie en memoire). Un attribut d'instance est propre a chaque objet.

class Vehicule:
    nombre_total = 0    # attribut de CLASSE : partage par tous les vehicules
    def __init__(self, marque):
        self.marque = marque         # attribut d'INSTANCE : propre a cet objet
        Vehicule.nombre_total += 1   # incremente le compteur partage
v1 = Vehicule("Renault")
v2 = Vehicule("Peugeot")
print(Vehicule.nombre_total)   # 2

🧬

Heritage

Classe derivee- Une classe enfant herite des attributs et methodes de sa classe parente, et peut en ajouter de nouvelles.

class Voiture(Vehicule):        # Voiture herite de Vehicule
    def klaxonner(self):
        print("Tut tut !")
ma_voiture = Voiture("Renault", 180)
ma_voiture.accelerer(30)   # methode heritee de Vehicule
ma_voiture.klaxonner()     # methode propre a Voiture

Surcharge et super()- Une classe enfant peut redefinir (surcharger) une methode du parent. super() permet d'appeler quand meme la version du parent, pour ne pas dupliquer son code.

class Voiture(Vehicule):
    def __init__(self, marque, vitesse_max, nb_portes):
        super().__init__(marque, vitesse_max)   # appelle __init__ du parent
        self.nb_portes = nb_portes              # ajoute son propre attribut
ma_voiture = Voiture("Renault", 180, 5)

🔒

Encapsulation

Convention des attributs 'prives'- Python n'a pas de vrai attribut prive : un underscore signale juste 'usage interne, ne pas toucher directement' (convention, pas une interdiction technique).

class CompteBancaire:
    def __init__(self, solde_initial):
        self._solde = solde_initial   # underscore = usage interne par convention
    def deposer(self, montant):
        self._solde += montant
compte = CompteBancaire(100)
compte.deposer(50)
compte._solde   # techniquement accessible, mais deconseille

Propriete (@property)- Une @property permet de lire un attribut avec la syntaxe simple (sans parentheses) tout en executant du code de controle en coulisses (ex: interdire un solde negatif).

class CompteBancaire:
    def __init__(self, solde_initial):
        self._solde = solde_initial
    @property
    def solde(self):          # lecture : compte.solde (sans parentheses)
        return self._solde
    @solde.setter
    def solde(self, valeur):  # ecriture : compte.solde = 200
        if valeur < 0:
            raise ValueError("Le solde ne peut pas etre negatif")
        self._solde = valeur
compte = CompteBancaire(100)
compte.solde = 200    # passe par le setter, qui valide la valeur

🎭

Polymorphisme & methodes speciales

Methodes speciales courantes- Les methodes entourees de doubles underscores (__xxx__) permettent a un objet de reagir aux fonctions natives de Python (print, len, ==...).

class Vehicule:
    def __init__(self, marque):
        self.marque = marque
    def __str__(self):
        # appelee automatiquement par print()
        return f"Vehicule({self.marque})"
    def __eq__(self, autre):
        # appelee automatiquement par ==
        return self.marque == autre.marque
v = Vehicule("Renault")
print(v)                              # Vehicule(Renault) : utilise __str__
v == Vehicule("Renault")              # True : utilise __eq__

Polymorphisme- Des classes differentes peuvent implementer la meme methode chacune a leur maniere : le code appelant n'a pas besoin de savoir laquelle il manipule.

class Voiture(Vehicule):
    def deplacer(self):
        print("Roule sur la route")
class Bateau(Vehicule):
    def deplacer(self):
        print("Navigue sur l'eau")
for v in [Voiture("Renault"), Bateau("Zodiac")]:
    v.deplacer()   # chaque objet execute SA propre version de deplacer()

🧰

Methodes statiques et de classe

@staticmethod et @classmethod- @staticmethod : une methode utilitaire qui n'a pas besoin d'acceder a self ni a la classe. @classmethod recoit la classe elle-meme (cls) : souvent utilisee pour proposer un constructeur alternatif.

class Vehicule:
    def __init__(self, marque, vitesse_max):
        self.marque = marque
        self.vitesse_max = vitesse_max
    @staticmethod
    def kmh_vers_ms(vitesse_kmh):
        # ne depend d'aucune instance : simple fonction utilitaire
        return vitesse_kmh / 3.6
    @classmethod
    def voiture_standard(cls):
        # constructeur alternatif : cree un Vehicule avec des valeurs par defaut
        return cls("Generique", 130)
Vehicule.kmh_vers_ms(90)        # 25.0 (pas besoin d'instance)
v = Vehicule.voiture_standard()  # utilise le constructeur alternatif

📄

Dataclasses

Classe de donnees simplifiee- @dataclass genere automatiquement __init__, __repr__ et __eq__ a partir des attributs declares : ideal pour des classes qui ne font que stocker des donnees, sans logique complexe.

from dataclasses import dataclass
@dataclass
class Point:
    x: int
    y: int
p1 = Point(1, 2)
print(p1)          # Point(x=1, y=2) : __repr__ genere automatiquement
p1 == Point(1, 2)  # True : __eq__ genere automatiquement

Valeurs par defaut- Comme une fonction, un champ de dataclass peut avoir une valeur par defaut si elle n'est pas fournie a la creation.

@dataclass
class Point:
    x: int = 0
    y: int = 0
origine = Point()        # Point(x=0, y=0)
p = Point(x=5)           # Point(x=5, y=0)