Sollte __init __ () die __init __ () der Elternklasse aufrufen?

Ich bin es gewohnt, dass ich in Objective-C dieses Konstrukt habe:

- (void)init {
    if (self = [super init]) {
        // init class
    }
    return self;
}

Sollte Python auch die Implementierung der übergeordneten Klasse aufrufen __init__?

class NewClass(SomeOtherClass):
    def __init__(self):
        SomeOtherClass.__init__(self)
        # init class

Ist das auch wahr / falsch für __new__()und __del__()?

Bearbeiten: Es gibt eine sehr ähnliche Frage: Vererbung und Überschreiben __init__in Python

In Python ist das Aufrufen der Superklasse __init__optional. Wenn Sie es aufrufen, ist es auch optional, ob Sie den superBezeichner verwenden oder die Superklasse explizit benennen möchten:

object.__init__(self)

Im Falle eines Objekts ist das Aufrufen der Super-Methode nicht unbedingt erforderlich, da die Super-Methode leer ist. Gleiches gilt für __del__.

Andererseits __new__sollten Sie in der Tat die Super-Methode aufrufen und ihre Rückgabe als neu erstelltes Objekt verwenden - es sei denn, Sie möchten ausdrücklich etwas anderes zurückgeben.

Wenn Sie __init__zusätzlich zu dem, was in der aktuellen Klasse getan wird, etwas von Super's tun __init__,müssen, müssen Sie es selbst nennen, da dies nicht automatisch geschieht. Aber wenn Sie nichts von Super __init__,brauchen, müssen Sie es nicht anrufen. Beispiel:

>>> class C(object):
        def __init__(self):
            self.b = 1


>>> class D(C):
        def __init__(self):
            super().__init__() # in Python 2 use super(D, self).__init__()
            self.a = 1


>>> class E(C):
        def __init__(self):
            self.a = 1


>>> d = D()
>>> d.a
1
>>> d.b  # This works because of the call to super's init
1
>>> e = E()
>>> e.a
1
>>> e.b  # This is going to fail since nothing in E initializes b...
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    e.b  # This is going to fail since nothing in E initializes b...
AttributeError: 'E' object has no attribute 'b'

__del__ist der gleiche Weg (aber seien Sie vorsichtig, wenn Sie sich __del__für die Finalisierung darauf verlassen - erwägen Sie dies stattdessen über die with-Anweisung).

Ich benutze selten __new__. die gesamte Initialisierung in__init__.

In Anons Antwort:
"Wenn Sie __init__zusätzlich zu dem, was in der aktuellen Klasse getan wird, etwas von Super's tun __init__müssen, müssen Sie es selbst nennen, da dies nicht automatisch geschieht."

Es ist unglaublich: Er formuliert genau das Gegenteil des Erbprinzips.

Es ist nicht so, dass "etwas von Super __init__ (...) nicht automatisch passiert" , es ist so, dass es automatisch passieren würde, aber es passiert nicht, weil die Basisklasse ' __init__durch die Definition der abgeleiteten Klassen überschrieben wird__init__

Warum also eine abgeleitete Klasse definieren __init__, da sie überschreibt, was angestrebt wird, wenn jemand auf Vererbung zurückgreift ?

Das liegt daran, dass man etwas definieren muss, das NICHT in der Basisklasse ausgeführt wird __init__, und die einzige Möglichkeit, dies zu erreichen, besteht darin, seine Ausführung in eine abgeleitete Klassenfunktion zu setzen __init__.
Mit anderen Worten, man braucht etwas in der Basisklasse " __init__zusätzlich zu dem, was automatisch in der Basisklasse gemacht wird", __init__wenn diese nicht überschrieben würde.
NICHT das Gegenteil.

Dann besteht das Problem darin, dass die gewünschten Anweisungen, die in der Basisklasse 'vorhanden __init__sind, zum Zeitpunkt der Instanziierung nicht mehr aktiviert werden. Um diese Inaktivierung auszugleichen, ist etwas Besonderes erforderlich: explizites Aufrufen der Basisklasse ' __init__, um die von der Basisklasse durchgeführte Initialisierung beizubehalten , NICHT ZU HINZUFÜGEN' __init__. Genau das steht im offiziellen Dokument:

Eine überschreibende Methode in einer abgeleiteten Klasse möchte möglicherweise die gleichnamige Basisklassenmethode erweitern, anstatt sie einfach zu ersetzen . Es gibt eine einfache Möglichkeit, die Basisklassenmethode direkt aufzurufen: Rufen Sie einfach BaseClassName.methodname (self, arguments) auf.
http://docs.python.org/tutorial/classes.html#inheritance

Das ist die ganze Geschichte:

• Wenn das Ziel darin besteht, die von der Basisklasse durchgeführte Initialisierung, dh die reine Vererbung, beizubehalten, ist nichts Besonderes erforderlich. Es muss lediglich vermieden werden, eine __init__Funktion in der abgeleiteten Klasse zu definieren

• Wenn das Ziel darin besteht, die von der Basisklasse durchgeführte Initialisierung zu ERSETZEN, __init__muss sie in der abgeleiteten Klasse definiert werden

• Wenn das Ziel darin besteht, Prozesse zu der von der Basisklasse durchgeführten Initialisierung hinzuzufügen, muss eine abgeleitete Klasse __init__ definiert werden, die einen expliziten Aufruf der Basisklasse umfasst__init__

Was ich an dem Posten von Anon erstaunlich finde, ist nicht nur, dass er das Gegenteil der Vererbungstheorie zum Ausdruck bringt, sondern dass 5 Leute an diesem Upvoted vorbeigegangen sind, ohne ein Haar zu drehen, und außerdem gab es in 2 Jahren niemanden, der darauf reagierte ein Thread, dessen interessantes Thema relativ oft gelesen werden muss.

Bearbeiten : (nach der Codeänderung)
Wir können Ihnen nicht sagen, ob Sie die Ihrer Eltern __init__(oder eine andere Funktion) aufrufen müssen oder nicht . Vererbung würde offensichtlich ohne einen solchen Anruf funktionieren. Es hängt alles von der Logik Ihres Codes ab: Wenn Sie __init__beispielsweise alles in der übergeordneten Klasse erledigen, können Sie die untergeordnete Klasse einfach ganz überspringen __init__.

Betrachten Sie das folgende Beispiel:

>>> class A:
    def __init__(self, val):
        self.a = val


>>> class B(A):
    pass

>>> class C(A):
    def __init__(self, val):
        A.__init__(self, val)
        self.a += val


>>> A(4).a
4
>>> B(5).a
5
>>> C(6).a
12

Es gibt keine feste Regel. In der Dokumentation für eine Klasse sollte angegeben werden, ob Unterklassen die Oberklassenmethode aufrufen sollen. Manchmal möchten Sie das Verhalten von Oberklassen vollständig ersetzen und zu anderen Zeiten erweitern - dh Ihren eigenen Code vor und / oder nach einem Aufruf von Oberklassen aufrufen.

Update: Die gleiche Grundlogik gilt für jeden Methodenaufruf. Konstruktoren müssen manchmal besonders berücksichtigt werden (da sie häufig einen verhaltensbestimmenden Zustand einrichten) und Destruktoren, da sie parallele Konstruktoren sind (z. B. bei der Zuweisung von Ressourcen, z. B. Datenbankverbindungen). Das Gleiche gilt beispielsweise beispielsweise für die render()Methode eines Widgets.

Weiteres Update: Was ist das OPP? Meinst du OOP? Nein - eine Unterklasse muss oft etwas über das Design der Oberklasse wissen . Nicht die internen Implementierungsdetails - sondern der Grundvertrag, den die Oberklasse mit ihren Kunden hat (unter Verwendung von Klassen). Dies verstößt in keiner Weise gegen die OOP-Prinzipien. Deshalb protectedist ein gültiges Konzept in OOP im Allgemeinen (obwohl natürlich nicht in Python).

IMO, du solltest es nennen. Wenn Ihre Superklasse ist object, sollten Sie nicht, aber in anderen Fällen denke ich, dass es außergewöhnlich ist, es nicht zu nennen. Wie bereits von anderen beantwortet, ist es sehr praktisch, wenn Ihre Klasse sich nicht einmal selbst überschreiben __init__muss, beispielsweise wenn sie keinen (zusätzlichen) internen Status zum Initialisieren hat.

Ja, Sie sollten die Basisklasse immer __init__explizit als gute Codierungspraxis aufrufen . Wenn Sie dies vergessen, kann dies zu subtilen Problemen oder Laufzeitfehlern führen. Dies gilt auch dann, wenn __init__keine Parameter verwendet werden. Dies ist anders als in anderen Sprachen, in denen der Compiler implizit den Basisklassenkonstruktor für Sie aufruft. Python macht das nicht!

Der Hauptgrund für den ständigen Aufruf der Basisklasse _init__besteht darin, dass die Basisklasse normalerweise eine Mitgliedsvariable erstellt und diese auf Standardwerte initialisiert. Wenn Sie also nicht die Basisklasse init aufrufen, wird kein Code ausgeführt, und Sie erhalten eine Basisklasse ohne Mitgliedsvariablen.

Beispiel :

class Base:
  def __init__(self):
    print('base init')

class Derived1(Base):
  def __init__(self):
    print('derived1 init')

class Derived2(Base):
  def __init__(self):
    super(Derived2, self).__init__()
    print('derived2 init')

print('Creating Derived1...')
d1 = Derived1()
print('Creating Derived2...')
d2 = Derived2()

Dies druckt ..

Creating Derived1...
derived1 init
Creating Derived2...
base init
derived2 init

Führen Sie diesen Code aus .