L'héritage multiple en python

Bienvenue dans notre cours ‘Programmation orientée objet en Python’. Alors, dans cette partie de cours, on va découvrir l’héritage multiple en python.

héritage multiple en python

Dans la partie précédente, nous avons décrit le type d’héritage nommé héritage multiple. Cette relation qui peut exister entre classes, impose d’avoir des classes mères (deux ou plusieurs) pour une classe spécifique.

Ainsi, l’implémentation de cette relation , dans un langage de programmation orienté objet, revient à programmer les classes mères et la classe spécifique qui hérite de ces classes . Puis, utiliser les objets de la classe voulue.

Exemple : Les classes mères

Dans l’exemple suivant, on a une classe mère Personne qui a les attributs nom et prénom. Pour le moment, on laisse les attributs publics (on va appliquer le principe d’encapsulation après). Aussi, la classe Personne a une méthode AfficherInfos qui affiche les informations d’une personne :

#classe mère 1
import datetime
class Personne:
  def __init__(self,n,p,d):
      self.nom=n
      self.prenom=p
      self.dateNaiss=d
  def AfficherInfos(self):
      print("nom: ",self.nom,"prénom: ",self.prenom,"date de naissance : ",self.dateNaiss)

La deuxième classe mère est la classe Employé (Attention, ici, on n’applique pas le principe d’encapsulation. On doit le détailler après pour voir comment l’appliquer si on a l’héritage) :

#classe mère 2 
class Employe:
  def __init__(self,code,sal):
      self.code=code
      self.salaire=sal
  def AfficherInfos(self):
      print("code:",self.code," salaire: ",self.salaire)

Donc, en général, la création des classes mères se fait de la même façon que l’implémentation d’une classe normale (sauf qu’on doit mettre les attributs protégés : voir la partie d’encapsulation et héritage)

héritage multiple : La classe fille

La classe professeur est une classe fille à la fois de la classe personne et la classe employé. Pour implémenter cela en python, on utilise la syntaxe :

class classeFille(mere1,mere2):

    .....

Puis, on continue l’implémentation de la classe fille : c’est à dire on ajoute les attributs et les méthodes spécifiques à la classe s’ils existent. Pour notre exemple, la classe professeur est la suivante :

class Prof(Employe,Personne):
  def __init__(self,n,p,d,cod,sal,specialite):
       Personne.__init__(self,n,p,d)
       Employe.__init__(self,cod,sal)
       self._sp=specialite
  def AfficherInfos(self):
      Personne.AfficherInfos(self)
      Employe.AfficherInfos(self)
      print("Specialité: ", self._sp)

La classe professeur utilisent les éléments hérités pour profiter de l’héritage. En effet, elle fait appel aux constructeurs de ses classes mères pour initialiser les attributs hérités. Aussi, elle a appelé les méthodes AfficherInfos de ses classes mères, puis elle a compléter l’affichage par l’ajout de l’affichage de la spécialité.

D’où, l’héritage, simple ou multiple, favorise la réutilisation et factorise le code.

héritage multiple en python : super()

Nous avons vu , pour l‘héritage simple, que la fonction super() peut être utiliser pour désigner la classe mère. Cela, nous permet d’appeler la classe mère même-ci on ne connait pas son nom. Aussi, la fonction super() nous permet d’omettre le paramètre self .

Ainsi, on veut bien utiliser cette fonction si c’est possible. Pour cela, on va réecrire le code d’implémentation de la classe fille professeur en changeant le nom de ses classes mères par l’appel de la focntion super() :

class Prof(Employe,Personne):
  def __init__(self,n,p,d,cod,sal,specialite):
       super().__init__(n,p,d)
       super().__init__(cod,sal)
       self._sp=specialite
  def AfficherInfos(self):
      Personne.AfficherInfos(self)
      Employe.AfficherInfos(self)
      print("Specialité: ", self._sp)

Le code va générer une exception!! c’est tout a fait normal, vu qu’on a plus d’une classe mère!! Bien sur , on doit se poser la question : la fonction super() va remplacer quelle classe mère? ce n’est pas possible que la fonction super() désigne à la fois la classe Personne et la classe Employe!!

Pour trouver la règle, on peut tester chaque cas séparément :

1- on utilise la fonction super() à la place de la classe Personne :

class Prof(Employe,Personne):
   def __init__(self,n,p,d,cod,sal,specialite):
       super().__init__(n,p,d)
       Employe.__init__(self,cod,sal)
       self._sp=specialite
   def AfficherInfos(self):
       super().AfficherInfos()
       Employe.AfficherInfos(self)
       print("Specialité: ", self._sp)

Le code engendre une exception! en lisant le message de l’exception, on comprend que le problème vient du fait qu’on attend trois paramètres mais nous, nous avons donné quatre!

Oui, en fait, on compte le self, meme-ci il n’est pas écrit.

Alors, on remarque qu’on attend à utiliser super() pour désigner Employe et non pas Personne. Voyons l’ordre des classes mère dans la première ligne :

class Prof(Employe,Personne):

Oui, c’est cà!! la fonction super() désigne la première classe mère! Donc, l’ordre est important. On peut inverser l’ordre des classes mères et tester :

class Prof(Personne,Employe):
   def __init__(self,n,p,d,cod,sal,specialite):
       super().__init__(n,p,d)
       Employe.__init__(self,cod,sal)
       self._sp=specialite
   def AfficherInfos(self):
       super().AfficherInfos()
       Employe.AfficherInfos(self)
       print("Specialité: ", self._sp)

Oui ca marche très bien! Vous pouvez laisser le premier ordre et utiliser la fonction super() pour désigner la classe Employe, vous voyez que ca va marcher aussi. Donc :

Règle :

La fonction super() désigne la première classe mère en cas d’héritage multiple . La première classe mère veut dire, celle écrite en premier; c’est à dire que l’ordre d’écriture des classes mères est important.

héritage multiple en python : création des objets

Une fois les classes (filles et mères) sont définit, alors, les objets peuvent être crées et utiliser selon l’objectif à atteindre.

Exemple : créer un objet p1 de la classe professeur :

e1=Prof("elgarrai","zineb",datetime.date(2019, 4, 13),10000,15000,"TDI")
e1.AfficherInfos()

Remarque : nous avons utiliser la méthode date du module datetime pour créer la date de recrutement. C’est pour cela nous avons démarré notre code au début par :

import datetime

Attention : dans cette partie , nous avons définit les attributs public. Chose qui est incorrectes selon le principe d’encapsulation. Nous l’avons fait simplement pour se focaliser sur l’implémentation d’héritage multiple. Pour compléter cette partie , vous devez voir la partie suivante qui va traiter l’encapsulation et l’héritage.

Vous pouvez suivre notre liste des vidéos sur la programmation orientée objet sur notre chaine youtube 9raytifclick (Darija: arabe marocaine) : POO en Python

Aussi, si vous voulez commencer l’apprentissage d’un langage de programmation, voilà notre cours : Langage Python Niveau 1 qui sera très utile pour vous (il vous aide à pratiquer tous les éléments de base de la programmation ; vus dans notre cours d’algorithmique).