Introduction à la Programmation Orientée Objet en Python

La Transition du Procédural vers l'Orienté Objet

Pour comprendre l'intérêt de la POO, comparons les approches procédurale et orientée objet dans un exemple concret : la gestion d'un compte bancaire.

Approche Procédurale

En programmation procédurale, nous utilisons des fonctions qui opèrent sur des données séparées :


# Procedural approach
# Bank account management
balance = 0

def deposit(amount):
    global balance
    if amount > 0:
        balance += amount
        return True
    return False

def withdraw(amount):
    global balance
    if amount > 0 and balance >= amount:
        balance -= amount
        return True
    return False

# Using the functions
deposit(100)
withdraw(30)
print(f"Balance: {balance}")

Approche Orientée Objet

En POO, nous encapsulons les données et les comportements dans une classe :


# Object-Oriented approach
class BankAccount:
    def __init__(self):
        self.__balance = 0

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False

    def withdraw(self, amount):
        if amount > 0 and self.__balance >= amount:
            self.__balance -= amount
            return True
        return False

    def get_balance(self):
        return self.__balance

# Using the class
account = BankAccount()
account.deposit(100)
account.withdraw(30)
print(f"Balance: {account.get_balance()}")

Avantages de l'Approche Orientée Objet

Encapsulation : Les données (balance) sont protégées et accessibles uniquement via des méthodes contrôlées
Réutilisabilité : Création facile de multiples comptes bancaires indépendants
Maintenance : Code plus organisé et plus facile à modifier
Extensibilité : Facilité d'ajout de nouvelles fonctionnalités via l'héritage

1. Objets : Les Briques de Base

Un objet est une unité qui combine des données (attributs) et des comportements (méthodes). Dans le monde réel, pensez à une voiture : elle a des attributs (couleur, marque) et des comportements (démarrer, accélérer).


# Exemple simple d'un objet voiture
my_car = Car("red", "Toyota")
my_car.start()
my_car.accelerate()

2. Classes : Le Plan de Construction

Une classe est un modèle pour créer des objets. Elle définit la structure et le comportement que les objets de ce type auront.


class Car:
    def __init__(self, color, brand):
        self.color = color
        self.brand = brand

    def start(self):
        print(f"The {self.brand} starts")

    def accelerate(self):
        print("Vrooom!")

3. Encapsulation : Protection des Données

L'encapsulation consiste à regrouper les données et les méthodes qui les manipulent, tout en contrôlant l'accès à ces données.


class BankAccount:
    def __init__(self):
        self.__balance = 0  # Private attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):
        return self.__balance

4. Héritage : Réutilisation et Extension

L'héritage permet à une classe d'hériter des attributs et méthodes d'une autre classe, facilitant la réutilisation du code.


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

    def speak(self):
        pass

class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"

5. Polymorphisme : Flexibilité des Formes

Le polymorphisme permet à différentes classes d'avoir des méthodes de même nom mais avec des comportements différents.


def make_speak(animal):
    print(animal.speak())

cat = Cat("Kitty")
dog = Dog("Rex")

make_speak(cat)   # Output: Kitty says meow!
make_speak(dog)  # Output: Rex says woof!

6. Abstraction : Simplification de la Complexité

L'abstraction permet de cacher les détails complexes et de montrer uniquement les fonctionnalités essentielles.


from abc import ABC, abstractmethod

class GeometricShape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass

class Rectangle(GeometricShape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

Points Clés à Retenir

Les objets combinent données et comportements
Les classes sont des modèles pour créer des objets
L'encapsulation protège les données
L'héritage permet la réutilisation du code
Le polymorphisme offre de la flexibilité
L'abstraction simplifie la complexité

Prochaines Étapes

Approfondissement des concepts OOP
Design Patterns en Python
Projets pratiques

That's all folks