Як супер () Python працює з багаторазовим успадкуванням?

Я досить новий у об'єктно-орієнтованому програмуванні Python, і у мене виникають проблеми з розумінням super()функції (нові класи стилів), особливо коли мова йде про багаторазове успадкування.

Наприклад, якщо у вас є щось на кшталт:

class First(object):
    def __init__(self):
        print "first"

class Second(object):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print "that's it"

Що я не отримую: це Third()клас успадкує обидва конструкторські методи? Якщо так, то який із них буде запускатися з Super () і чому?

А що, якщо ви хочете запустити інший? Я знаю, що це має відношення до порядку вирішення методу Python ( MRO ).

Про це детально роз'яснюється з досить розумною деталізацією самого Гвідо в своєму дописі про блог Методичне рішення (включаючи дві попередні спроби).

У вашому прикладі Third()зателефонуйте First.__init__. Python шукає кожен атрибут у батьків класу, оскільки вони перераховані зліва направо. У цьому випадку ми шукаємо __init__. Отже, якщо ви визначаєте

class Third(First, Second):
    ...

Python почне з перегляду First, а якщо Firstатрибут не має, то він погляне на Second.

Ця ситуація стає більш складною, коли спадкування починає схрещувати шляхи (наприклад, якщо вони Firstуспадковані від Second). Прочитайте вищенаведене посилання для більш детальної інформації, але, коротко кажучи, Python намагатиметься підтримувати порядок, у якому кожен клас відображається у списку спадкування, починаючи з самого дочірнього класу.

Так, наприклад, якщо у вас були:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First):
    def __init__(self):
        print "third"

class Fourth(Second, Third):
    def __init__(self):
        super(Fourth, self).__init__()
        print "that's it"

МРО буде [Fourth, Second, Third, First].

До речі: якщо Python не зможе знайти узгоджений порядок вирішення методу, він створить виняток, замість того, щоб повернутися до поведінки, яка може здивувати користувача.

Відредаговано, щоб додати приклад неоднозначного MRO:

class First(object):
    def __init__(self):
        print "first"

class Second(First):
    def __init__(self):
        print "second"

class Third(First, Second):
    def __init__(self):
        print "third"

Чи повинен Thirdбути МРО [First, Second]чи [Second, First]? Очевидних очікувань немає, і Python створить помилку:

TypeError: Error when calling the metaclass bases
    Cannot create a consistent method resolution order (MRO) for bases Second, First

Редагувати: Я бачу декількох людей, які стверджують, що у прикладах вище відсутні бракує super()дзвінків, тому дозвольте мені пояснити: Суть прикладів - показати, як будується МРО. Вони не призначені для друку "першої \ n секунди \ третьої" чи будь-чого іншого. Можна, і, звичайно, потрібно пограти з прикладом, додавати super()дзвінки, бачити, що відбувається, і глибше розуміти модель успадкування Python. Але моя мета тут - зробити це просто і показати, як будується МРО. І він побудований так, як я пояснив:

>>> Fourth.__mro__
(<class '__main__.Fourth'>,
 <class '__main__.Second'>, <class '__main__.Third'>,
 <class '__main__.First'>,
 <type 'object'>)

Ваш код та інші відповіді - це баггі. Вони відсутні у super()викликах у перших двох класах, які потрібні для кооперативного підкласу для роботи.

Ось фіксована версія коду:

class First(object):
    def __init__(self):
        super(First, self).__init__()
        print("first")

class Second(object):
    def __init__(self):
        super(Second, self).__init__()
        print("second")

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print("third")

super()Виклик знаходить наступний метод в MRO на кожен крок, тому перші і другі повинні мати це теж, в іншому випадку виконання зупиняється в кінці Second.__init__().

Ось що я отримую:

>>> Third()
second
first
third

Я хотів трохи уточнити відповідь, бо коли я почав читати про те, як використовувати super () в ієрархії множинних успадковувань на Python, я не отримав її негайно.

Вам потрібно зрозуміти, що super(MyClass, self).__init__()надає наступний __init__ метод відповідно до використовуваного алгоритму впорядкування методу роздільної здатності (MRO) у контексті повної ієрархії успадкування .

Ця остання частина має вирішальне значення для розуміння. Розглянемо приклад ще раз:

#!/usr/bin/env python2

class First(object):
  def __init__(self):
    print "First(): entering"
    super(First, self).__init__()
    print "First(): exiting"

class Second(object):
  def __init__(self):
    print "Second(): entering"
    super(Second, self).__init__()
    print "Second(): exiting"

class Third(First, Second):
  def __init__(self):
    print "Third(): entering"
    super(Third, self).__init__()
    print "Third(): exiting"

Згідно з цією статтею про наказ щодо вирішення методу Гвідо ван Россума, порядок вирішення __init__розраховується (до Python 2.3), використовуючи "перехід вліво-вправо по глибині":

Third --> First --> object --> Second --> object

Після видалення всіх дублікатів, крім останнього, ми отримуємо:

Third --> First --> Second --> object

Отже, давайте слідкуємо за тим, що відбувається, коли ми інстанціюємо екземпляр Thirdкласу, наприклад x = Third().

1. За даними МРО Third.__init__.
   • відбитки Third(): entering
   • потім super(Third, self).__init__()виконує і MRO повертає First.__init__виклик.
2. First.__init__ виконує.
   • відбитки First(): entering
   • потім super(First, self).__init__()виконує і MRO повертає Second.__init__виклик.
3. Second.__init__ виконує.
   • відбитки Second(): entering
   • потім super(Second, self).__init__()виконує і MRO повертає object.__init__виклик.
4. object.__init__ виконує (в коді немає виписок про друк)
5. виконання повертається до Second.__init__якого потім друкуєтьсяSecond(): exiting
6. виконання повертається до First.__init__якого потім друкуєтьсяFirst(): exiting
7. виконання повертається до Third.__init__якого потім друкуєтьсяThird(): exiting

Тут детально роз'яснюється, чому інстанція Третього () призводить до:

Third(): entering
First(): entering
Second(): entering
Second(): exiting
First(): exiting
Third(): exiting

Алгоритм MRO було вдосконалено з Python 2.3 і надалі добре працює у складних випадках, але я думаю, що використання "переходу вперед-зліва направо" + "видалення дублікатів очікується на останнє" все ще працює в більшості випадків (будь ласка коментар, якщо це не так). Обов’язково прочитайте допис у блозі від Guido!

Це відоме як Diamond Problem , на сторінці є запис на Python, але коротше кажучи, Python буде називати методи надкласу зліва направо.

Це те, як я вирішив питання про наявність декількох успадкованих з різними змінними для ініціалізації та наявності декількох MixIns з одним і тим же викликом функції. Я повинен був явно додати змінні до пройдених ** kwargs та додати MixIn інтерфейс, щоб бути кінцевою точкою для супервикликів.

Ось Aрозширюваний базовий клас Bі Cє класи MixIn, які забезпечують функцію f. Aі Bобидва очікують параметр vу своїх __init__і Cочікує w. Функція fприймає один параметр y. Qуспадковує від усіх трьох класів. MixInF- це інтерфейс Mixin для Bта C.

• Записна книжка IPython цього коду
• Github Repo з прикладом коду

class A(object):
    def __init__(self, v, *args, **kwargs):
        print "A:init:v[{0}]".format(v)
        kwargs['v']=v
        super(A, self).__init__(*args, **kwargs)
        self.v = v


class MixInF(object):
    def __init__(self, *args, **kwargs):
        print "IObject:init"
    def f(self, y):
        print "IObject:y[{0}]".format(y)


class B(MixInF):
    def __init__(self, v, *args, **kwargs):
        print "B:init:v[{0}]".format(v)
        kwargs['v']=v
        super(B, self).__init__(*args, **kwargs)
        self.v = v
    def f(self, y):
        print "B:f:v[{0}]:y[{1}]".format(self.v, y)
        super(B, self).f(y)


class C(MixInF):
    def __init__(self, w, *args, **kwargs):
        print "C:init:w[{0}]".format(w)
        kwargs['w']=w
        super(C, self).__init__(*args, **kwargs)
        self.w = w
    def f(self, y):
        print "C:f:w[{0}]:y[{1}]".format(self.w, y)
        super(C, self).f(y)


class Q(C,B,A):
    def __init__(self, v, w):
        super(Q, self).__init__(v=v, w=w)
    def f(self, y):
        print "Q:f:y[{0}]".format(y)
        super(Q, self).f(y)

Я розумію, що це не відповідає безпосередньо на super()питання, але я вважаю, що це досить актуально, щоб поділитися.

Існує також спосіб безпосередньо викликати кожен успадкований клас:

class First(object):
    def __init__(self):
        print '1'

class Second(object):
    def __init__(self):
        print '2'

class Third(First, Second):
    def __init__(self):
        Second.__init__(self)

Просто зауважте, що якщо ви зробите це таким чином, вам доведеться телефонувати кожен вручну, оскільки я впевнений, Firstщо __init__()його не викликають.

Загалом

Якщо припустити, що все походить з object(ви самостійно, якщо цього немає), Python розраховує порядок роздільної здатності методу (MRO) на основі дерева спадкування вашого класу. MRO задовольняє 3 властивості:

• Діти класу приходять перед батьками
• Ліві батьки виходять перед правими батьками
• Клас з’являється лише один раз у MRO

Якщо такого впорядкування немає, помилки Python. Внутрішня робота цього - це лінійка С3 походження класів. Про це читайте тут: https://www.python.org/download/releases/2.3/mro/

Таким чином, в обох наведених нижче прикладах це:

1. Дитина
2. Зліва
3. Правильно
4. Батьківський

Коли метод викликається, першим виникненням цього методу в МРО є той, який викликається. Будь-який клас, який не реалізує цей метод, пропускається. Будь-який виклик у superмежах цього методу викликає наступне виникнення цього методу в MRO. Отже, має значення як порядок розміщення класів у спадщині, так і куди ви ставите виклики superв методах.

З superпершим у кожному методі

class Parent(object):
    def __init__(self):
        super(Parent, self).__init__()
        print "parent"

class Left(Parent):
    def __init__(self):
        super(Left, self).__init__()
        print "left"

class Right(Parent):
    def __init__(self):
        super(Right, self).__init__()
        print "right"

class Child(Left, Right):
    def __init__(self):
        super(Child, self).__init__()
        print "child"

Child() Виходи:

parent
right
left
child

З superостаннім у кожному методі

class Parent(object):
    def __init__(self):
        print "parent"
        super(Parent, self).__init__()

class Left(Parent):
    def __init__(self):
        print "left"
        super(Left, self).__init__()

class Right(Parent):
    def __init__(self):
        print "right"
        super(Right, self).__init__()

class Child(Left, Right):
    def __init__(self):
        print "child"
        super(Child, self).__init__()

Child() Виходи:

child
left
right
parent

Щодо коментаря @ calfzhou , як завжди, ви можете використовувати **kwargs:

Приклад роботи в Інтернеті

class A(object):
  def __init__(self, a, *args, **kwargs):
    print("A", a)

class B(A):
  def __init__(self, b, *args, **kwargs):
    super(B, self).__init__(*args, **kwargs)
    print("B", b)

class A1(A):
  def __init__(self, a1, *args, **kwargs):
    super(A1, self).__init__(*args, **kwargs)
    print("A1", a1)

class B1(A1, B):
  def __init__(self, b1, *args, **kwargs):
    super(B1, self).__init__(*args, **kwargs)
    print("B1", b1)


B1(a1=6, b1=5, b="hello", a=None)

Результат:

A None
B hello
A1 6
B1 5

Ви також можете використовувати їх позиційно:

B1(5, 6, b="hello", a=None)

але ви повинні пам’ятати MRO, це дійсно заплутано.

Я можу трохи дратувати, але я помітив, що люди забувають щоразу використовувати *argsі **kwargsколи вони перекривають метод, хоча це одна з небагатьох дійсно корисних і розумних використання цих «магічних змінних».

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

Приклад:

class A(object):
    def __init__(self, **kwargs):
        print('A.__init__')
        super().__init__()

class B(A):
    def __init__(self, **kwargs):
        print('B.__init__ {}'.format(kwargs['x']))
        super().__init__(**kwargs)


class C(A):
    def __init__(self, **kwargs):
        print('C.__init__ with {}, {}'.format(kwargs['a'], kwargs['b']))
        super().__init__(**kwargs)


class D(B, C): # MRO=D, B, C, A
    def __init__(self):
        print('D.__init__')
        super().__init__(a=1, b=2, x=3)

print(D.mro())
D()

дає:

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
D.__init__
B.__init__ 3
C.__init__ with 1, 2
A.__init__

Виклик суперкласу __init__безпосередньо до більш прямого присвоєння параметрів є заманливим, але не вдається, якщо superв суперкласі є якийсь виклик та / або MRO змінюється, а клас A може викликатися кілька разів, залежно від реалізації.

На закінчення: кооперативне успадкування та супер та конкретні параметри для ініціалізації працюють не дуже добре разом.

class First(object):
  def __init__(self, a):
    print "first", a
    super(First, self).__init__(20)

class Second(object):
  def __init__(self, a):
    print "second", a
    super(Second, self).__init__()

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__(10)
    print "that's it"

t = Third()

Вихід є

first 10
second 20
that's it

Виклик Третьому () визначає init, визначений у Третьому. І заклик до супер у цій процедурі викликає init, визначений у First. MRO = [Перший, Другий]. Тепер виклик super in init, визначений у First, продовжить пошук MRO і знайде init, визначений у Second, і будь-який виклик super буде потрапляти на об'єкт за замовчуванням init . Я сподіваюся, що цей приклад прояснює концепцію.

Якщо ви не телефонуєте супер з Першого. Ланцюжок зупиняється, і ви отримаєте наступний вихід.

first 10
that's it

Навчаючись, я дізнаюся щось, що називається супер () вбудованою функцією, якщо не помиляюся. Виклик функції super () може допомогти успадковуванню пройти через батьківського і «побратимів» і допоможе вам бачити чіткіше. Я все ще початківець, але люблю ділитися своїм досвідом використання цього супер () в python2.7.

Якщо ви прочитали коментарі на цій сторінці, ви почуєте Порядок вирішення методу (MRO), метод, який є функцією, яку ви написали, MRO буде використовувати схему «Глибина-перший-вліво-вправо» для пошуку та запуску. Ви можете зробити більше досліджень з цього приводу.

Додавши функцію super ()

super(First, self).__init__() #example for class First.

Ви можете з'єднати кілька екземплярів та "родин" із super (), додавши в них кожного та кожного в них. І він виконає методи, пройде їх і переконається, що ви не пропустили! Однак, додавши їх до або після, це має значення, ви дізнаєтесь, чи зробили ви навчальні піхотехнічні вправи 44. Нехай забава починається !!

Беручи приклад нижче, ви можете скопіювати та вставити та спробувати запустити його:

class First(object):
    def __init__(self):

        print("first")

class Second(First):
    def __init__(self):
        print("second (before)")
        super(Second, self).__init__()
        print("second (after)")

class Third(First):
    def __init__(self):
        print("third (before)")
        super(Third, self).__init__()
        print("third (after)")


class Fourth(First):
    def __init__(self):
        print("fourth (before)")
        super(Fourth, self).__init__()
        print("fourth (after)")


class Fifth(Second, Third, Fourth):
    def __init__(self):
        print("fifth (before)")
        super(Fifth, self).__init__()
        print("fifth (after)")

Fifth()

Як це працює? Екземпляр п'ятого () буде таким. Кожен крок йде від класу до класу, де додана суперфункція.

1.) print("fifth (before)")
2.) super()>[Second, Third, Fourth] (Left to right)
3.) print("second (before)")
4.) super()> First (First is the Parent which inherit from object)

Батько був знайдений, і він продовжить третій та четвертий !!

5.) print("third (before)")
6.) super()> First (Parent class)
7.) print ("Fourth (before)")
8.) super()> First (Parent class)

Тепер доступ до всіх класів із супер () було доступно! Батьківський клас був знайдений та виконаний, і тепер він продовжує розблоковувати функцію у спадщинах для закінчення кодів.

9.) print("first") (Parent)
10.) print ("Fourth (after)") (Class Fourth un-box)
11.) print("third (after)") (Class Third un-box)
12.) print("second (after)") (Class Second un-box)
13.) print("fifth (after)") (Class Fifth un-box)
14.) Fifth() executed

Результат програми вище:

fifth (before)
second (before
third (before)
fourth (before)
first
fourth (after)
third (after)
second (after)
fifth (after)

Для мене додавання super () дозволяє зрозуміти, як python виконує моє кодування і переконається, що спадщина може отримати доступ до методу, який я призначив.

Я хотів би додати те, що говорить @Visionscaper вгорі:

Third --> First --> object --> Second --> object

У цьому випадку інтерпретатор не фільтрує об'єктний клас, оскільки його дублюється, а не його, тому що Second з’являється в голові, а не з'являється у хвостовій позиції в підмножині ієрархії. Хоча об'єкт з'являється лише в хвостових положеннях і не вважається сильним положенням в алгоритмі С3 для визначення пріоритету.

Лінеаризація (mro) класу C, L (C), є

• клас C
• плюс злиття
  • лінеаризація його батьків P1, P2, .. = L (P1, P2, ...) і
  • список його батьків P1, P2, ..

Лінійне об’єднання відбувається шляхом вибору загальних класів, які відображаються як голова списків, а не хвіст, оскільки порядок має значення (стане зрозуміло нижче)

Лінеаризацію Третього можна обчислити так:

    L(O)  := [O]  // the linearization(mro) of O(object), because O has no parents

    L(First)  :=  [First] + merge(L(O), [O])
               =  [First] + merge([O], [O])
               =  [First, O]

    // Similarly, 
    L(Second)  := [Second, O]

    L(Third)   := [Third] + merge(L(First), L(Second), [First, Second])
                = [Third] + merge([First, O], [Second, O], [First, Second])
// class First is a good candidate for the first merge step, because it only appears as the head of the first and last lists
// class O is not a good candidate for the next merge step, because it also appears in the tails of list 1 and 2, 
                = [Third, First] + merge([O], [Second, O], [Second])
// class Second is a good candidate for the second merge step, because it appears as the head of the list 2 and 3
                = [Third, First, Second] + merge([O], [O])            
                = [Third, First, Second, O]

Таким чином, для супер () реалізації в наступному коді:

class First(object):
  def __init__(self):
    super(First, self).__init__()
    print "first"

class Second(object):
  def __init__(self):
    super(Second, self).__init__()
    print "second"

class Third(First, Second):
  def __init__(self):
    super(Third, self).__init__()
    print "that's it"

стає очевидним, як вирішиться цей метод

Third.__init__() ---> First.__init__() ---> Second.__init__() ---> 
Object.__init__() ---> returns ---> Second.__init__() -
prints "second" - returns ---> First.__init__() -
prints "first" - returns ---> Third.__init__() - prints "that's it"

У python 3.5+ успадкування виглядає передбачувано і дуже приємно для мене. Будь ласка, подивіться на цей код:

class Base(object):
  def foo(self):
    print("    Base(): entering")
    print("    Base(): exiting")


class First(Base):
  def foo(self):
    print("   First(): entering Will call Second now")
    super().foo()
    print("   First(): exiting")


class Second(Base):
  def foo(self):
    print("  Second(): entering")
    super().foo()
    print("  Second(): exiting")


class Third(First, Second):
  def foo(self):
    print(" Third(): entering")
    super().foo()
    print(" Third(): exiting")


class Fourth(Third):
  def foo(self):
    print("Fourth(): entering")
    super().foo()
    print("Fourth(): exiting")

Fourth().foo()
print(Fourth.__mro__)

Виходи:

Fourth(): entering
 Third(): entering
   First(): entering Will call Second now
  Second(): entering
    Base(): entering
    Base(): exiting
  Second(): exiting
   First(): exiting
 Third(): exiting
Fourth(): exiting
(<class '__main__.Fourth'>, <class '__main__.Third'>, <class '__main__.First'>, <class '__main__.Second'>, <class '__main__.Base'>, <class 'object'>)

Як бачимо, він називає foo рівно ОДИН час для кожного успадкованого ланцюга в тому ж порядку, як і він був успадкований. Ви можете отримати це замовлення, зателефонувавши . мро :

Четвертий -> Третій -> Перший -> Другий -> База -> об'єкт

Можливо, є ще щось, що можна додати, невеликий приклад з Django rest_framework та декоратори. Це дає відповідь на неявне запитання: "чому я все-таки хочу цього?"

Як було сказано: ми з Django rest_framework, і ми використовуємо загальні представлення даних, і для кожного типу об’єктів у нашій базі даних ми опиняємося з одним класом перегляду, що забезпечує GET і POST для списків об'єктів, та іншим класом перегляду, що забезпечує GET , PUT та DELETE для окремих об'єктів.

Тепер POST, PUT і DELETE ми хочемо прикрасити Django з login_required. Зверніть увагу, як це стосується обох класів, але не всіх методів в обох класах.

Рішення може перейти через багаторазове успадкування.

from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required

class LoginToPost:
    @method_decorator(login_required)
    def post(self, arg, *args, **kwargs):
        super().post(arg, *args, **kwargs)

Так само і для інших методів.

У списку спадку моїх конкретних класів я б додав свої LoginToPostдо ListCreateAPIViewі LoginToPutOrDeleteраніше RetrieveUpdateDestroyAPIView. Мої конкретні заняття " getзалишалися б незатребуваними.

Опублікував цю відповідь для мого майбутнього реферату.

Python Multiple Inheritance має використовувати алмазну модель, і підпис функції не повинен змінюватися в моделі.

    A
   / \
  B   C
   \ /
    D

Фрагмент зразкового коду буде; -

class A:
    def __init__(self, name=None):
        #  this is the head of the diamond, no need to call super() here
        self.name = name

class B(A):
    def __init__(self, param1='hello', **kwargs):
        super().__init__(**kwargs)
        self.param1 = param1

class C(A):
    def __init__(self, param2='bye', **kwargs):
        super().__init__(**kwargs)
        self.param2 = param2

class D(B, C):
    def __init__(self, works='fine', **kwargs):
        super().__init__(**kwargs)
        print(f"{works=}, {self.param1=}, {self.param2=}, {self.name=}")

d = D(name='Testing')

Тут клас А є object