Python dérivée de la classe et de la classe de base attributs?

Si vous mettez en œuvre __init__ dans une classe dérivée de BaseClass, puis il va remplacer l'héritée __init__ méthode et donc BaseClass.__init__ ne sera jamais appelé. Si vous avez besoin d'appeler le __init__ méthode pour BaseClass (comme c'est normalement le cas), alors c'est à vous de le faire, et sa fait explicitement en appelant BaseClass.__init__, normalement à partir de l'intérieur de la nouvellement mis en œuvre __init__ méthode.

class Foo(object):
    def __init__(self):
        self.a = 10

    def do_something(self):
        print self.a

class Bar(Foo):
    def __init__(self):
        self.b = 20

bar = Bar()
bar.do_something()

Ce sera la cause de l'erreur suivante:

AttributeError: 'Bar' object has no attribute 'a'

Donc, le do_something méthode a été hérité comme prévu, mais cette méthode nécessite l'attribut a avoir été réglée, il ne l'est jamais car __init__ a également été remplacé. Nous contourner ce en appelant explicitement Foo.__init__ de l'intérieur Bar.__init__.

class Foo(object):
    def __init__(self):
        self.a = 10

    def do_something(self):
        print self.a

class Bar(Foo):
    def __init__(self):
        Foo.__init__(self)
        self.b = 20

bar = Bar()
bar.do_something()

qui imprime 10 comme prévu. Foo.__init__ dans ce cas s'attend à ce qu'un seul argument qui est une instance de Foo (qui par convention est appelée self).

Normalement, lorsque vous appelez une méthode sur une instance d'une classe, l'instance de classe est passé automatiquement en tant que premier argument. Méthodes sur une instance d'une classe sont appelées les méthodes liées. bar.do_something est un exemple d'une méthode liée (et vous remarquerez qu'il est appelé sans arguments). Foo.__init__ est un indépendant méthode parce qu'il n'est pas attaché à une instance particulière de Foo, de sorte que le premier argument, une instance de Foo, doit être transmis de manière explicite.

Dans notre cas, nous passons self à Foo.__init__, qui est l'instance de Bar a été passé à la __init__ méthode dans Bar. Depuis Bar hérite de Foo, les instances de Bar sont également des instances de Foo, donc en passant self à Foo.__init__ est autorisé.

Il est probable que la classe héritant de l'exige ou accepte des arguments plus que juste une instance de la classe. Ces sujets sont traités, comme vous le feriez avec n'importe quelle méthode que vous appelez à partir de l'intérieur de __init__:

class Foo(object):
    def __init__(self, a=10):
        self.a = a

    def do_something(self):
        print self.a

class Bar(Foo):
    def __init__(self):
        Foo.__init__(self, 20)

bar = Bar()
bar.do_something()

qui imprime 20.

Si vous essayez de mettre en œuvre une interface entièrement expose tous les arguments d'initialisation de la classe de base par le biais de votre héritant de la classe, vous en aurez besoin pour le faire explicitement. Ceci est généralement fait avec l' *args et **kwargs arguments (les noms sont par convention), qui sont des espaces réservés pour tous reste des arguments qui ne sont pas explicitement nommé. L'exemple suivant utilise tout ce que j'ai abordés:

class Foo(object):
    def __init__(self, a, b=10):
        self.num = a * b

    def do_something(self):
        print self.num

class Bar(Foo):
    def __init__(self, c=20, *args, **kwargs):
        Foo.__init__(self, *args, **kwargs)
        self.c = c

    def do_something(self):
        Foo.do_something(self)
        print self.c


bar = Bar(40, a=15)
bar.do_something()

Dans ce cas, l'argument c est fixé à 40, comme c'est le premier argument de Bar.__init__. Le deuxième argument est ensuite incorporé dans les variables args et kwargs (*et ** est une syntaxe spécifique qui dit que l'élargissement de la liste/n-uplet ou un dictionnaire pour séparer les arguments lors du passage d'une fonction/méthode), et est transmis à Foo.__init__.

Cet exemple rend le point que tout écrasé méthode doit être appelée explicitement si c'est ce qui est nécessaire (comme do_something est dans ce cas).

Un point final, vous verrez souvent super(ChildClass, self).method() (où ChildClass est arbitraire de la classe enfant) utilisé au lieu d'un appel à la BaseClass méthode explicite. Discussion de super est une toute autre question, mais il suffit de dire, dans ces cas, il est généralement utilisé pour faire exactement ce qui est fait en appelant BaseClass.method(self). Brièvement, super délégués de l'appel de méthode à la classe suivante dans la méthode de résolution de l'ordre - la MRO (ce qui, dans l'héritage simple est la classe mère). Voir la documentation sur super pour plus d'info.

OriginalL'auteur Henry Gomersall