__Init __ () dovrebbe chiamare __init __ () della classe genitore?

Sono abituato che in Objective-C ho questo costrutto:

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

Python dovrebbe anche chiamare l'implementazione della classe genitore per __init__?

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

È vero / falso anche per __new__()e __del__()?

Modifica: c'è una domanda molto simile: Eredità e Sostituzione __init__in Python

In Python, chiamare la superclasse " __init__è facoltativo. Se lo chiami, è anche facoltativo se usare l' superidentificatore o se nominare esplicitamente la superclasse:

object.__init__(self)

In caso di oggetto, non è strettamente necessario chiamare il metodo super, poiché il metodo super è vuoto. Lo stesso per __del__.

D'altra parte, per __new__, dovresti davvero chiamare il metodo super e usare il suo ritorno come oggetto appena creato - a meno che tu non voglia esplicitamente restituire qualcosa di diverso.

Se hai bisogno di qualcosa di super __init__da fare in aggiunta a ciò che viene fatto nelle classi attuali, __init__,devi chiamarlo da solo, poiché ciò non accadrà automaticamente. Ma se non hai bisogno di qualcosa di super, __init__,non c'è bisogno di chiamarlo. Esempio:

>>> 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__è allo stesso modo ((ma __del__fai attenzione a fare affidamento per la finalizzazione - considera invece di farlo tramite la dichiarazione with).

Uso raramente __new__. faccio tutte le inizializzazioni in__init__.

Nella risposta di Anon:
"Se hai bisogno di qualcosa di super __init__da fare in aggiunta a ciò che viene fatto nelle lezioni attuali __init__, devi chiamarlo tu stesso, dal momento che ciò non accadrà automaticamente"

È incredibile: sta formulando esattamente il contrario del principio di eredità.

Non è che "qualcosa del super __init__ (...) non accadrà automaticamente" , è che DOVREBBE accadere automaticamente, ma non succede perché la classe base " __init__è sostituita dalla definizione del clas derivato__init__

Quindi, PERCHÉ definire un deriv_class ' __init__, dal momento che ignora ciò a cui si rivolge quando qualcuno ricorre all'eredità ??

È perché bisogna definire qualcosa che NON viene fatto nella classe base ' __init__, e l'unica possibilità per ottenerlo è quella di mettere la sua esecuzione in una __init__funzione di classe derivata .
In altre parole, uno ha bisogno di qualcosa nella classe base ' __init__in aggiunta a ciò che verrebbe fatto automaticamente nella classe base' __init__se quest'ultima non fosse sostituita.
NON il contrario.

Quindi, il problema è che le istruzioni desiderate presenti nella classe base ' __init__non vengono più attivate al momento dell'istanza. Per compensare questa inattivazione, è necessario qualcosa di speciale: chiamare esplicitamente la classe base ' __init__, per MANTENERE , NON AGGIUNGERE, l'inizializzazione eseguita dalla classe base' __init__. Questo è esattamente ciò che si dice nel documento ufficiale:

Un metodo prioritario in una classe derivata potrebbe infatti voler estendere piuttosto che semplicemente sostituire il metodo della classe base con lo stesso nome. Esiste un modo semplice per chiamare direttamente il metodo della classe di base: basta chiamare BaseClassName.methodname (sé, argomenti).
http://docs.python.org/tutorial/classes.html#inheritance

Questa è tutta la storia:

• quando l'obiettivo è MANTENERE l'inizializzazione eseguita dalla classe base, ovvero pura eredità, non è necessario nulla di speciale, si deve semplicemente evitare di definire una __init__funzione nella classe derivata

• quando l'obiettivo è SOSTITUIRE l'inizializzazione eseguita dalla classe base, __init__deve essere definita nella classe derivata

• quando lo scopo è quello di AGGIUNGERE i processi all'inizializzazione eseguita dalla classe base, è __init__ necessario definire una classe derivata " , comprendente una chiamata esplicita alla classe base__init__

Quello che mi sembra sorprendente nel post di Anon non è solo il fatto che esprima il contrario della teoria dell'eredità, ma che ci siano stati 5 ragazzi che lo hanno votato senza girare i capelli, e inoltre non c'è stato nessuno a cui reagire in 2 anni una discussione il cui argomento interessante deve essere letto relativamente spesso.

Modifica : (dopo la modifica del codice)
Non c'è modo per noi di dirti se hai bisogno o meno di chiamare i tuoi genitori __init__(o qualsiasi altra funzione). L'ereditarietà ovviamente funzionerebbe senza tale chiamata. Tutto dipende dalla logica del tuo codice: ad esempio, se tutto __init__è fatto in classe genitore, puoi semplicemente saltare del __init__tutto la classe figlio .

considera il seguente esempio:

>>> 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

Non esiste una regola dura e veloce. La documentazione per una classe dovrebbe indicare se le sottoclassi devono chiamare il metodo superclasse. A volte si desidera sostituire completamente il comportamento della superclasse e altre volte aumentarlo, ovvero chiamare il proprio codice prima e / o dopo una chiamata della superclasse.

Aggiornamento: la stessa logica di base si applica a qualsiasi chiamata di metodo. I costruttori a volte hanno bisogno di una considerazione speciale (poiché spesso impostano lo stato che determina il comportamento) e i distruttori perché sono costruttori paralleli (ad es. Nell'allocazione delle risorse, ad es. Connessioni al database). Ma lo stesso potrebbe valere, per esempio, per il render()metodo di un widget.

Ulteriore aggiornamento: cos'è l'OPP? Intendi OOP? No - una sottoclasse spesso deve sapere qualcosa sul design della superclasse. Non i dettagli dell'implementazione interna, ma il contratto di base che la superclasse ha con i suoi clienti (usando le classi). Ciò non viola in alcun modo i principi OOP. Ecco perché protectedè un concetto valido in OOP in generale (sebbene non, ovviamente, in Python).

IMO, dovresti chiamarlo. Se la tua superclasse è object, non dovresti, ma in altri casi penso che sia eccezionale non chiamarla. Come già risposto da altri, è molto conveniente se la tua classe non deve nemmeno sovrascrivere __init__se stessa, ad esempio quando non ha uno stato interno (aggiuntivo) da inizializzare.

Sì, dovresti sempre chiamare __init__esplicitamente la classe base come una buona pratica di codifica. Dimenticare di fare ciò può causare problemi sottili o errori di runtime. Questo è vero anche se__init__ non accetta alcun parametro. Questo è diverso da altri linguaggi in cui il compilatore chiamerebbe implicitamente il costruttore della classe base per te. Python non lo fa!

Il motivo principale per cui si chiama sempre la classe base _init__ è che la classe base può in genere creare una variabile membro e inizializzarla sui valori predefiniti. Quindi se non chiami init di classe base, nessuno di quel codice verrebbe eseguito e finiresti con una classe base che non ha variabili membro.

Esempio :

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()

Questo stampa ..

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

Esegui questo codice .