Les Classes en Python

Ce laboratoire présente les concepts fondamentaux des classes en Python. Il permet d'apprendre à définir des classes, créer des instances, utiliser les attributs et méthodes, gérer les constructeurs et destructeurs, organiser les classes dans des modules, appliquer l'héritage simple et multiple, ainsi que surcharger des méthodes. Il inclut également la manipulation de collections d'objets. Pour réaliser ce TP, un environnement Python fonctionnel est nécessaire, ainsi qu'un éditeur de texte ou un IDE adapté.

Objectifs

• Comprendre la définition et la syntaxe des classes en Python.
• Créer et manipuler des instances d'une classe.
• Utiliser les attributs et méthodes, y compris le paramètre self.
• Définir et utiliser un constructeur (__init__) et un destructeur (__del__).
• Organiser les classes dans des modules et les importer.
• Mettre en œuvre l'héritage simple et multiple.
• Surcharger des méthodes dans une classe fille.
• Gérer des collections d'objets et itérer sur celles-ci.

Prérequis et installation

• Python installé (version compatible avec la syntaxe utilisée, Python 3 recommandé).
• Connaissances de base en programmation Python : variables, fonctions, boucles.
• Connaissance élémentaire des notions d'objet et de classe.
• Un éditeur de texte ou un IDE pour écrire et exécuter les scripts Python.

Définition et création d’une classe

Commencez par définir une classe simple en Python. Une classe est un ensemble d’attributs (variables) et de méthodes (fonctions). La syntaxe est :

class nom_classe:
    # corps de la classe
    pass

Le mot-clé pass indique que la classe est vide. Par exemple :

class classe_vide:
    pass

Cette étape sert à comprendre la structure de base d’une classe. Un résultat correct est l’absence d’erreur à la définition de la classe.

Création d’instances, attributs et méthodes

Une instance est un objet créé à partir d’une classe. Pour créer une instance :

C1 = nom_classe()

Les attributs sont des variables associées à la classe et accessibles via self dans les méthodes. Une méthode est une fonction définie dans la classe avec self comme premier paramètre.

Exemple d’une classe compte avec des méthodes :

class compte:
    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

Cette étape permet de manipuler les attributs et méthodes d’une instance. Un résultat correct est la possibilité d’appeler monCompte.crediter(500) puis monCompte.afficherSolde() et d’obtenir le solde mis à jour.

Constructeur et destructeur

Le constructeur initialise une instance lors de sa création. Il s’appelle __init__ et doit avoir self comme premier paramètre. Exemple :

class compte:
    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()

Le destructeur __del__ est une méthode spéciale appelée automatiquement quand un objet n’est plus référencé. Il sert à libérer la mémoire ou mettre à jour des compteurs. Sa syntaxe est similaire à celle des autres méthodes :

def __del__(self):
    # actions à effectuer lors de la destruction
    pass

Cette étape permet de gérer le cycle de vie des objets. Un résultat correct est la bonne initialisation des attributs lors de la création et la destruction automatique sans erreur.

Définition des classes dans des modules

Il est conseillé de définir les classes dans des modules Python pour mieux organiser le code. Exemple de module ModuleCompte.py :

class compte:
    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)

Dans le programme principal, importer le module et créer une instance :

import ModuleCompte as MC

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

Cette étape enseigne l’organisation du code et l’importation des classes. Un résultat correct est l’affichage du nom et du solde mis à jour sans erreur.

Héritage simple

L’héritage permet de créer une classe fille qui hérite des attributs et méthodes d’une classe mère, améliorant la réutilisabilité du code. Exemple :

class classeMere:
    # classe mère
    pass

class classeFille(classeMere):
    # classe fille héritant de classeMere
    pass

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

class classeFille(classeMere):
    def __init__(self, para1, para2, ...):
        classeMere.__init__(self, para1, ...)
        # initialisation spécifique à classeFille

Ou avec super() :

class classeFille(classeMere):
    def __init__(self, para1, para2, ...):
        super().__init__(para1, ...)
        # initialisation spécifique à classeFille

Un exemple concret :

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)

Cette étape permet de comprendre la hiérarchie des classes. Un résultat correct est la saisie et l’affichage des attributs hérités et spécifiques.

Héritage multiple

Une classe fille peut hériter de plusieurs classes mères. Elle possède alors les attributs et méthodes de toutes ses classes mères plus ses propres attributs.

class mere1:
    pass

class mere2:
    pass

class classeFille(mere1, mere2):
    def __init__(self, para1, para2, ...):
        mere1.__init__(self, para1, ...)
        mere2.__init__(self, para2, ...)
        # initialisation spécifique

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()

Cette étape montre la complexité et la puissance de l’héritage multiple. Un résultat correct est l’exécution des méthodes héritées sans erreur.

Surcharge des méthodes

La surcharge permet à une classe fille de redéfinir une méthode héritée 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)

Un programme principal pour tester :

import ModulePersonne as MP

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

Cette étape permet de personnaliser les comportements des classes filles. Un résultat correct est la saisie et l’affichage des attributs supplémentaires.

Gestion des collections d’objets

On peut gérer plusieurs objets en les stockant dans une liste. Exemple :

import ModulePersonne as MP

liste = []

n = int(input("Nb de pers : "))

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

print("début affichage")

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

Cette étape permet de manipuler des collections d’objets et d’itérer sur celles-ci. Un résultat correct est l’affichage des informations de chaque personne saisie.

Résultats attendus

• Définition correcte des classes sans erreurs de syntaxe.
• Création d’instances avec initialisation des attributs via le constructeur.
• Appel des méthodes affichant les valeurs attendues (exemple : solde, nom, prime).
• Héritage fonctionnel avec accès aux attributs et méthodes des classes mères.
• Surcharge des méthodes affichant les informations spécifiques à la classe fille.
• Gestion correcte des collections d’objets avec affichage des données de chaque objet.
• Exécution sans erreurs des exemples d’héritage multiple et des appels de méthodes associées.

Pièges courants

• Oublier le paramètre self dans la définition des méthodes, ce qui provoque des erreurs.
• Confondre une variable locale et un attribut de classe en omettant self. devant le nom de l’attribut.
• Ne pas appeler explicitement le constructeur de la classe mère dans une classe fille, ce qui empêche l’initialisation des attributs hérités.
• Utiliser pass sans ajouter d’attributs ou méthodes, ce qui rend la classe inutile.
• Ne pas importer correctement un module contenant une classe avant de l’utiliser.
• Lors de l’héritage multiple, oublier d’appeler tous les constructeurs des classes mères.
• Confondre la surcharge avec la redéfinition sans appel aux méthodes de la classe mère, ce qui peut entraîner la perte de fonctionnalités.
• Ne pas gérer correctement la saisie des données, notamment les conversions de types (int, float).