🛄 Création et manipulation d'objets

La programmation orientée objet (POO) en Python permet de créer des structures appelées objets qui regroupent des données et des fonctions associées. Les objets sont définis à partir de classes, qui servent de "modèle" ou "plan" pour créer des instances.

Définir une classe

Une classe est définie avec le mot-clé class. Elle peut contenir :

des attributs : variables qui décrivent l'objet,
des méthodes : fonctions qui agissent sur l'objet.


class Animal:
    def __init__(self, nom, age):
        self.nom = nom   # attribut nom
        self.age = age   # attribut âge

    def se_presenter(self):
        return f"Je suis {self.nom} et j'ai {self.age} ans."

Explications :

__init__ : méthode spéciale appelée lors de la création d'une instance. Elle initialise les attributs de l'objet.
self : référence à l'objet courant. Permet d'accéder aux attributs et méthodes de l'objet.
Les autres méthodes sont définies comme des fonctions normales, mais prennent toujours self comme premier argument.

Créer une instance d'une classe


# Création d'un objet à partir de la classe Animal
chien = Animal("Rex", 5)
chat = Animal("Miaou", 3)

# Appel d'une méthode
print(chien.se_presenter())  # Je suis Rex et j'ai 5 ans.
print(chat.se_presenter())   # Je suis Miaou et j'ai 3 ans.

Chaque instance possède ses propres attributs, même si elles viennent de la même classe.

Modifier les attributs d'une instance


chien.age = 6
print(chien.se_presenter())  # Je suis Rex et j'ai 6 ans.

# Ajouter un nouvel attribut dynamique
chat.couleur = "blanc"
print(chat.couleur)           # blanc

Méthodes avec paramètres

Les méthodes peuvent recevoir d'autres arguments pour modifier ou calculer des valeurs :


class CompteBancaire:
    def __init__(self, titulaire, solde=0):
        self.titulaire = titulaire
        self.solde = solde

    def deposer(self, montant):
        self.solde += montant

    def retirer(self, montant):
        if montant <= self.solde:
            self.solde -= montant
        else:
            print("Solde insuffisant")

    def afficher_solde(self):
        return f"Solde de {self.titulaire} : {self.solde} €"

# Exemple
compte = CompteBancaire("Alice", 100)
compte.deposer(50)
print(compte.afficher_solde())  # Solde de Alice : 150 €
compte.retirer(200)             # Solde insuffisant

Héritage

Une classe peut hériter d'une autre classe pour réutiliser ses attributs et méthodes :


class Chien(Animal):
    def aboyer(self):
        return f"{self.nom} dit : Ouaf !"

rex = Chien("Rex", 5)
print(rex.se_presenter())  # Héritage de la méthode de Animal
print(rex.aboyer())        # Rex dit : Ouaf !

L'héritage permet de créer des classes spécialisées tout en conservant les comportements de la classe parent.

Méthodes spéciales utiles

>__str__(self) : définit ce qui est affiché lorsqu'on utilise print(objet).
>__repr__(self) : fournit une représentation officielle de l'objet.
>__len__(self) : peut définir le comportement de len(objet).


class Livre:
    def __init__(self, titre, pages):
        self.titre = titre
        self.pages = pages

    def __str__(self):
        return f"Livre : {self.titre}, {self.pages} pages"

livre = Livre("Python pour tous", 250)
print(livre)  # Livre : Python pour tous, 250 pages

Résumé

Une classe est un modèle pour créer des objets.
Une instance est un objet créé à partir d'une classe.
__init__ initialise les attributs lors de la création.
Les méthodes sont des fonctions de la classe qui agissent sur l'objet.
L'héritage permet de créer des classes dérivées avec les mêmes attributs et méthodes que la classe parent.
Les méthodes spéciales comme __str__ ou __len__ permettent de personnaliser le comportement des objets.

La POO est très puissante pour structurer vos programmes, organiser le code et faciliter sa réutilisation.