Langage Python

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Héritage en Python

L'héritage est un mécanisme qui nous permet de créer une nouvelle classe – connue sous le nom de classe enfant – qui est basée sur une classe existante – la classe mère, en ajoutant de nouveaux attributs et méthodes en plus de la classe existante. Lorsque vous procédez ainsi, la classe enfant hérite des attributs et méthodes de la classe parent.

L'héritage brille vraiment quand vous voulez créer des classes qui sont très similaires. Tout ce que vous avez à faire est d’écrire le code des choses qu’ils ont en commun dans une classe - la classe mère. Ensuite, écrire du code pour des choses très spécifiques dans une classe différente - la classe enfant. Cela vous évite de dupliquer le code.

Syntaxe :
                                class mere:
                                    # corps de la classe mère
                                
                                class enfant(mere):
                                    # corps de la classe enfant
                            
Remarque ! Comme la classe d'objets Java, en Python (à partir de la version 3.x), object est la racine de toutes les classes.
"class mere(object)" et "class mere" sont identiques.

Héritage simple

nous avons une classe appelée Personne définie comme suit.

                                class Personne(object):     
                                      
                                    # Constructeur         
                                    def __init__(self, nom, cin):    
                                        self.nom = nom 
                                        self.cin = cin 

                                    def afficher(self): 
                                        print("Nom : ",self.nom) 
                                        print("CIN : ",self.cin) 
                                

                                # création d'une variable d'instance
                                p=Personne("ISMAIL", "EE456788")
        
                                # appeler une fonction de la classe Personne en utilisant son instance
                                p.affiche()
                            

Cette classe possède des attributs pour stocker l'identifiant d'une personne (cin) et le nom de chaque personne (nom).
et aussi cette classe possède une méthode afficher() pour afficher les informations d'une personne

‘p’ est l’instance créée pour la classe Personne. Il invoque __init __ () de la classe mère. Vous pouvez voir "object" écrit dans la déclaration de la classe Personne. En Python, chaque classe hérite d’une classe de base intégrée appelée "object". Le constructeur, c’est-à-dire la fonction __init__ d’une classe est appelé lorsque nous créons une variable objet ou une instance de la classe.

Un employé est une personne, donc Nous pouvons donc créer une classe appelée Employe qui hérite de Personne. Cela rend tous les attributs disponibles dans la classe Personne facilement disponibles dans Employe. Nous n'avons pas besoin de les redéfinir (possibilité de réutilisation du code). La classe Employe est définie comme suite.

                                class Employe( Personne ): 

                                    def __init__(self, nom, cin, salaire): 
                                        self.salaire = salaire 
                              
                                        # appeler __init__ de la classe mère (Personne) 
                                        super().__init__(self, nom, cin) 
                            

Cependant, la classe Employe a un nouvel attribut salaire pour stocker le salaire d'un employé.

Exemple 1 :
                                class Personne(object):     
                                      
                                    # Constructeur         
                                    def __init__(self, nom, cin):    
                                        self.nom = nom 
                                        self.cin = cin 

                                    def afficher(self): 
                                        print("Nom : ",self.nom) 
                                        print("CIN : ",self.cin) 


                                class Employe( Personne ): 

                                    def __init__(self, nom, cin, salaire): 
                                        self.salaire = salaire 
                                  
                                    # appeler __init__ de la classe mère (Personne) 
                                    Personne.__init__(self, nom, cin) 
                                
                                p=Employe("Ismail", "EE4567", 7000)
                                p.afficher()
                            
Nom : Ismail
CIN : EE4567

Si aucun attribut n'est trouvé dans la classe, la recherche continue vers la classe de mère. Cela se répète de manière récursive, si la classe mère est elle-même dérivée d'autres classes.

En Python, nous utilisons la fonction super() pour appeler les méthodes de la classe parent.

Héritage multiple

Python nous permet de dériver une classe à partir de plusieurs classes à la fois, cela s'appelle Multiple Hheritance. Son format général est:

                                Class mere_1:
                                    # corps de mere_1
                                 
                                Class mere_2:
                                    # corps de mere_2
                                 
                                Class mere_3:
                                    # corps de mere_3
                                 
                                Class enfant(mere_1, mere_2, mere_3):
                                    # corps de la classe enfant
                            

La classe enfant est dérivée de trois classes mere_1, mere_2, mere_3. En conséquence, il héritera des attributs et des méthodes des trois classes.

Exemple 2 :
                                class Base(object): 
      
                                    # Constructeur
                                    def __init__(self, nom): 
                                        self.nom = nom 
                                  
                                    # retourner le nom 
                                    def getNom(self): 
                                        return self.nom 
                                  
                                  
                                class Child(Base): 
                                      
                                    # Constructeur
                                    def __init__(self, nom, age): 
                                        Base.__init__(self, nom) 
                                        self.age = age 
                                  
                                    # retourner l'age 
                                    def getAge(self): 
                                        return self.age 
                                  
                                class GrandChild(Child): 
                                      
                                    # Constructeur
                                    def __init__(self, nom, age, adresse): 
                                        Child.__init__(self, nom, age) 
                                        self.adresse = adresse 
                                  
                                    # retourner l'adresse
                                    def getAdresse(self): 
                                        return self.adresse         
                                  
                                # tester le code
                                g = GrandChild("ISMAIL", 32, "Meknes")   
                                print(g.getNom(), g.getAge(), g.getAdresse()) 
                            
ISMAIL 32 Meknes

La classe de base - object

En Python, toutes les classes héritent de la classe d'objet de manière implicite. Cela signifie que les deux définitions de classe suivantes sont équivalentes.

                                        class Personne:
                                            pass
                                        # ET 
                                        class Personne(object):
                                            pass
                                    

La classe object fournit des méthodes spéciales avec deux traits de soulignement de début et de fin, hérités de toutes les classes. Voici quelques méthodes importantes fournies par la classe d'objet.

  • __new__()
  • __init__()
  • __str__()

La méthode __new __ () crée l'objet. Après avoir créé l'objet, il appelle la méthode __init __ () pour initialiser les attributs de l'objet. Enfin, il renvoie l'objet nouvellement créé au programme appelant. Normalement, nous ne remplaçons pas la méthode __new __ (). Toutefois, si vous souhaitez modifier de manière significative la manière dont un objet est créé, vous devez absolument le remplacer.

La méthode __str__() est utilisée pour retourner une représentation de chaîne de caractères bien formatée de l'objet. La version object class de la méthode __str__() retourne une chaîne contenant le nom de la classe et son adresse mémoire dans hexadécimal.

Exemple 3 :
                                    class Personne(object):     
                                          
                                        # Constructeur         
                                        def __init__(self, nom, cin):    
                                            self.nom = nom 
                                            self.cin = cin
    
                                    p=Personne("ISMAIL", "EE456788")
                                    print(p)
                                
< __main__.Personne object at 0x10c287358>

Bien sûr, ce n'est pas très utile. Nous pouvons facilement remplacer cette méthode en définissant une méthode nommée __str __() dans la classe Personne comme suit.

Exemple 4 :
                                    class Personne(object):     
                                          
                                        # Constructeur         
                                        def __init__(self, nom, cin):    
                                            self.nom = nom 
                                            self.cin = cin
                                        
                                        def __str__(self):
                                            return self.nom
    
                                    p=Personne("ISMAIL", "EE456788")
                                    print(p)
                                
ISMAIL

Fonctions intégrées en Python liées à l'héritage

Deux fonctions intégrées, isinstance() et issubclass (), sont utilisées pour vérifier les héritages. Function isinstance () renvoie True si l'objet est une instance de la classe ou d'autres classes qui en dérivent. Chaque classe en Python hérite de la classe de base "object".

Exemple 1 :
                                class Personne(object):     
                                      
                                    # Constructeur         
                                    def __init__(self, nom, cin):    
                                        self.nom = nom 
                                        self.cin = cin 

                                    def afficher(self): 
                                        print("Nom : ",self.nom) 
                                        print("CIN : ",self.cin) 


                                class Employe( Personne ): 

                                    def __init__(self, nom, cin, salaire): 
                                        self.salaire = salaire 
                                  
                                    # appeler __init__ de la classe mère (Personne) 
                                    Personne.__init__(self, nom, cin) 
                                
                                p=Employe("Ismail", "EE4567", 7000)
                                
                                if(isinstance(p, Employe)):
                                    print("p est une instance de la classe Employe")


                                if(issubclass(Employe, Personne)):
                                    print("Employe est une sous classe de Personne")
                            
p est une instance de la classe Personne
Employe est une sous classe de Personne

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :