Différences

Ci-dessous, les différences entre deux révisions de la page.

--- python:programmes:classes_heritage_exemple [2017/03/21 22:12] – root
+++ python:programmes:classes_heritage_exemple [2017/06/01 11:02] (Version actuelle) – root
@@ Ligne 2: / Ligne 2: @@
 <code python>
-#!/usr/bin/env python3
+class parent1:
-# -*- coding: utf-8 -*-
-class parent(object):
     def __init__(self):
-        print("init parent")
+        print("init parent1")
-        self.var = 'myvar'
+        self.var1 = 'myvar1'
+    def defParent1(self):
+        print('defParent1')
     def test(self):
-        print('parent')
+        print('parent1')
-class parent2(object):
+class parent2:
     def __init__(self):
         print("init parent2")
         self.var2 = 'myvar2'
+    def defParent2(self):
+        print('defParent2')
     def test(self):
         print('parent2')
-class child(parent, parent2):
+class child(parent1, parent2):
     def __init__(self):
         print("init child")
         # Auto-initialisation des variables de l'ensemble des classes parentes
-        for c in __class__.mro()[1:]:
+        for c in __class__.mro()[1:-1]:
             c.__init__(self)
-            # On initialise les variables avec le nom des parents
+            #exec('self.{} = c.__init__(self)'.format(c.__name__))
-            for c in child.mro()[1:]:
+            # On initialise dynamiquement les variables avec le nom des parents
-                exec('self.{}=c()'.format(c.__name__))
+            #for c in child.mro()[1:]:
+            #    exec('self.{}=c()'.format(c.__name__))
     def test(self):
-        parent.test(self)              # Appelle parent.test() sans appeler __init__()
-        parent().test()                # Appelle parent.__init__, puis la methode test de la fonction parent (mais initialise pas la variable var)
-        parent2().test()               # Appelle parent2.__init__, puis la methode test de la fonction parent2 (mais n'initialise pas la variable var2)
-        super().test()                 # Appelle test de la fonction parent (sans __init__)
-        super().__init__()             # Appelle __init__ de la fonction parent (sans __init__) et initialise la variable var à myvar
-        parent.__init__(self)          # Appelle parent.__init__ et initialise la variable var à myvar
-        parent2.__init__(self)         # Appelle parent2.__init__ et initialise la variable var2 à myvar2
-        super(__class__, self).test()  # Appelle test de la fonction parent (sans __init__)
-        super(child, self).test()      # Appelle test de la fonction parent (sans __init__)
         print('child')
+        print('\n* parent1.test(self) => appelle parent1.test() sans appeler __init__() car non instanciée')
+        parent1.test(self)
+        print("\n* parent1().test() => appelle parent1.__init__, puis la méthode test() de la classe parent1, mais n'initialise pas la variable var1")
+        parent1().test()
+        print("\n* parent2().test() => appelle parent2.__init__(), puis la méthode test() de la classe parent2, mais n'initialise pas la variable var2")
+        parent2().test()
+        print('\n* super().test() => appelle la méthode test() de la classe parent1 sans __init__()')
+        super().test()
+        print('\n* super().__init__() => appelle __init__() de la classe parent1 sans __init__() et initialise la variable var1 à myvar1')
+        super().__init__()
+        print('\n* super(parent1, self).__init__() => appelle __init__() de la classe parent2 car on demande à super de sauter parent1')
+        super(parent1, self).__init__()
+        print('\n* parent1.__init__(self) => appelle parent1.__init__() et initialise la variable var1 à myvar1')
+        parent1.__init__(self)
+        print('\n* parent2.__init__(self) => appelle parent2.__init__() et initialise la variable var2 à myvar2')
+        parent2.__init__(self)
+        print('\n* super(__class__, self).test() => Appelle la méthode test() de la classe parent1 sans __init__()')
+        super(__class__, self).test()
+        print('\n* super(child, self).test() => appelle la méthode test() de la classe parent1 sans __init__()')
+        super(child, self).test()
 if __name__ == '__main__':
     # super() se base sur la première classe rencontrée dans le mro()
+    print("\n* child.mro() => affiche l'ordre d'héritage des parents si non spécifié")
     print(child.mro())
+    print('\n* child().test() => instancie la classe child et appelle la méthode test')
     child().test()
-    a=child()
+    print('\n* a = child() => crée une instance de la classe child dans la variable a')
-    print('a.parent.var : ' + a.parent.var)
+    a = child()
-    a.parent.test()
-    print('a.parent2.var2 : ' + a.parent2.var2)
+    print('\n* a.defParent1() => appelle la méthode defParent1 seulement présente dans parent1')
-    a.parent2.test()
+    a.defParent1()
+    print('\n* a.defParent2() => appelle la méthode defParent2 seulement présente dans parent2')
+    a.defParent2()
+    print('\n* a.var1 : ' + a.var1)
+    print('\n* a.var2 : ' + a.var2)
+    #print('\n* a.parent1.var1 : ' + a.parent1.var1)
+    #print('\n* a.parent2.var2 : ' + a.parent2.var2)
+    #print('\n* Appelle explicitement la méthode test() sur parent1 (rendu possible car on a créé le nom des classes enfants dynamiqudment dans __init__())')
+    #a.parent1.test()
+    #print('\n* Appelle explicitement la méthode test() sur parent2 (rendu possible car on a créé le nom des classes enfants dynamiqudment dans __init__())')
+    #a.parent2.test()
 </code>