Programmation orientée objet : classes Python – attributs, méthodes et instantiation

Ce document présente les concepts fondamentaux de la programmation orientée objet (POO) en Python, destinés aux étudiants de niveau master. Il couvre la définition des classes, les attributs, les méthodes, l’instanciation, les constructeurs et destructeurs, la définition de classes dans des modules, l’héritage simple et multiple, la surcharge des méthodes, ainsi que la gestion des collections d’objets.

Présentation des classes

Une classe est un ensemble regroupant des attributs et des méthodes. Les attributs sont des variables accessibles depuis toutes les méthodes de la classe. En Python, les classes sont des types modifiables. Les champs d’une classe peuvent être de tout type, y compris des références à des instances d’autres classes.

La syntaxe de base pour définir une classe est :

class nom_classe:
    # corps de la classe
    # ...

Le corps d’une classe peut être vide, contenir des variables (attributs) ou des fonctions (méthodes). Le mot-clé pass indique un corps vide :

class classe_vide:
    pass

Instantiation : Une instance d’une classe C est une variable de type C, c’est-à-dire un objet de cette classe. La syntaxe d’instanciation est :

C1 = nom_classe()

Attributs et méthodes

Les attributs sont des variables explicitement associées à une classe. Ils se comportent comme des variables globales pour toutes les méthodes de cette classe.

Une méthode est une fonction définie dans le corps de la classe, avec un premier paramètre obligatoire self. Ce paramètre représente l’objet sur lequel la méthode est appliquée (la référence d’instance).

Pour accéder à un attribut dans une méthode, on utilise self.nom_attribut. Sans self, une variable est locale à la méthode et ne correspond pas à un attribut de la classe.

Exemple de définition et d’appel d’une méthode :

class nom_classe:
    def nom_methode(self, param_1, ..., param_n):
        self.nom_attribut = valeur

cl = nom_classe()  # création d’une instance
t = cl.nom_methode(valeur_1, ..., valeur_n)

Exemple concret :

class compte:
    # gestion d'un compte bancaire
    def crediter(self, x):
        self.solde += x

    def afficherSolde(self):
        print("Le solde vaut :", self.solde)

monCompte = compte()
monCompte.nom = "comptePerso"
monCompte.numero = 666
monCompte.solde = 1000

Constructeur et destructeur

Constructeur

Le constructeur est une méthode spéciale nommée __init__. Elle accepte au moins un paramètre, self, qui doit être le premier. Elle ne retourne aucun résultat.

self représente l’objet en cours de création, permettant d’accéder à ses attributs et méthodes.

Exemple :

class compte:
    """gestion d'un compte bancaire"""
    def __init__(self, nom, numero, valeur):
        self.nom = nom
        self.numero = numero
        self.solde = valeur

    def afficherSolde(self):
        print("Le solde vaut :", self.solde)

monCompte = compte("comptepro", 777, 10000)
monCompte.afficherSolde()

Destructeur

Le destructeur est une méthode spéciale nommée __del__ qui est appelée automatiquement quand un objet cesse d’être référencé. Elle sert à libérer la mémoire ou à mettre à jour certains attributs, comme un compteur d’objets instanciés.

Sa syntaxe est similaire à celle des autres méthodes :

class nomDeLaClasse:
    def __init__(self, para1, para2, ...):
        ...

    def __del__(self):
        ...

    def methode1(self, para1, para2, ...):
        ...

Définition des classes dans des modules

Il est conseillé de définir les classes dans des modules Python, ce qui facilite la réutilisation et la maintenance. Un module peut contenir plusieurs classes.

Exemple de module ModuleCompte.py :

class compte:
    # gestion d'un compte bancaire
    def __init__(self, nom, numero, solde):
        self.nom = nom
        self.numero = numero
        self.solde = solde

    def crediter(self, x):
        self.solde += x

    def afficherSolde(self):
        print("Le solde vaut :", self.solde)

Exemple d’utilisation dans un programme principal :

import ModuleCompte as MC

monCompte = MC.compte('moncompte personel', 666, 1000)
print(monCompte.nom)
monCompte.crediter(2000)
monCompte.afficherSolde()

On importe le module, on crée une instance en précisant le module puis la classe, et on peut afficher les membres avec print(dir(monCompte)).

Héritage

L’héritage permet de construire une hiérarchie de classes. Une classe fille hérite des attributs et méthodes de la classe mère, ce qui améliore la lisibilité et la réutilisabilité du code.

Exemple de déclaration :

class classeMere:
    # une classe mère
    ...

class classeFille(classeMere):
    # une classe fille héritant de la classe mère
    ...

Constructeur de la classe fille

Le constructeur de la classe fille doit appeler explicitement celui de la classe mère pour initialiser les attributs hérités. Deux syntaxes sont possibles :

class classeFille(classeMere):
    def __init__(self, para1, para2, ...):
        classeMere.__init__(self, para1, ...)
        ...

ou

class classeFille(classeMere):
    def __init__(self, para1, para2, ...):
        super().__init__(para1, ...)
        ...

Héritage multiple

Une classe fille peut hériter de plusieurs classes mères :

class mere1:
    ...

class mere2:
    ...

class classeFille(mere1, mere2, ...):
    ...

Le constructeur de la classe fille doit appeler explicitement les constructeurs des classes mères :

class classeFille(mere1, mere2, ...):
    def __init__(self, para1, para2, ...):
        mere1.__init__(self, para1, ...)
        mere2.__init__(self, para1, ...)

Exemple concret :

class carnivore:
    def __init__(self, p):
        self._poidsViande = p

    def devorer(self):
        print("Je mange", self._poidsViande, "kilos de viande par jour")

class herbivore:
    def __init__(self, p):
        self._poidsHerbe = p

    def brouter(self):
        print("Je mange", self._poidsHerbe, "kilos d’herbe par jour")

class omnivore(carnivore, herbivore):
    def __init__(self, pv, ph, h):
        carnivore.__init__(self, pv)
        herbivore.__init__(self, ph)
        self.__humain = h

o = omnivore(10, 5, False)
o.devorer()
o.brouter()

Surcharge des méthodes

La surcharge consiste à redéfinir une méthode héritée dans une classe fille pour modifier ou étendre son comportement.

Exemple :

class Personne:
    def __init__(self):
        self.nom = ""
        self.age = 0
        self.salaire = 0.0

    def saisie(self):
        self.nom = input("Nom : ")
        self.age = int(input("Age : "))
        self.salaire = float(input("Salaire : "))

    def affichage(self):
        print("Son nom est", self.nom)
        print("Son âge :", self.age)
        print("Son salaire :", self.salaire)

class Employe(Personne):
    def __init__(self):
        Personne.__init__(self)
        self.prime = 0.0

    def saisie(self):
        Personne.saisie(self)
        self.prime = float(input("Prime : "))

    def affichage(self):
        Personne.affichage(self)
        print("Sa prime :", self.prime)

Programme principal :

import ModulePersonne as MP

e = MP.Employe()
e.saisie()
print(" ** Affichage **")
e.affichage()

Gestion des collections d’objets

On peut gérer des collections d’objets en utilisant des listes Python. Exemple de saisie et affichage d’une liste d’objets :

import ModulePersonne as MP

liste = []
n = int(input("Nb de pers : "))

for i in range(n):
    a = MP.Personne()
    a.saisie()
    liste.append(a)

print("début affichage")
for p in liste:
    print("-------")
    p.affichage()

Chaque objet est créé, saisi, puis ajouté à la liste. Le typage est automatique, et chaque élément p est bien de type Personne.

Glossaire des termes clés

• Classe : Ensemble regroupant des attributs et des méthodes, définissant un type d’objet.
• Instance : Objet créé à partir d’une classe, variable dont le type est une classe.
• Attribut : Variable associée à une classe ou à une instance, accessible via self.
• Méthode : Fonction définie dans une classe, avec un premier paramètre self représentant l’instance.
• Constructeur (__init__) : Méthode spéciale appelée lors de la création d’une instance pour initialiser ses attributs.
• Destructeur (__del__) : Méthode spéciale appelée automatiquement lors de la destruction d’un objet.
• Module : Fichier Python contenant des définitions de classes, fonctions, variables, utilisé pour organiser le code.
• Héritage : Mécanisme permettant à une classe fille d’hériter des attributs et méthodes d’une classe mère.
• Héritage multiple : Classe fille héritant de plusieurs classes mères.
• Surcharge de méthode : Redéfinition d’une méthode héritée dans une classe fille pour modifier son comportement.
• Collection d’objets : Ensemble d’objets stockés dans une structure de données, souvent une liste.

Points clés à retenir

• Une classe définit un type d’objet avec des attributs et des méthodes accessibles via self.
• L’instanciation crée un objet à partir d’une classe, initialisé par le constructeur __init__.
• Le destructeur __del__ est appelé automatiquement lors de la suppression d’un objet.
• Les classes sont souvent définies dans des modules pour faciliter la modularité et la réutilisation.
• L’héritage permet de créer des hiérarchies de classes, favorisant la réutilisation et l’extension du code.
• Le constructeur d’une classe fille doit appeler explicitement celui de la classe mère.
• L’héritage multiple permet à une classe d’hériter de plusieurs classes mères, avec appel explicite de leurs constructeurs.
• La surcharge des méthodes permet de modifier ou d’étendre le comportement hérité.
• Les collections d’objets sont gérées efficacement avec des listes, facilitant la manipulation de groupes d’instances.