Bases de Python

La programmation orientée objet en Python

Dans cette leçon, vous allez découvrir l'encapsulation, l'héritage, la redéfinition de méthodes et le polymorphisme à travers un exemple de compte bancaire en Python.

  • Débutant
  • 4 min de lecture
  • 1 exemple exécutable

Qu’est-ce que la programmation orientée objet en Python ?

Le problème

Quand un programme grandit, beaucoup de parties ont besoin des mêmes genres d'objets avec de petites différences : un compte normal et un compte d'épargne, un chat et un chien. Copier des classes et changer quelques lignes duplique le code, et tester le type avec if partout fait de chaque nouveau genre un gros chantier.

Imaginez-le ainsi

La programmation orientée objet fonctionne comme les comptes d'une même banque. Chaque compte garde son solde derrière le guichet (l'encapsulation). Un livret d'épargne est un compte normal avec une fonction en plus (l'héritage). Quand la banque annonce la 'fin de mois' à tous les comptes, chacun fait sa propre version (le polymorphisme).

De la banque au code
self._balance🔒 L'argent derrière le guichet : ne le modifier que via deposit()
class SavingsAccount(BankAccount):🏦 Un compte d'épargne est un compte, plus des intérêts
super().__init__(owner, balance)📋 Remplir d'abord le formulaire du compte normal
account.month_end()📅 Même demande, chaque compte répond à sa façon
Les règles communes dans la classe de base, les différences dans la sous-classe.
En une phrase

La programmation orientée objet organise un programme en classes dont les objets gardent leurs données privées (encapsulation), réutilisent d'autres classes (héritage) et répondent au même appel chacun à leur façon (polymorphisme).

La POO modélise un système comme des objets qui collaborent. Chaque objet associe un état aux opérations autorisées, ce qui clarifie les responsabilités dans une grande application.

Les quatre principes fondamentaux

  • Encapsulation : regrouper état et comportement et contrôler l’accès.
  • Abstraction : exposer une interface utile et masquer les détails inutiles.
  • Héritage : spécialiser une classe lorsqu’il existe une véritable relation « est un ».
  • Polymorphisme : appliquer la même opération à différents objets avec un comportement adapté.

Conception de l’exemple

  1. BankAccount possède le solde et valide les dépôts.
  2. SavingsAccount réutilise le contrat de la classe de base.
  3. SavingsAccount redéfinit month_end pour appliquer les intérêts.
  4. La boucle traite tous les comptes via la même interface.
Conseil : Préférez la composition lorsqu’un objet en utilise simplement un autre. Réservez l’héritage aux relations de substitution valides.

Quand l’utiliser ?

  • Plusieurs genres d'objets qui partagent l'essentiel du comportement : types de comptes, formes, personnages de jeu.
  • Un code qui devra fonctionner plus tard avec de nouveaux genres sans être réécrit.
  • Protéger des données qui doivent rester valides, comme un solde qui ne peut jamais être négatif.

Quand s'en passer

  • Les petits scripts avec quelques fonctions : classes et héritage ajoutent une structure inutile.
  • Les longues chaînes d'héritage (A de B de C de D) : elles sont difficiles à suivre ; préférez la composition.

Exemple de base

Exécuter le code →
main.py
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = float(balance)

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self._balance += amount

    def month_end(self):
        return "No interest"


class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def month_end(self):
        self._balance *= 1 + self.interest_rate
        return "Interest applied"


accounts = [
    BankAccount("Ada", 100),
    SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)

for account in accounts:
    status = account.month_end()
    print(f"{account.owner}: {account.balance:.2f} ({status})")
Obtenir un bouton Run pour cet exemple

Résultat de l’exécution

Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)

Les quatre principes de la POO en pratique

Ces exemples ciblés montrent comment Python met en œuvre l’encapsulation, l’abstraction, l’héritage et le polymorphisme dans du code courant.

Encapsulation

Exécuter le code →

regrouper état et comportement et contrôler l’accès.

encapsulation.py
class BankAccount:
    def __init__(self, balance=0):
        # Double underscores prevent accidental direct access.
        self.__balance = balance

    @property
    def balance(self):
        # Expose read access without exposing mutation.
        return self.__balance

    def deposit(self, amount):
        # Keep validation next to the state it protects.
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.__balance += amount


account = BankAccount(100)
account.deposit(50)
print(account.balance)  # 150

Abstraction

Exécuter le code →

exposer une interface utile et masquer les détails inutiles.

abstraction.py
from abc import ABC, abstractmethod


class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount):
        # Callers know what pay does, not how each provider does it.
        pass


class CreditCard(PaymentMethod):
    def pay(self, amount):
        # The concrete class hides its payment implementation.
        return f"Paid ${amount:.2f} by card"


payment = CreditCard()
print(payment.pay(25))

Héritage

Exécuter le code →

spécialiser une classe lorsqu’il existe une véritable relation « est un ».

inheritance.py
class Employee:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return self.name


class Developer(Employee):
    def __init__(self, name, language):
        # Reuse initialization from the parent class.
        super().__init__(name)
        self.language = language

    def describe(self):
        # Extend inherited behavior instead of duplicating it.
        return f"{super().describe()} writes {self.language}"


print(Developer("Ada", "Python").describe())

Polymorphisme

Exécuter le code →

appliquer la même opération à différents objets avec un comportement adapté.

polymorphism.py
class EmailNotification:
    def send(self, message):
        return f"Email: {message}"


class SmsNotification:
    def send(self, message):
        return f"SMS: {message}"


def notify(channels, message):
    for channel in channels:
        # The same call selects behavior from each concrete object.
        print(channel.send(message))


channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")

Explication du code

La classe BankAccount encapsule le solde dans l'attribut _balance et n'autorise sa modification qu'au travers de méthodes contrôlées comme deposit(). La classe SavingsAccount hérite de toutes ces méthodes et redéfinit month_end() pour ajouter les intérêts. La boucle appelle la même méthode sur les deux comptes, mais Python choisit à l'exécution la version adaptée à chaque type d'objet. C'est cela, le polymorphisme.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices d’approfondissement

Essayez de modifier le code en suivant les pistes ci-dessous. Changer le code et observer le résultat vous fera bien mieux comprendre la leçon que la simple lecture.

  1. Changez les données d’entrée et prévoyez le résultat avant d’exécuter.
  2. Ajoutez une vérification pour les données vides ou invalides.
  3. Placez le traitement dans une fonction séparée et testez-la avec plusieurs jeux de données.
Exécuter dans le compilateur Python →

Erreurs fréquentes

Oublier d'appeler super().__init__

Sans lui, l'initialisation du parent ne s'exécute jamais et des attributs comme owner manquent.

Problème
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
Correction
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        super().__init__(owner, balance)
        self.interest_rate = rate

Modifier directement des données protégées

Fixer _balance de l'extérieur contourne les vérifications de deposit().

Problème
account._balance = -500
Correction
account.deposit(50)

Leçon terminée ?

Marquez-la comme apprise pour suivre votre progression.

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis