Maîtriser la programmation orientée objet Python : classes, héritage, encapsulation et polymorphisme

Programmation orientée objet Python

Ce guide vous accompagne à travers les concepts fondamentaux de la programmation orientée objet (POO) de Python, avec des exemples pratiques illustrant comment construire du code robuste et réutilisable.

Vidéo : Programmation orientée objet en Python

Programmation orientée objet

Python est un langage multi-paradigme qui supporte plusieurs styles de programmation. L'une des approches les plus puissantes est de modéliser les problèmes en utilisant des objets — une approche connue sous le nom de programmation orientée objet (POO).

Un objet possède deux caractéristiques essentielles :

• Attributs (données)
• Comportement (méthodes)

Par exemple, un perroquet est un objet avec des attributs tels que nom, âge et couleur, et des comportements comme chanter() et danser().

La POO en Python favorise la réutilisabilité du code, adhérant au principe DRY (Don't Repeat Yourself).

Classe

Une class est un plan qui définit la structure et le comportement des objets. Considérez-la comme un esquisse détaillée d'un perroquet : elle spécifie quelles propriétés et actions un perroquet peut avoir.

class Perroquet:
    pass

Ici, Perroquet est une classe vide. Les instances de cette classe sont créées plus tard.

Objet

Un objet (ou instance) est une concrétisation d'une classe. Quand une classe est définie, aucune mémoire n'est allouée ; seul le modèle existe. L'instanciation de la classe crée l'objet.

obj = Perroquet()

Dans l'exemple ci-dessous, nous construisons une classe Perroquet fonctionnelle et créons deux instances, bleu et woo :

class Perroquet:
    # Attribut de classe
    espece = "oiseau"
    # Attributs d'instance
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
# Instancier la classe
bleu = Perroquet("Bleu", 10)
woo = Perroquet("Woo", 15)
# Accéder aux attributs de classe
print("Bleu est un {}".format(bleu.__class__.espece))
print("Woo est aussi un {}".format(woo.__class__.espece))
# Accéder aux attributs d'instance
print("{} a {} ans".format(bleu.nom, bleu.age))
print("{} a {} ans".format(woo.nom, woo.age))

Sortie

Bleu est un oiseau Woo est aussi un oiseau Bleu a 10 ans Woo a 15 ans

Dans cet extrait, espece est un attribut de classe partagé par tous les perroquets, tandis que nom et age sont des attributs d'instance uniques à chaque objet.

Méthodes

Les méthodes sont des fonctions définies dans une classe qui décrivent le comportement de l'objet. Elles sont invoquées sur des instances de la classe.

class Perroquet:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
    def chanter(self, chanson):
        return f"{self.nom} chante {chanson}"
    def danser(self):
        return f"{self.nom} danse maintenant"
# Instancier et utiliser les méthodes
bleu = Perroquet("Bleu", 10)
print(bleu.chanter("'Joyeux'"))
print(bleu.danser())

Sortie

Bleu chante 'Joyeux' Bleu danse maintenant

Héritage

L'héritage permet à une nouvelle classe d'hériter des attributs et méthodes d'une classe existante, favorisant la réutilisation de code et la hiérarchie logique.

# Classe de base
class Oiseau:
    def __init__(self):
        print("Oiseau est prêt")
    def quiEstCe(self):
        print("Oiseau")
    def nager(self):
        print("Nager plus vite")
# Classe dérivée
class Manchot(Oiseau):
    def __init__(self):
        super().__init__()
        print("Manchot est prêt")
    def quiEstCe(self):
        print("Manchot")
    def courir(self):
        print("Courir plus vite")
peggy = Manchot()
peggy.quiEstCe()
peggy.nager()
peggy.courir()

Sortie

Oiseau est prêt Manchot est prêt Manchot Nager plus vite Courir plus vite

Encapsulation

L'encapsulation restreint l'accès direct à l'état interne d'un objet, protégeant l'intégrité des données. En Python, les attributs privés sont dénotés par un underscore initial (simple ou double).

class Ordinateur:
    def __init__(self):
        self.__prix_max = 900
    def vendre(self):
        print(f"Prix de vente : {self.__prix_max}")
    def setPrixMax(self, prix):
        self.__prix_max = prix
c = Ordinateur()
c.vendre()
# Tentative de modification directe
c.__prix_max = 1000
c.vendre()
# Utiliser la méthode setter
c.setPrixMax(1000)
c.vendre()

Sortie

Prix de vente : 900 Prix de vente : 900 Prix de vente : 1000

Polymorphisme

Le polymorphisme permet aux objets de différentes classes d'être traités via une interface partagée, permettant un code flexible qui peut opérer sur divers types d'objets.

class Perroquet:
    def voler(self):
        print("Le perroquet peut voler")
    def nager(self):
        print("Le perroquet ne peut pas nager")
class Manchot:
    def voler(self):
        print("Le manchot ne peut pas voler")
    def nager(self):
        print("Le manchot peut nager")
# Interface commune
def test_vol(oiseau):
    oiseau.voler()
bleu = Perroquet()
peggy = Manchot()
test_vol(bleu)
test_vol(peggy)

Sortie

Le perroquet peut voler Le manchot ne peut pas voler

Points clés à retenir

• La POO structure le code pour la clarté et la maintenabilité.
• Les classes permettent la réutilisation du code par l'héritage.
• L'encapsulation protège les données internes.
• Le polymorphisme offre des interfaces flexibles à travers les types d'objets.