Comment invoquer le super constructeur?

en ligne avec les autres réponses, il y a plusieurs façons d'appeler les méthodes super class (y compris le constructeur), cependant en Python-3.x le processus a été simplifié:

Python-2.x

class A(object):
 def __init__(self):
   print "world"

class B(A):
 def __init__(self):
   print "hello"
   super(B, self).__init__()

Python-3.x

class A(object):
 def __init__(self):
   print("world")

class B(A):
 def __init__(self):
   print("hello")
   super().__init__()

super() est maintenant équivalent à super(<containing classname>, self) selon le docs .

Avec Python 2.x classes de l'ancien style ce serait:

class A: 
 def __init__(self): 
   print "world" 

class B(A): 
 def __init__(self): 
   print "hello" 
   A.__init__(self)

une façon est d'appeler le constructeur de A et passer self comme argument, comme ainsi:

class B(A):
    def __init__(self):
        A.__init__(self)
        print "hello"

L'avantage de ce style est qu'il est très très clair. Il appelle le constructeur de A. L'inconvénient est qu'il ne gère pas très bien l'héritage en forme de diamant, puisque vous pouvez finir par appeler le constructeur de la classe de base partagée deux fois.

une Autre façon est d'utiliser des super(), comme d'autres l'ont montré. Pour seul héritage, il fait la même chose que de vous laisser appeler le parent du constructeur.

cependant, super () est un peu plus compliqué sous le capot et peut parfois être contre-intuitif dans les situations d'héritage multiple. Du côté positif, super() peut être utilisé pour gérer l'héritage en forme de diamant. Si vous voulez connaître les détails de ce que super() fait, la meilleure explication que j'ai trouvé pour comment super () fonctionne est ici (bien que je ne suis pas nécessairement d'accord que l'article de l'avis).

j'utilise la formule suivante qui prolonge les réponses précédentes:

class A(object):
 def __init__(self):
   print "world"

class B(A):
 def __init__(self):
   print "hello"
   super(self.__class__, self).__init__()

B()

de cette façon, vous ne devez pas répéter le nom de la classe dans l'appel à super . Il peut être utile si vous codez un grand nombre de classes, et que vous voulez rendre votre code dans les méthodes du constructeur indépendant du nom de la classe.