Чи повинен __init __ () викликати батьківський клас __init __ ()?

Я використовую, що в Objective-C у мене є така конструкція:

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

Чи повинен Python також викликати реалізацію батьківського класу __init__?

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

Це також правда / неправда для __new__()і __del__()?

Редагувати: Є дуже схоже питання: Спадщина та переосмислення __init__в Python

У Python виклик суперкласу ' __init__необов’язковий. Якщо ви її називаєте, то також необов'язково використовувати superабо ідентифікатор, або явно називати суперклас:

object.__init__(self)

У випадку об'єкта викликати супер метод не є строго необхідним, оскільки супер метод порожній. Те саме для __del__.

З іншого боку, бо __new__, ви дійсно повинні викликати супер-метод і використовувати його повернення як новостворений об'єкт - якщо тільки ви явно не хочете повернути щось інше.

Якщо вам потрібно зробити щось із супер- __init__класу на додаток до того, що робиться в поточному класі, __init__,ви повинні назвати його самостійно, оскільки це не відбудеться автоматично. Але якщо вам нічого не потрібно від супер, __init__,не потрібно це називати. Приклад:

>>> 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__той же самий спосіб (але будьте обережні, покладаючись на __del__остаточне завершення - подумайте про те, як це зробити через оператор with).

Я рідко використовую, __new__. я роблю всю ініціалізацію в__init__.

У відповідь Анона:
"Якщо вам потрібно зробити щось із супер- __init__класу __init__, крім того, що робиться в поточному класі , ви повинні зателефонувати самі, оскільки це не відбудеться автоматично"

Це неймовірно: він формулює точно протилежний принцип успадкування.

Це не те, що "щось із супер __init__ (...) не відбудеться автоматично" , це те, що воно буде автоматично, але це не відбувається, тому що базовий клас " __init__переосмислюється визначенням похідних класів__init__

Тоді ЧОМУ визначаючи похідний_клас ' __init__, оскільки він перекриває те, на що спрямований, коли хтось вдається до спадщини ??

Це тому, що потрібно визначити щось, що НЕ робиться в базовому класі ' __init__, і єдина можливість отримати це - поставити його виконання у функцію похідного класу' __init__.
Іншими словами, потрібно щось у базовому класі " __init__на додаток до того, що автоматично робиться в базовому класі", __init__якби цей останній не був відмінений.
НЕ навпаки.

Тоді проблема полягає в тому, що бажані вказівки, присутні в базовому класі ' __init__, більше не активуються в момент інстанції. Для того, щоб компенсувати цю інактивацію, потрібно щось особливе: явно викликати базовий клас ' __init__, щоб ЗБЕРІГАТИ , НЕ ДОДАТИ, ініціалізацію, виконану базовим класом' __init__. Саме так сказано в офіційному документі:

Переважний метод у похідному класі може насправді хотіти розширити, а не просто замінити метод однойменного базового класу . Існує простий спосіб прямого виклику методу базового класу: просто зателефонуйте BaseClassName.methodname (self, аргументи).
http://docs.python.org/tutorial/classes.html#inheritance

Ось і вся історія:

• коли мета KEEP - ініціалізація, виконана базовим класом, це чисте успадкування, нічого особливого не потрібно, потрібно просто уникати визначення __init__ функції у похідному класі

• коли мета - ЗАМІНА ініціалізації, виконаної базовим класом, __init__повинна бути визначена у похідному класі

• коли метою є додавання процесів ADD до ініціалізації, що виконується базовим класом, __init__ повинен бути визначений похідний клас ' , що містить явний виклик базового класу__init__

Що я дивуюсь на посаді Анона - це не тільки те, що він висловлює протилежність теорії спадкування, але й те, що через них було порушено 5 хлопців, не обернувшись волоссям, і більше того, що за два роки в них ніхто не реагував нитка, цікаву тему якої треба читати порівняно часто.

Редагувати : (після зміни коду)
Немає способу сказати вам, чи потрібно вам дзвонити __init__(чи будь-яка інша функція) чи не потрібно дзвонити батькові . Спадкування очевидно спрацювало б без такого заклику. Все залежить від логіки вашого коду: наприклад, якщо все ваше __init__робиться в батьківському класі, ви можете просто пропустити дочірній клас __init__взагалі.

розглянемо наступний приклад:

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

Не існує жорсткого і швидкого правила. Документація до класу повинна вказувати, чи повинні підкласи викликати метод надкласу. Іноді ви хочете повністю замінити поведінку надкласових класів, а в інший час її доповнювати - тобто називати власний код до та / або після виклику надкласового класу.

Оновлення: та ж основна логіка застосовується до будь-якого виклику методу. Конструктори іноді потребують особливої ​​уваги (оскільки вони часто встановлюють стан, що визначає поведінку) та деструкторів, оскільки вони паралельні конструкторам (наприклад, при розподілі ресурсів, наприклад, підключення до бази даних). Але те саме може стосуватися, скажімо, і доrender() методу віджета.

Подальше оновлення: що таке OPP? Ви маєте на увазі ООП? Ні - підкласу часто потрібно щось знати про дизайн надкласу. Не внутрішні деталі впровадження - а базовий договір, який має суперклас зі своїми клієнтами (використовуючи класи). Це жодним чином не порушує принципів ООП. Ось чому protectedце дійсна концепція в ООП взагалі (хоча, звичайно, не в Python).

ІМО, ви повинні це назвати. Якщо ваш суперклас є object, ви не повинні, але в інших випадках я вважаю, що винятково його не називати. Як уже відповіли інші, це дуже зручно, якщо ваш клас навіть не повинен перекривати __init__себе, наприклад, коли у нього немає (додаткового) внутрішнього стану для ініціалізації.

Так, ви завжди повинні __init__чітко називати базовий клас доброю практикою кодування. Якщо забути це зробити, це може спричинити тонкі проблеми або помилки часу роботи. Це вірно, навіть якщо __init__не приймає жодних параметрів. Це на відміну від інших мов, де компілятор неявно називав би конструктор базового класу для вас. Python цього не робить!

Основна причина завжди викликати базовий клас _init__полягає в тому, що базовий клас може зазвичай створювати змінну члена та ініціалізувати їх до значень за замовчуванням. Отже, якщо ви не викликаєте базовий клас init, жоден із цього коду не буде виконаний, і ви отримаєте базовий клас, який не має змінних членів.

Приклад :

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

Це відбитки ..

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

Запустіть цей код .