Au fur et à mesure qu’un script grandit, vous finissez par transmettre le même groupe de variables entre les fonctions, et il devient difficile de savoir quelles données appartiennent à quelle logique. Les classes et objets Python résolvent ce problème en regroupant les données et le comportement en une seule unité.

Dans ce didacticiel, nous construisons un petit compte bancaire étape par étape et ajoutons chaque idée de POO uniquement lorsqu’elle résout un problème. Nous avons exécuté chaque exemple sur Python 3.13 et le résultat affiché provient de cette exécution. Si vous êtes nouveau dans le langage, lisez d’abord notre Tutoriel Python pour débutants.

Que sont les classes et les objets ?

Une classe décrit ce qu’est quelque chose et ce qu’il peut faire. Un objet, également appelé instance, est un objet spécifique créé à partir de cette description. « Compte » est une classe, tandis que le compte d’Asha et le compte de Ben sont deux objets.

Vous utilisez des objets depuis le début. En Python, les chaînes, les listes et même les fonctions sont des objets, c’est pourquoi vous pouvez écrire "hello".upper().

Votre premier cours

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

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

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ s’exécute automatiquement chaque fois que vous créez un objet et définit l’état de départ. Le dépôt dans a n’a pas touché b, car chaque objet a ses propres données. Notez que la méthode protège également le solde d’une mauvaise valeur. Notre guide sur la gestion des exceptions Python explique raise plus en profondeur.

Qu’est-ce que le soi ?

self est simplement l’objet sur lequel une méthode travaille. Lorsque vous écrivez a.deposit(50), Python appelle effectivement Account.deposit(a, 50), en passant l’objet comme premier argument. C’est ainsi qu’une définition de méthode peut servir chaque objet.

Le nom self est une convention forte plutôt qu’un mot-clé, mais utilisez-le toujours. L’oublier dans une définition de méthode est l’erreur de débutant la plus courante et produit un message déroutant sur le nombre d’arguments.

Attributs de classe vs attributs d’instance

Un attribut défini directement dans le corps de la classe est partagé par tous les objets. Un ensemble sur self appartient uniquement à cet objet. Cet exemple montre comment se comportent les recherches :

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Cette dernière ligne surprend les gens. L’attribution via a n’a pas modifié la valeur partagée. Il a créé un nouvel attribut d’instance sur a qui masque celui de classe. Python regarde d’abord l’objet, puis la classe.

Méthodes spéciales (dunder)

Les méthodes avec des traits de soulignement doubles permettent à vos objets de fonctionner avec les fonctionnalités intégrées de Python. Sans eux, l’impression d’un compte affiche une adresse mémoire inutile. En ajouter deux lui donne une forme lisible :

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

Héritage

L’héritage permet à une nouvelle classe de réutiliser une classe existante et de modifier uniquement ce qui diffère. Ici, Savings est un Account avec un paramètre supplémentaire :

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() appelle la version parent, donc la logique de configuration n’est pas répétée. deposit a été hérité tel quel et __str__ a été remplacé pour ajouter une étiquette. N’utilisez l’héritage que pour une véritable relation “est une”. Si une classe a simplement besoin de quelque chose, comme une voiture ayant besoin d’un moteur, donnez-lui cet objet comme attribut. C’est ce qu’on appelle la composition, et elle est généralement plus flexible que les chaînes d’héritage profondes.

Polymorphisme

Le polymorphisme signifie que différents objets peuvent répondre au même appel de méthode à leur manière. Le code appelant n’a pas besoin de connaître le type exact :

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Ces deux classes ne partagent même pas de parent. Python se soucie uniquement que l’objet ait une méthode area, une approche connue sous le nom de typage de canard. L’ajout d’un Triangle plus tard ne nécessiterait aucune modification de la boucle.

Encapsulation et propriétés

Python n’a pas d’attributs véritablement privés et s’appuie plutôt sur des conventions. Un simple trait de soulignement, comme dans _price, indique aux autres développeurs “ceci est interne, veuillez ne pas y toucher”. Pour vérifier les valeurs lorsqu’elles sont définies, utilisez une propriété, qui ressemble à un simple attribut vu de l’extérieur :

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Cela signifie que vous pouvez commencer avec un attribut simple et ajouter une validation ultérieurement sans modifier le code qui utilise la classe. N’écrivez donc pas les méthodes get_price() et set_price() par habitude, comme vous le feriez en Java. La syntaxe @ ici est un décorateur, que nous expliquons dans Explication des décorateurs Python.

Méthodes de classe et méthodes statiques

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Classes de données

Lorsqu’une classe contient principalement des données, écrire __init__, __repr__ et __eq__ à la main est fastidieux. @dataclass les génère à partir d’annotations de type :

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Erreurs courantes

Utiliser un attribut de classe mutable

C’est un bug classique. La liste est définie sur la classe, donc tous les paniers la partagent :

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Créez-le dans __init__ avec self.items = [], afin que chaque objet obtienne sa propre liste.

Autres erreurs courantes

• Oublier self. Écrivez self.balance, et non balance, dans les méthodes.
• Oublier super().__init__(). L’enfant manque alors des attributs mis en place par le parent.
• Créer d’énormes classes. Une classe qui fait tout est difficile à tester. Divisez-le par responsabilité.
• Héritage profond. Deux niveaux suffisent généralement et la composition est souvent plus claire.
• Ne pas écrire de tests. Les classes avec des règles sont faciles à tester, comme le montre notre tutoriel pytest à l’aide d’un petit chariot.

Pour conclure

Python orienté objet revient à regrouper les données avec le comportement qui les protège. Commencez par __init__, les méthodes et __str__, puis ajoutez l’héritage et les propriétés lorsque vous rencontrez un problème qu’ils résolvent. Comme étape suivante, prenez un script qui transmet les mêmes variables partout et transformez-les en une seule petite classe.

Questions fréquentes

Continuez à apprendre