Что такое mro python

Порядок разрешения метода Python (MRO)

Сегодня мы собираемся посмотреть порядок разрешения метода Python или MRO для краткости. Если вы следуете за руководствами по классам Python и наследования, и вы практиковались в коде, вы поймете, что после того, как иерархия классов перемещается в несколько наследований, вы можете вернуть странные результаты или в конечном итоге с непонятными ошибками. … Подробнее … Подробнее … Python Method порядок (MRO) Подробнее »

Прочитайте эти статьи, если вам нужен переподготовка на классы Python и наследство. Не стесняйтесь следить за этим видео, как вы снимаете в статье:

Что такое разрешение метода Python (MRO)?

Когда мы называем атрибут или метод в классе с несколькими наследованиями, Python следует конкретному порядку при поиске элемента, который мы ищем. Этот заказ называется порядок разрешения метода, и он соответствует двум правилам:

Чтобы понять эти правила, у нас есть три концепции для изучения. __Bases__ атрибут, __mro__ атрибут, а Python встроенный супер класс «Объект».

Одна будьте здесь, есть два метода MRO в зависимости от версии Python, которую вы используете. Хотя разница между ними вряд ли порадует большинство из нас в повседневном использовании, я предполагаю, что если вы изучаете Python сегодня, вы используете версию 3.x, и по этой причине я поговорим с новым стилем классов в этой статье.

Что такое атрибут __bases__?

__Bases__ Атрибут – это встроенный класс Python, который выводят базовые классы любого Класс Вы называете это.

Давайте назовем __Bases__ Атрибут на примере нескольких наследований, чтобы увидеть вывод. Вот блок-схема того, что код будет отображаться. Два класса дедушек, протекающие в родительский класс, который затем проходит в детский класс.

И код здесь. Складские и складские классы – дедушка, класс продукции является родительским, а плоды – это ребенок.

Обратите внимание, что __Bases__ Звоните на фруктовые шоу продукты как Родитель Отказ Призыв __Bases__ на производить Класс возвращает сток и Склад как его Родитель Отказ Как указано в двух правилах ранее, сток и Склад Следовательно, порядок поиска, который будет следовать Python при поиске дерева.

Представляем атрибут __mro__

Этот атрибут только для чтения в Python, когда вызывается, возвращает кортеж Из классов, которые рассматриваются Python при поиске базовых классов во время разрешения метода. Давайте назовем __mro__ на сток Класс, который мы использовали в последнем примере, чтобы увидеть, что возвращает.

Обратите внимание, что в кортеже есть два предмета. Первый – это сток Класс, как вы ожидаете, как это нынешний класс. Но что упоминается класс объекта? сток Класс – это родительский класс и у него нет своих родителей, не так ли?

Python Base Object Object Class

Использование __mro__, чтобы увидеть порядок разрешения метода

Если мы вернемся в наш полный код, мы позвоним __mro__ Атрибут на дочернем классе, Фрукты и посмотрите, что возвращено.

Более сложные структуры

Наши примеры до сих пор были элементарными и необработанными, но что, если у нас будет немного сложная структура? Вот блок-схема, чтобы показать пример, чтобы помочь иллюстрировать, как Python работает за кулисами.

Тогда вот код, представленный этой блок-схемой.

Так что это интересно. Заказ следовал не то, что вы можете ожидать. Конечно, было бы более эффективно искать одну руку алмаза, из консервированного, на склад, затем на складе, прежде чем вернуться к поиску правой стороны через поставщик снова на складе?

Однако Python не может работать с двусмысленностью, и если бы искать, как описано, вы получите следующий заказ:

Это просто не работает, потому что при работе с наследством вопросов приоритета. Это означает, что у вас не может быть класс дедушка, например сток перед родительским классом, таким как поставщик. Или объект супер класса, впереди бабушка и родителя. Вот почему порядок разрешения метода определяется как:

Этот маршрут соответствует те двум правилам, которые мы ввели в начале этой статьи.

Почему MRO имеет значение?

Как только ваш код начнет становиться более сложным, с несколькими уровнями наследования, гибридных структур и вложенных классов, жизнь начинает становиться громоздким. Если классы используют один и тот же атрибут или имена методов, вы можете получить неприятный сюрприз при вызове метода или атрибута, только для возврата полностью неожиданного значения. Вы также можете получить сообщение об ошибке, когда Python не может разрешить двусмысленность или конфликт следующим образом.

Почему? Вот блок-схема.

Мы знаем, что более высокий класс не может прийти перед более низким классом, но это то, что мы просим, когда мы создали класс полки, используя полка (дистрибьютор, shop_dispatch) Отказ Есть два решения этой проблемы. Одним из них – это переодеться в скобные классы для чтения Полка (Shop_Dispatch, Дистрибьютор) Как показано здесь. Но вы исправляете за ловушку, которая может возникнуть с дальнейшими изменениями кода, оставив вас с грязным и возможно проблемным кодом.

Другой метод состоит в том, чтобы удалить класс дистрибьютора в качестве родителя полка Поскольку все атрибуты и методы доступны через иерархию. См. Следующий код, в котором мы сняли ссылку на класс дистрибьютора из полка класс. Чтобы доказать, что это работает, мы затем добавили метод в классе дистрибьютора, созданный объектом, используя полка Класс, затем называется методом метки с использованием нового объекта.

Тогда, если мы позвоним __mro__ Метод на полка Класс, который мы видим следующее возвращено.

Хороший, аккуратный и понятный код с четко определенным порядком разрешения метода.

Резюме

Источник

MRO – порядок разрешения методов в Python

Погорим о наследовании. Если один класс унаследован от другого, то он от него перенимает себе методы и атрибуты своего родителя. Вы, конечно, можете переопределить некоторые из них или добавить свою новую функциональность – в этом и есть смысл наследования. Но те методы, которые вы не переопределяли, так и останутся родительскими. Таким образом, когда вы вызываете метод экземпляра класса, Python должен посмотреть, есть ли в нем этот метод. Если есть – он и будет вызван, а если его нет, то ему придется проверить классы-родители данного класса. Вдруг, у них есть?

В коде выше ребенок играет, играть – это ему присущий метод. Но зарабатывать деньги он пока не умеет, но его родитель вполне может с этим справиться. Поэтому метод earn_money будет взят от родителя. Думаю, тут все ясно.

Сложнее ситуация становится, когда иерархия классов разрастается. Не будем забывать, что Python поддерживает множественное наследование, что сделает граф отношений между классами весьма запутанным. Методы с одинаковыми именами могут быть определены в любых классах из всей иерархии. И если ответ на вопрос «где искать?» довольно прост: сначала посмотри в самом классе, а потом в его родителях; то ответ на вопрос «в каком порядке искать?» не такой тривиальный. Например, взгляните на такую иерархия классов:

«Простой» пример

Сможет сходу назвать порядок поиска методов в этой иерархии? Я вот ошибся с первой попытки, и даже со второй. Узнаем правду методом mro():

Что же такое этот MRO?

Аббревиатура MRO – method resolution order. А по-русски это переводится как «порядок разрешения методов». Но! Тоже самое относится не только к методам, но и к прочим атрибутам класса, так как методы – это частный случай более общего понятия «атрибут».

Метод класса Z.mro() возвращает нам список классов ровно в том порядке, в котором Python будет искать методы в иерархии классов пока не найдет нужный или не выдаст ошибку.

Ромбовидное наследование

В более сложных иерархиях потребуется специальный алгоритм.

Алгоритм C3-линеаризации

Какие критерии должны быть для алгоритма разрешения методов?

Алгоритм, который удовлетворяет этим условиям был предложен в 1996 года и называется C3 superclass linearization. Линеаризация в данном случае – это процесс превращения графа наследования в плоский список. А С3 он называется из-за наличия трех основных свойств. Важнейшее свойство здесь – это монотонность – это свойство, которое требует соблюдения в линеаризации класса-потомка того же порядка следования классов-прародителей, что и в линеаризации класса-родителя.

В Python данный алгоритм появился еще в далекой версии 2.3.

Если вы обладаете навыками чтения английской технической литературы, то можете ознакомиться с оригиналом статьи, PDF я нашел на просторах интернета. Есть и замечательное описание алгоритма на русском языке в статье на Хабре. Там же есть и примеры составления линеаризаций.

Почему именно так?

Вернемся к исходному примеру.

Попробуем обосновать такой порядок. C начала, конечно же, положим в MRO-список оконечный класс Z. Потом класс K1, так как он идет первым в списке наследования Z. Далее, видим, что идет класс A. Этот класс больше никому не является родителем, кроме как K1, следовательно алгоритм добавляет A сразу после K1, не нарушив никаких правил. После A непосредственно не может идти класс B, так как за ним пришлось бы где-то еще воткнуть K2, и получилось бы так, что K2 будет позже B, что запрещено. Нет! Ставим тогда сначала K2, потом только B. Далее, по схожей причине нужно поставить K3, дабы он не оказался после своего родителя C. Дополняем список классами D и E в их порядке. И остается только завершить список классами O, который общий родитель для всех прочих классов, и object, который родитель для O. Как видите никакой родитель не стоит перед стоим потомком (но может стоять перед чужим). А также порядок следования классов в MRO согласован с порядком наследования.

Вариант реализации алгоритма и его работу на этом примере я разместил здесь (можно запустить и поиграться прямо браузере. Автор реализации – не я. Нашел на Github.

Когда нельзя линеаризовать?

Думаю, такой вопрос имеет место быть на собеседовании. Вас могут попросить привести пример иерархии классов, не поддающихся линеризации по стандартному алгоритму. Вот первый неразрешимый пример:

Или вот второй пример:

Как задать свой порядок MRO?

Это возможно, используя метаклассы. Для «конфликтного» класса мы определим особый метакласс, который переопределяет явно метод mro(), указывая вручную, какой именно должен быть порядок разрешения методов. На первом «неразрешимом» примере решение будет такое:

Ты super()!

Иногда требуется обратиться к родительскому классу из дочернего. Например, если дочерний класс переопределяет метод инициализации, то ему, как правило, следует вызвать инициализатор родительского класса. Делать по имени класса не очень удобно и порождает кучу проблем и багов, особенно, если наследование множественное, и мы мало что знаем об устройстве и родственных связях наследуемых классов. Тем более если со временем иерархия измениться, нужно будет поддерживать все вызовы в актуальном состоянии. Поэтому плохо писать так:

Гораздо удобнее обратиться к следующему в цепочка MRO классу-родителю через super().

super() – это особенный прокси-класс к нужному родительскому классу. Вот так правильно можно обратиться к родительскому классу:

В родительских классах тоже используется super(), поэтому все инициализаторы сработают в порядке MRO.

Специально для канала @pyway. Подписывайтесь на мой канал в Телеграм @pyway 👈

Источник

Порядок разрешения методов (MRO) в Python в множественном наследовании

В этом руководстве мы узнаем о порядке разрешения методов, который также известен как MRO. Это важная концепция наследования Python.

Порядок разрешения методов (MRO) в Python описывает путь поиска класса, который используется для получения соответствующего метода в классах, содержащих множественное наследование.

Вступление

Как мы знаем, наследуемый класс называется родительским классом или подклассом, а наследующий класс называется дочерним классом или подклассом. При множественном наследовании класс может состоять из многих функций, поэтому метод порядка разрешения методов используется для поиска порядка, в котором выполняется базовый класс.

Проще говоря, метод или атрибуты исследуются в текущем классе, если метод отсутствует, поиск переходит к родительским классам и так далее. Это пример поиска в глубину.

Он играет важную роль в множественном наследовании, когда один и тот же метод можно найти в нескольких суперклассах.

Чтобы лучше понять это, давайте посмотрим, как мы можем его использовать.

В приведенном выше коде присутствует множественное наследование. Мы определили три класса с именами A, B и C, и эти классы имеют одноименный метод myname(). Мы создали объект класса C. Объект вызвал класс C, в то время как класс C унаследовал метод класса A.

Давайте разберемся с еще одним примером множественного наследования.

В приведенном выше коде мы создали еще один класс D без определения атрибутов класса, унаследовавших классы B и C. Когда мы вызываем метод myname(), он переходит к классу D и ищет функцию myname(). Но у класса D нет объявления. Следовательно, поиск переходит к классу B, получает функцию myname() и возвращает результат. Поиск будет происходить следующим образом.

Если у класса B не будет метода, он вызовет метод класса C.

Здесь мы предлагаем вам удалить метод класса B и проверить, что происходит. Сделав это, вы получите представление о том, как работает разрешение метода.

Порядок старого и нового стиля

В более старой версии Python (2.1) мы ограничены использованием старых классов, но в Python версии 2.2 и новее мы можем использовать новые классы. По умолчанию в Python 3 есть оригинальные (новые) классы. Первый родительский элемент нового класса стиля наследуется от корневого класса «объект» Python. Давайте посмотрим на следующий пример –

Стиль объявления обоих классов разный. В разрешении метода классы старого стиля следуют алгоритму «сначала в глубину» слева направо (DLR), тогда как классы нового стиля используют алгоритм линеаризации C3 при выполнении множественного наследования.

Алгоритм DLR

Python создает список классов при реализации множественного наследования между классами. Этот список используется для определения того, какой метод должен быть вызван экземплярами.

Мы можем предположить, что работая от его имени, разрешение метода будет сначала искать в глубину, а затем идти слева направо. Ниже приведен пример.

Сначала алгоритм будет искать вызванный метод в классе экземпляра. Если не найдет, он переходит к первому родительскому классу. Затем обратиться к родителям родительского класса. Так будет продолжаться до конца наследования классов.

В приведенном примере приведен порядок разрешения метода:

Но A не может присутствовать дважды, поэтому –

Этот алгоритм показывает странное поведение в то время. Давайте посмотрим на пример ниже.

Согласно алгоритму DLR, порядок будет E, C, D, B, A. В классе C происходит обмен классами A и B, что очень неоднозначно. Значит, алгоритм не сохраняет свойство монотонности.

Самуэле Пердони был первым человеком, обнаружившим несоответствие между алгоритмами MRO.

Алгоритм линеаризации C3

Алгоритм линеаризации C3 – лучшая версия алгоритма DLR, поскольку он устраняет несогласованность. Этот алгоритм имеет некоторые ограничения, которые приведены ниже.

Правила алгоритма линеаризации C3

Способ для порядка разрешения метода

Python предоставляет два способа получить порядок разрешения метода класса – атрибут __mro__ или метод mro(). С помощью этих методов мы можем отобразить порядок методов, в которых они разрешены.

Давайте разберемся в следующем примере.

Как видно из вышеприведенного вывода, мы получаем порядок разрешения метода. Таким образом, алгоритм линеаризации C3 работает для множественного наследования.

Источник

Множественное наследование классов.

Python также поддерживает форму множественного наследования. Определение класса с несколькими базовыми классами выглядит следующим образом:

Чтобы предотвратить повторный доступ к базовым классам, динамический алгоритм линеаризует порядок поиска таким образом, чтобы сохранить порядок слева направо, указанный в каждом классе, который вызывает каждого родителя только один раз и является монотонным. Это означает, что класс может быть подклассом, не затрагивая порядок приоритета его родителей. В совокупности эти свойства позволяют создавать надежные и расширяемые классы с множественным наследованием.

Например:

Не все классы поддаются линеаризации алгоритмом MRO.

Вот как работает алгоритм линеаризации для определения пути поиска в символической нотации (для примера выше):

Дальше объявляем класс следующим образом:

Обратите внимание, что если вы берёте на себя ответственность за MRO, Python не проводит никаких дополнительных проверок и можно спокойно провести поиск в предках раньше чем в потомках. И хотя это не желательная практика, но это возможно.

Осложнения в множественном наследовании Python.

Что происходит, когда классы, от которых происходит наследование, имеют общий атрибут? Чье значение принимает дочерний класс? Давайте возьмем три класса А, В и С.

Как мы видим, класс, названный первым в наследовании, передает свое значение дочернему классу для общего атрибута. То же самое происходит и с методами/функциями класса Python.

Источник

Порядок разрешения методов в Python

В этой заметке рассматривается алгоритм MRO С3 и некоторые специфические проблемы множественного наследования. Хотя и алгоритм и проблемы не ограничиваются рамками одного языка, я акцентировал своё внимание на Питоне. В конце приведён список полезных ссылок по данной теме.

Порядок разрешения методов (method resolution order) позволяет Питону выяснить, из какого класса-предка нужно вызывать метод, если он не обнаружен непосредственно в классе-потомке. Если у каждого потомка есть только один предок, то задача тривиальна. Происходит восходящий поиск по всей иерархии. Если же используется множественное наследование, то можно столкнуться со специфическими проблемами, которые описаны ниже.

В старых версиях Питона порядок разрешения методов был достаточно примитивным: поиск вёлся во всех родительских классах слева направо на максимальную глубину. Т.е. если у родительского класса в свою очередь не было нужного метода, но были родители, то поиск производился в них по тем же правилам. Для примера возмём структуру:

При обращении к методу экземпляра класса E такой алгоритм произвёл бы поиск последовательно в классах E, B, A, D и C. Таким образом поиск вёлся сначала в первом классе-родителе и во всех его предках, затем во втором классе-родителе со всеми предками и т. д. Этот способ не вызывал особых нареканий, пока у классов не было общего предка. Однако, начиная с версии 2.2, появился базовый класс object, от которого рекомендовалось наследовать все пользовательские классы. Зачем его ввели — тема для отдельной статьи. Пожалуй, наиболее существенным фактором можно назвать разделение объектной модели и модели мета-данных. Начиная с версии 3.0, старые классы больше не поддерживаются, а все пользовательские классы по умолчанию происходят от класса object.

Это породило проблему «ромбовидной структуры» («diamond diagram»).

Если у нас есть классы A и B, от которых наследуется класс C, то при поиске метода по старому алгоритму (C, A, object, B) получается, что если метод не определён в классах C и A он будет извлечён из object, даже если он определён в B. Это создаёт определённые неудобства, т.к. в object определены многие магические методы, типа __init__, __str__ и т.п. Но даже если object заменить на некий пользовательский класс D, то проблема останется — менее специфичный метод класса-предка может отработать вместо более специфичного метода класса-потомка.

Итак, у нас на руках есть сам класс, список всех его предков и связей между ними. Из этих данных нам нужно построить упорядоченный список классов, в которых будет производиться поиск метода слева направо. Такой список называется линеаризацией класса. Для простоты возьмем структуру:

Тогда линеаризацией для класса B будет список [B, A, object]. Т.е. при вызове B().something() метод сначала будет искаться в классе B. Если он там не найден, то поиск продолжится в классе A. Если его нет и там, то поиск завершится в классе object. Перебрав все классы из линеаризации и не обнаружив нужного метода, Питон выкинет ошибку Attribute Error.

Для решения проблемы ромбовидной структуры линеаризация должна быть монотонной. Это значит, что если в линеаризации некого класса C класс A следует за классом B (она имеет вид [C, …, B, …, A]), то и для любого его потомка D класс B будет следовать за A в его линеаризации (она будет иметь вид [D, …, C, …, B, …, A]). Как вы можете видеть, старый порядок разрешения методов не монотонен, т.к. в случае ромбовидной структуры для класса A линеаризация есть [A, object], для класса B — [B, object], но для класса C — [C, A, object, B], что нарушает свойство монотонности по отношению к классу B.

Для удовлетворения свойству монотонности в этом случае подойдут две линеаризации: [C, A, B, object] и [C, B, A, object]. Очевидно, что они обе не нарушают монотонности ни в отношении класса A (т.к. object следует за A в обоих случаях), ни в отношении класса B (т.к. object следует за B в обоих случаях). Так какую из них выбрать? В этом случае наиболее интуитивно-понятный способ — посмотреть на определение класса C. Если класс объявлен как C(A, B), то разумно будет взять первую линеаризацию, поскольку в ней B следует за A. Если класс объявлен как C(B, A), то будет лучше взять вторую линеаризацию, в которой A следует за B.

Такой выбор определяется порядком локального старшинства (local precedence ordering). Свойство порядка локального старшинства требует соблюдения для классов-родителей в линеаризации класса-потомка того же порядка, что и при его объявлении. Например, если класс объявлен как D(A, B, C), то в линеаризации D класс A должен стоять раньше B, а класс B — раньше C.

Алгоритм порядка разрешения методов C3.

Для достижения указанных выше целей в Питоне используется алгоритм C3. Он достаточно прост, однако для лучшего понимания введём следующие условные обозначения:
[C1, C2, … CN] – список из элементов C1, C2, … CN. Соответственно, [С] — список из одного элемента C.
L[C] – линеаризация класса C. Важно помнить, что любая линеаризация есть список по определению.
merge(L[C1], L[C2], …, L[CN]) – объединение элементов линеаризаций L[C1], L[C2], …, L[CN] в список с помощью некоторого алгоритма. По сути, этот алгоритм должен упорядочить все классы из L[C1], L[C2], …, L[CN] и исключить дублирование классов в итоговом списке.

Наибольший интерес представляет процесс объединения, так что разберём его более подробно. В случаях L[A] и L[B] выражение merge(L[object], [object]) = merge([object], [object]) раскрывается тривиально. Поскольку и первый и второй списки состоят из одного элемента object, по пункту 4 правила объединения результатом будет [object].

Запишем линеаризацию L[C]:
L[C] = [C] + merge(L[D], L[E], [D, E])
L[E] = [E] + merge(L[D], [D])
L[D] = [D] + merge(L[object], [object]) = [D, object]

Проведём подстановки и получим:
L[E] = [E] + merge([D, object], [D]) = [E, D, object]
L[C] = [C] + merge([D, object], [E, D, object], [D, E])

Теперь посмотрите, что мы получили. Объединение merge([D, object], [E, D, object], [D, E]) не может быть завершено, поскольку в списках [D, object] и [D, E] нулевым элементом является D, которое является первым элементом списка [E, D, object]. И наоборот, E, являющееся нулевым элементом [E, D, object] одновременно является и первым элементом [D, E]. Таким образом, через 3 итерации алгоритм придёт к пункту 5, после чего Питон выкинет ошибку TypeError: Cannot create a consistent method resolution order (MRO) for bases D, E. Если бы наше объединение не заканчивалось списком родителей, то мы бы получили нарушение порядка локального старшинства: L[C] = [C] + merge([D, object], [E, D, object]) = [C] + [E] + merge([D, object], [D, object]) = [C] + [E, D] + [object] = [C, E, D, object]. При такой линеаризации класса C поиск вёлся бы сначала в классе E, а потом в классе D, хотя в объявлении было записано C(D, E).

Решить эту проблему не сложно. Достаточно переписать объявление на class C(E, D). В таком случае мы получим:
L[C] = [C] + merge([E, D, object], [D, object], [E, D]) = [C] + [E] + merge([D, object], [D, object], [D]) = [C] + [E, D, object] = [C, E, D, object].
По сути ничего не изменилось, за исключением того, что в объявлении класса порядок перечисления родителей получился таким же, как и в линеаризации класса, т.е. соблюдается порядок локального старшинства. Надо отметить, что хотя Питон и намекает, в каком порядке логичнее было бы указать родителей, он не станет мешать вам искать приключений, если вы объявите свой собственный MRO через метакласс. Но об этом ближе к концу.

Питон вычисляет линеаризацию один раз при создании класса. Если вы хотите её получить для самопроверки или каких-то других целей — используйте свойство класса __mro__ (например, C.__mro__). Чтобы закрепить материал разберём примеры позаковыристее. Класс object умышленно выброшен, чтобы не загромождать линеаризации. Как известно из сказанного выше, при одиночном наследовании классы просто выстраиваются в цепочку от потомка к предкам, так что object всегда будет находиться в конце любой цепочки. И ещё. Я не кулинар и не музыкант, так что примеры — это всего лишь примеры. Не стоит акцентировать своё внимание на смысловых неточностях в них.

class Music (object): pass
class Rock (Music): pass
class Gothic (Music): pass
class Metal (Rock): pass
class GothicRock (Rock, Gothic): pass
class GothicMetal (Metal, Gothic): pass
class The69Eyes (GothicRock, GothicMetal): pass

L[The69Eyes] = [The69Eyes] + merge(L[GothicRock], L[GothicMetal], [GothicRock, GothicMetal])
L[GothicRock] = [GothicRock] + merge(L[Rock], L[Gothic], [Rock, Gothic])
L[GothicMetal] = [GothicMetal] + merge(L[Metal], L[Gothic], [Metal, Gothic])
L[Rock] = [Rock, Music]
L[Gothic] = [Gothic, Music]
L[Metal] = [Metal] + [Rock, Music] = [Metal, Rock, Music]

После подстановок получаем:
L[GothicRock] = [GothicRock] + merge([Rock, Music], [Gothic, Music], [Rock, Gothic]) = [GothicRock, Rock, Gothic, Music]
L[GothicMetal] = [GothicMetal] + merge([Metal, Rock, Music], [Gothic, Music], [Metal, Gothic]) = [GothicMetal] + [Metal, Rock, Gothic, Music] = [GothicMetal, Metal, Rock, Gothic, Music]
L[The69Eyes] = [The69Eyes] + merge([GothicRock, Rock, Gothic, Music], [GothicMetal, Metal, Rock, Gothic, Music], [GothicRock, GothicMetal])
= [The69Eyes] + [GothicRock, GothicMetal] + merge([Rock, Gothic, Music], [Metal, Rock, Gothic, Music])
= [The69Eyes] + [GothicRock, GothicMetal, Metal] + merge([Rock, Gothic, Music], [Rock, Gothic, Music])
= [The69Eyes, GothicRock, GothicMetal, Metal, Rock, Gothic, Music]

class Food (object): pass
class Meat (Food): pass
class Milk (Food): pass
class Flour (Food): pass
class Rabbit (Meat): pass
class Pork (Meat): pass
class Pasty (Milk, Flour): pass
class Pie (Rabbit, Pork, Pasty): pass

L[Pie] = [Pie] + merge(L[Rabbit], L[Pork], L[Pasty], [Rabbit, Pork, Pasty])
L[Rabbit] = [Rabbit] + merge(L[Meat], [Meat])
L[Pork] = [Pork] + merge(L[Meat], [Meat])
L[Pasty] = [Pasty] + merge(L[Milk], L[Flour], [Milk, Flour])
L[Meat] = [Meat] + merge(L[Food], [Food]) = [Meat, Food]
L[Milk] = [Milk] + merge(L[Food], [Food]) = [Milk, Food]
L[Flour] = [Flour] + merge(L[Food], [Food]) = [Flour, Food]

После подстановок получаем:
L[Rabbit] = [Rabbit, Meat, Food]
L[Pork] = [Pork, Meat, Food]
L[Pasty] = [Pasty] + merge([Milk, Food], [Flour, Food], [Milk, Flour]) = [Pasty] + [Milk, Flour, Food] = [Pasty, Milk, Flour, Food]
L[Pie] = [Pie] + merge([Rabbit, Meat, Food], [Pork, Meat, Food], [Pasty, Milk, Flour, Food], [Rabbit, Pork, Pasty])
= [Pie] + [Rabbit] + merge([Meat, Food], [Pork, Meat, Food], [Pasty, Milk, Flour, Food], [Pork, Pasty])
= [Pie] + [Rabbit, Pork] + merge([Meat, Food], [Meat, Food], [Pasty, Milk, Flour, Food], [Pasty])
= [Pie] + [Rabbit, Pork, Meat] + merge([Food], [Food], [Pasty, Milk, Flour, Food], [Pasty])
= [Pie] + [Rabbit, Pork, Meat, Pasty] + merge([Food], [Food], [Milk, Flour, Food])
= [Pie] + [Rabbit, Pork, Meat, Pasty, Milk, Flour, Food]
= [Pie, Rabbit, Pork, Meat, Pasty, Milk, Flour, Food]

Как обратиться к предкам.

Множественное наследование порождает ещё одну специфическую проблему. На самом деле непосредственный поиск какого-то метода в родительских классах — это лишь часть пользы, которую можно извлечь из него. Как и в случае одиночного наследования, часто можно облегчить себе жизнь, реализовав в потомке метод, который помимо некоторых действий будет вызывать тот же самый метод родителя. Например, достаточно часто можно встретить такое:
class B (A):
def __init__ (self):
# something
A. __init__ (self)

Однако, для случая множественного наследования этот подход не годится. И вот по каким причинам:
class C (B, A):
def __init__ (self):
# something
B. __init__ (self)
A. __init__ (self)

Во-первых, мы явно обращаемся к родительским классам (вообще-то и в примере с одиночным наследованием то же самое). Если мы захотим заменить кого-то из предков на другой класс или вообще убрать, то нам придётся изменять все функции, которые к нему обращались. Это чревато багами, если мы что-нибудь пропустим. Но это ещё пол беды. Во-вторых, мы ничего не знаем о классах A и B. Возможно, у них есть общие предки, к которым они обращаются аналогичным образом:
class A (P1, P2):
def __init__ (self):
# something
P1. __init__ (self)
P2. __init__ (self)

class B (P1, P2):
def __init__ (self):
# something
P1. __init__ (self)
P2. __init__ (self)

Если это так, то получится, что инициализация общих предков отработает два раза. Это не правильно. Чтобы этого избежать в Питоне есть класс super. В версии 3.0 он окончательно очеловечен и к нему можно обращаться следующим образом:
class C (B, A):
def __init__ (self):
# something
super (). __init__ () # для версий младше 3.0 нужно использовать super(C, self)

Обратите внимание, что в версиях 2.x первым аргументом нужно указывать сам класс, а не какого-либо его родителя. По сути, объект класса super запоминает аргуметы переданные ему в момент инициализации и при вызове любого метода (super().__init__(self) в примере выше) проходит по списку линеаризации класса второго аргумента (self.__class__.__mro__), пытаясь вызвать этот метод по очереди для всех классов, следующих за классом в первом аргументе (класс C), передавая в качестве параметра первый аргумент (self). Т.е. для нашего случая:
self.__class__.__mro__ = [C, B, A, P1, P2, …]
super(C, self).__init__() => B.__init__(self)
super(B, self).__init__() => A.__init__(self)
super(A, self).__init__() => P1.__init__(self)
Как видите, из метода B.__init__ при использовании super будет вызван метод A.__init__, хотя класс A с ним никак не связан и не является его предком. В этом случае при необходимости по цепочке однократно отработают методы всех предков.

Благодаря такому подходу можно, например, ввести для рассмотренного примера с пирогом метод allergen для всех компонентов, который будет последовательно проходя по цепочке предков составлять список всех аллергенов компонентов, чтобы предупредить покупателей. Будет удобно вместо того, чтобы переписывать каждый раз список «не рекомендуется» для каждого продукта просто унаследовать его от составляющих компонентов. Тогда список будет формироваться автоматически. Аналогично можно будет предлагать пользователю на выбор напитки к каждому продукту, или подкручивать веса предпочтений пользователя на самописной интернет-радиостанции, идя от конкретной группы к жанрам с некоторым коэффициентом затухания.

class Meat (Food):
def drink(self):
return [ ‘Red wine’ ] + super (Meat, self).drink()

class Milk (Food):
def allergen(self):
return [ ‘Milk-protein’ ] + super (Milk, self).allergen()

class Flour (Food): pass

class Rabbit (Meat):
def drink(self):
return [ ‘Novello wine’ ] + super (Rabbit, self).drink()

class Pork (Meat):
def drink(self):
return [ ‘Sovinion wine’ ] + super (Pork, self).drink()
def allergen(self):
return [ ‘Pork-protein’ ] + super (Pork, self).allergen()

class Pasty (Milk, Flour): pass

class Pie (Rabbit, Pork, Pasty):
def drink(self):
return [ ‘Mineral water’ ] + super (Pie, self).drink()

if __name__ == «__main__» :
pie = Pie()

Исходя из этого списка, можно понять, каким образом обходился список линеаризации. Как видите, ни один из родительских методов не был вызван дважды, иначе в списке аллергенов или рекомендаций обнаружились бы повторения. Кроме того обратите внимание, что в самом старшем классе Food определены оба метода — allergen и drink. Вызов super() не совершает никаких проверок, так что если мы пытаемся обратиться к несуществующему методу, то получим ошибку типа AttributeError: ‘super’ object has no attribute ‘allergen’.

Когда линеаризация не может быть составлена.

Выше уже был разобран случай, когда составить линеаризацию по алгоритму C3 было невозможно. Однако, тогда проблема решилась переменой мест классов-предков в объявлении класса-потомка. Существуют и другие случай, в которых составление линеаризации не возможно:
class C (A, B): pass
class D (B, A): pass
class E (C, D): pass

L[E] = [E] + merge(L[C], L[D], [C, D]) = [E] + merge([C, A, B], [D, B, A], [C, D])
= [E] + [C, D] + merge([A, B], [B, A])

Как видите, конфликт получился неразрешимый, поскольку в объявлении C класс A стоит перед B, а в объявлении D — наоборот. По-хрошему, с этого места надо идти и пересматривать структуру. Но если вам очень надо быстро подхачить или вы просто знаете что делаете, Питон не станет вас ограничивать. Свою собственную линеаризацию можно задать через метаклассы. Для этого достаточно в метаклассе указать метод mro(cls) — по сути, переопределить метод базового метакласса type, — который вернёт нужную вам линеаризацию.
class MetaMRO ( type ):
def mro(cls):
return (cls, A, B, C, D object)

Дальше объявление класса различается для версии 3.0 и 2.x:
class E (C, D): __metaclass__ = MetaMRO # 2.x
class E (C, D, metaclass = MetaMRO): pass # 3.0

После этого E.__mro__ = [E, A, B, C, D, object]. Заметте, что если вы берёте на себя ответственность за MRO Питон не проводит никаких дополнительных проверок и вы можете спокойно провести поиск в предках раньше чем в потомках. И хотя это не желательная практика, но это возможно.

Полезные ссылки:
Unifying types and classes in Python 2.2 — о разделении объектной модели и модели мета-данных. Здесь же обсуждаются MRO, проблемы множественного наследования и super().
The Python 2.3 Method Resolution Order — алгоритм C3 с примерами. В конце есть реализация функций mro и merge на чистом Питоне для тех, кто лучше воспринимает код чем текст.
A Monotonic Superclass Linearization for Dylan — сравнение некоторых видов линеаризации.

Послесловие.

Источник