Programmation Orientée Objet (POO)

I. Introduction à la POO

La programmation orientée objet est un paradigme de programmation qui permet de modéliser des objets du monde réel à l’aide de classes et d’objets.

Pourquoi l’utiliser ?

• Pour mieux organiser le code (surtout quand il est complexe).

• Pour réutiliser du code facilement (héritage, méthodes communes…).

• Pour structurer les données et leurs comportements dans une seule entité : l’objet.

II. Classe et Objet

1. Classe

Une classe est un modèle qui définit :

• Les attributs (les données d’un objet),

• Les méthodes (les actions qu’il peut effectuer).

Exemple : une classe Chien peut avoir un nom, une race, une méthode aboyer().

class Chien:
    def __init__(self, nom, race):
        self.nom = nom
        self.race = race

2. Objet

Un objet est une instance concrète de la classe.

rex = Chien("Rex", "Labrador")
print(rex.nom)   # Affiche : Rex

III. Attributs et Méthodes

1. Les attributs

Ce sont les données propres à chaque objet.

Ils sont généralement définis dans la méthode __init__.

self.nom = nom

Chaque objet a ses propres valeurs d’attributs.

2. Les méthodes

Ce sont des fonctions internes à une classe.

Elles prennent toujours self comme premier paramètre, pour accéder à l’objet.

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

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

Appel :

rex.aboyer()  # Rex aboie !

IV. Le mot-clé self

self représente l’instance courante de l’objet.

Exemple : self.nom désigne l’attribut nom de cet objet précis.

Toutes les méthodes d’une classe doivent avoir self en premier paramètre, même si on ne l’utilise pas explicitement.

V. Les méthodes spéciales

Les méthodes spéciales sont des méthodes encadrées par __ (double underscore) utilisées automatiquement par Python.

1. __init__(self, ...) – Le constructeur

Appelée automatiquement lors de la création d’un objet. Elle initialise les attributs.

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

2. __str__(self) – Représentation lisible

Définit la représentation "humaine" de l’objet, quand on fait print(objet).

def __str__(self):
    return f"Chien nommé {self.nom}"

print(rex)  # Affiche : Chien nommé Rex

3. __repr__(self) – Représentation technique (débogage)

Utilisée par repr(objet) ou dans la console.

Elle est censée retourner une chaîne claire et non ambiguë permettant de recréer l’objet si possible.

def __repr__(self):
    return f"Chien('{self.nom}', '{self.race}')"

4. __eq__(self, other) – Comparaison d’égalité

Permet d’utiliser == entre deux objets.

def __eq__(self, other):
    return self.nom == other.nom and self.race == other.race

c1 = Chien("Rex", "Labrador")
c2 = Chien("Rex", "Labrador")

print(c1 == c2)  # True, grâce à __eq__

5. Autres méthodes utiles (non exigées mais utiles)

Ces méthodes peuvent servir à trier, comparer ou filtrer des objets.

VI. Encapsulation (protection des données)

Python ne permet pas de rendre un attribut privé au sens strict, mais on utilise les conventions suivantes :

• _nom : signifie "usage interne" (pas destiné à être modifié directement).

• __nom : active le name mangling (le nom est renommé en interne), utile pour éviter les collisions en héritage.

On peut aussi créer des méthodes d’accès (getters/setters) :

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

    def get_solde(self):
        return self._solde

    def set_solde(self, montant):
        if montant >= 0:
            self._solde = montant

VII. Héritage

Une classe peut hériter d’une autre : elle récupère ses attributs et méthodes.

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

    def parler(self):
        print("L’animal fait un bruit.")

class Chat(Animal):
    def parler(self):
        print("Le chat miaule.")

Appel :

c = Chat("Miaou")
c.parler()  # Le chat miaule.

La méthode parler de la classe Chat redéfinit celle de Animal.

VIII. Fonctions utiles

isinstance(obj, Classe)

→ Vérifie si obj est une instance d’une classe (ou d’une classe qui en hérite).

isinstance(c, Animal)  # True

type(obj)

→ Donne le type exact d’un objet.

IX. Exemple complet et commenté

class Etudiant:
    def __init__(self, nom, note):
        self.nom = nom
        self.note = note

    def __str__(self):
        return f"{self.nom} a obtenu {self.note}/20"

    def __eq__(self, other):
        return self.nom == other.nom and self.note == other.note

    def reussite(self):
        return self.note >= 10

Utilisation :

e1 = Etudiant("Alice", 14)
e2 = Etudiant("Bob", 8)
e3 = Etudiant("Alice", 14)

print(e1)            # Alice a obtenu 14/20
print(e1.reussite()) # True
print(e1 == e3)      # True
print(e1 == e2)      # False