Discussion :

[afranck64]

Bonsoir, j'aimerai bien, si cela est possible, avoir des informations détaillés sur les méthodes suivantes (Héritage B, C, D):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class A:
    def __init__(self, value="default"):
        self.a= "toto"
        self.b= "world"
        print("new objet A", value)
 
 
class B(A):
    def __init__(self, value="child-B"):
        super(B,self).__init__(value)
        print("new objet B", value)
 
 
class C(A):
    def __init__(self, value="child-C"):
        A.__init__(self, value)
        print("new objet C", value)
 
class D(A):
    def __init__(self,value="child-D"):
        super().__init__(value)
        print("new objet D", value)
 
 
a = A()
b = B()
c = C()
d = D()

Y-a t'il des différences? ...

[wiztricks]

Salut,

• super().__init__(value), python V3
• super(B,self).__init__(value) est Python V2.4+
• A.__init__(self, value): construction pre v2.4+.

Tant que la classe n'hérite pas de plusieurs classes, la fonction réalisée est identique. Sinon, seul "super" sait parcourir l'arbre d'héritage pour appeler les différentes méthodes __init__ "héritées".
Pour les détails voir l'article
- W

[dividee]

Visiblement il s'agit de Python 3 (ce code est invalide en Python 2).

Les classes B et D sont équivalentes. En fait, l'utilisation de super sans argument est une nouveauté de Python 3, la sémantique est la même que dans la classe B.

La classe C est différente, mais la différence n’apparaît que si on utilise l'héritage multiple.

Si on rajoute ceci à ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class CD(C,D): pass
class DC(D,C): pass
 
cd = CD()
dc = DC()

On obtient ce résultat supplémentaire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
new objet A child-C
new objet C child-C
new objet A child-D
new objet C child-D
new objet D child-D

Dans le premier cas, le C.__init__ est appelé en premier, et celui-ci appelle A.__init__. D.__init__ n'est pas appelé du tout.

Dans le second cas, D.__init__ est appelé en premier, mais cette fois super() renvoie un proxy sur les méthodes de C, au lieu de A, c'est donc C.__init__ qui est appelé ensuite (qui lui appelle finalement A.__init__).

La seconde sémantique est généralement jugée préférable, du point de vue des concepts OO, donc, s'il y a possibilité d'héritage multiple, il vaut mieux utiliser super() au lieu de référencer directement la super-classe.

[afranck64]

Coooool! alors va pour les "super"!
Faut dire que j'ai toujours eu le "Parent.__init__()" facile