Что такое наследование в python

Что такое наследование в python

Наследование позволяет создавать новый класс на основе уже существующего класса. Наряду с инкапсуляцией наследование является одним из краеугольных камней объектно-ориентированного программирования.

Ключевыми понятиями наследования являются подкласс и суперкласс . Подкласс наследует от суперкласса все публичные атрибуты и методы. Суперкласс еще называется базовым (base class) или родительским (parent class), а подкласс — производным (derived class) или дочерним (child class).

Синтаксис для наследования классов выглядит следующим образом:

class подкласс (суперкласс): методы_подкласса

Например, у нас есть класс Person, который представляет человека:

class Person: def __init__(self, name): self.__name = name # имя человека @property def name(self): return self.__name def display_info(self): print(f"Name: ")

Предположим, нам необходим класс работника, который работает на некотором предприятии. Мы могли бы создать с нуля новый класс, к примеру, класс Employee:

class Employee: def __init__(self, name): self.__name = name # имя работника @property def name(self): return self.__name def display_info(self): print(f"Name: ") def work(self): print(f" works")

Однако класс Employee может иметь те же атрибуты и методы, что и класс Person, так как работник — это человек. Так, в выше в классе Employee только добавляется метод works , весь остальной код повторяет функционал класса Person. Но чтобы не дублировать функционал одного класса в другом, в данном случае лучше применить наследование.

Итак, унаследуем класс Employee от класса Person:

class Person: def __init__(self, name): self.__name = name # имя человека @property def name(self): return self.__name def display_info(self): print(f"Name: ") class Employee(Person): def work(self): print(f" works") tom = Employee("Tom") print(tom.name) # Tom tom.display_info() # Name: Tom tom.work() # Tom works

Класс Employee полностью перенимает функционал класса Person, лишь добавляя метод work() . Соответственно при создании объекта Employee мы можем использовать унаследованный от Person конструктор:

tom = Employee("Tom")

И также можно обращаться к унаследованным атрибутам/свойствам и методам:

print(tom.name) # Tom tom.display_info() # Name: Tom

Однако, стоит обратить внимание, что для Employee НЕ доступны закрытые атрибуты типа __name. Например, мы НЕ можем в методе work обратиться к приватному атрибуту self.__name :

def work(self): print(f" works") # ! Ошибка

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

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

# класс работника class Employee: def work(self): print("Employee works") # класс студента class Student: def study(self): print("Student studies") class WorkingStudent(Employee, Student): # Наследование от классов Employee и Student pass # класс работающего студента tom = WorkingStudent() tom.work() # Employee works tom.study() # Student studies

Здесь определен класс Employee, который представляет сотрудника фирмы, и класс Student, который представляет учащегося студента. Класс WorkingStudent, который представляет работающего студента, не определяет никакого функционала, поэтому в нем определен оператор pass . Класс WorkingStudent просто наследует функционал от двух классов Employee и Student. Соответственно у объекта этого класса мы можем вызвать методы обоих классов.

При этом наследуемые классы могут более сложными по функциональности, например:

class Employee: def __init__(self, name): self.__name = name @property def name(self): return self.__name def work(self): print(f" works") class Student: def __init__(self, name): self.__name = name @property def name(self): return self.__name def study(self): print(f" studies") class WorkingStudent(Employee, Student): pass tom = WorkingStudent("Tom") tom.work() # Tom works tom.study() # Tom studies

Наследование — Python: Введение в ООП

Все классы, которые мы рассматривали до этого, создавались «с нуля». И до тех пор, пока описываемые классами сущности мало похожи друг на друга, создание абсолютно новых классов работает отлично. Но что делать, если мы хотим, чтобы пара классов содержала один и тот же метод — не одноименный, а именно копию?

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

Языки, реализующие инструментарий для объектно ориентированного программирования, включая использование классов, предоставляют и механизм наследования. Python — один из таких языков. Поэтому классы в Python можно наследовать.

Когда один класс становится наследником другого, то все атрибуты класса-предка (надкласса, superclass) становятся доступны классу-потомку (подклассу, subclass) — наследуются (достаются в наследство).

Что дает наследование

Наследование позволяет выделить общее для нескольких классов поведение и вынести его в отдельную сущность. То есть наследование является средством переиспользования кода (code reuse) — использования существующего кода для решения новых задач!

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

Как обычно, рассмотрим пример:

# этот класс у нас уже был class Counter: def __init__(self): self.value = 0 def inc(self): self.value += 1 def dec(self): self.value -= 1 # А этот класс - новый. Наследник Counter class NonDecreasingCounter(Counter): # в скобках указан класс-предок def dec(self): pass 

Если мы выполним эти объявления классов и посмотрим на поведение экземпляра NonDecreasingCounter , то увидим, что он работает как Counter — имеет те же методы и атрибуты (правда, при вызове метода .dec новый счетчик не изменяет текущее значение):

n = NonDecreasingCounter() n.inc() n.inc() n.value # 2 n.dec() n.value # 2 

В объявлении NonDecreasingCounter присутствует метод dec , а вот откуда взялись value и inc ? Они были взяты от предка — класса Counter ! Данный факт даже можно пронаблюдать:

n.dec # > n.inc # > 

Метод dec — метод класса NonDecreasingCounter , связанный с конкретным экземпляром NonDecreasingCounter . А вот inc — метод класса Counter , хоть и связанный с все тем же экземпляром класса-потомка.

Здесь вы можете увидеть сходство с взаимоотношениями между классом и его экземпляром: если экземпляр получает свой собственный атрибут, то этот атрибут заменяет атрибут класса. Точно так же объявления в классе-потомке заменяют собой атрибуты класса-предка, если имя используется то же самое — говорят, переопределяют (override).

И, как и в случае с объектом, который может использовать все содержимое класса и заменять только небольшую часть атрибутов (или добавлять новые!), так и потомок по умолчанию получает все атрибуты предка, часть из которых может изменить.

Все будет super()

Представим, что нас в целом устраивает класс Counter из предыдущего примера, но мы хотим при вызове inc увеличивать значение дважды. Мы могли бы заменить в потомке весь метод и прописать внутри нового метода self.value += 2 . Но если бы позже что-то поменялось в исходном классе Counter , то эти изменения не коснулись бы нашего метода.

Получается, что нам внутри метода потомка нужно получить доступ к методу предка. Методу с тем же именем! Если мы просто обратимся к self.inc , то получим ссылку на новый метод, ведь мы его переопределили.

Тут нам на помощь приходит специальная функция super :

class DoubleCounter(Counter): def inc(self): super().inc() super().inc() 

Вызов super здесь заменяет обращение к self . При этом вы фактически обращаетесь к «памяти предков»: получаете ссылку на атрибут предка. Более того, в данном случае, super().inc — это связанный с текущим экземпляром метод, то есть полноценная «оригинальная версия» из класса-предка. Если бы вы вдруг решили вручную вызвать метод класса предка, то вам бы пришлось использовать его не связанную версию:

class DoubleCounter(Counter): def inc(self): Counter.inc(self) # явно обращаемся к методу класса предка Counter.inc(self) # и передаем ссылку на экземпляр 

Вызов super вместо явного вызова предка хорош не только тем, что автоматически связывает методы. При смене предка (такое бывает) в описании класса super учтет изменения, и вы получите доступ к поведению нового предка. Удобно!

super работает не только с методами, но и с атрибутами классов:

class A: x = 'A' class B(A): x = 'B' def super_x(self): return super().x B().x # 'B' B().super_x() # 'A' 

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

Функция super так названа в честь названия класса-предка: «superclass».

Вызов инициализатора суперкласса с super()

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

Использование super() в __init__ позволяет нам вызвать конструктор суперкласса, что гарантирует, что весь необходимый код инициализации будет выполнен:

class Counter: def __init__(self): self.value = 0 def inc(self): self.value += 1 def dec(self): self.value -= 1 class NonDecreasingCounter(Counter): def __init__(self): super().__init__() # Вызываем конструктор предка self.non_decreasing = True # Дополнительный атрибут для наследника def dec(self): if self.non_decreasing: print("Уменьшение значения запрещено.") else: super().dec() # Вызываем метод dec предка, если уменьшение разрешено n = NonDecreasingCounter() n.inc() print(n.value) # 1 n.dec() # Уменьшение значения запрещено. print(n.value) # 1 n.non_decreasing = False n.dec() print(n.value) # 0 

В этом примере метод __init__ в NonDecreasingCounter вызывает метод __init__ предка Counter с помощью super() . Это гарантирует, что атрибут value инициализируется как в Counter . Класс NonDecreasingCounter добавляет дополнительный атрибут non_decreasing и изменяет поведение метода dec , чтобы контролировать, может ли счетчик уменьшаться. Это демонстрирует, как можно расширить и настроить поведение классов при наследовании.

В контексте множественного наследования использование super() становится еще более важным, так как оно гарантирует, что все конструкторы суперклассов вызываются в правильном порядке. Это предотвращает проблемы с инициализацией и позволяет каждому классу в иерархии наследования вносить свой вклад в конечное состояние объекта.

Наследование и object

В прошлом мы не указывали предка в объявлениях классов, то есть писали так:

class Foo: pass 

В Python3 такая запись равнозначна записи class Foo(object): . То есть, если класс-предок не указан, то таковым считается object — самый базовый класс в Python. Сейчас, в эпоху повсеместного использования Python3, указывать или не указывать наследование от object — дело вкуса.

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Наследование классов в Python

Классы в языке Python поддерживают наследование классов, что позволяет создавать новые классы с расширенным и/или измененным функционалом базового класса. Новый класс, созданный на основе базового класса — называется производный класс (derived class) или просто подкласс.

Подкласс наследует атрибуты и методы из родительского класса. Он так же может переопределять (override) методы родительского класса. Если подкласс не определяет свой конструктор __init__ , то он наследует конструктор родительского класса по умолчанию.

Синтаксис определения производного (дочернего) класса выглядит следующим образом:

class DerivedClassName(BaseClassName): statement-1> . statement-N> 

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

class DerivedClassName(modname.BaseClassName): statement-1> . statement-N> 

Выполнение определения производного класса DerivedClassName происходит так же, как и для базового класса BaseClassName . Когда объект класса создан, базовый класс BaseClassName запоминается. Это используется для разрешения ссылок на атрибуты. Если запрошенный атрибут не найден в классе DerivedClassName , поиск переходит к поиску в базовом классе BaseClassName . Это правило применяется рекурсивно, если сам базовый класс является производным от какого-либо другого класса.

В создании экземпляров производных классов нет ничего особенного. Выражение a = DerivedClassName() создает новый экземпляр класса. Ссылки на методы разрешаются следующим образом: поиск соответствующего атрибута данных класса осуществляется по цепочке базовых классов, если это необходимо. Ссылка на метод класса будет действительна, если поиск обнаружил функциональный объект.

Производные классы DerivedClassName могут переопределять методы своих базовых классов BaseClassName . Поскольку методы не имеют особых привилегий при вызове других методов того же объекта, метод базового класса, который вызывает другой метод, определенный в том же базовом классе, может в конечном итоге вызвать метод производного класса, который переопределяет его. Для программистов C++ — все методы в Python фактически являются виртуальными.

Переопределяющий метод в производном классе может фактически расширить, а не просто заменить метод базового класса с тем же именем. Существует простой способ вызвать метод базового класса напрямую: просто вызовите BaseClassName.methodname(self, arguments) . Это иногда полезно и для «клиентов». Обратите внимание, что это работает только в том случае, если базовый класс доступен как имя базового класса BaseClassName в глобальной области видимости.

Python имеет две встроенные функции, которые работают с наследованием:

• Используйте isinstance() для проверки типа экземпляра класса: isinstance(obj, int) будет истинным True только в том случае, если obj.__class__ равен int или класс является производным от класса int .
• Используйте issubclass() для проверки наследования классов: issubclass(bool, int) является истинным, так как bool является подклассом int() . Однако issubclass(float, int) является ложным False , так как float не является подклассом int .

Примеры использования переопределения методов.

class One: def __init__(self, name): self.name = name def talk(self): return f'Меня зовут self.name>' def say(self): return f'Привет self.name>' class Two(One): # декорируем метод def say(self): x = One.say(self) return f'x> . ' class Three(One): # переопределяем метод def say(self, word): return f'word> self.name>. ' one = One('Андрей') two = Two('Юра') three = Three('Аня') 

print(f'class One.__name__>:') print(one.talk()) print(one.say()) # class One: # Меня зовут Андрей # Привет Андрей print(f'class Two.__name__>:') print(two.talk()) print(two.say()) print('Two is subclass One:', issubclass(Two, One)) # class Two: # Меня зовут Юра # Привет Юра . # Two is subclass One: True print(f'class Three.__name__>:') print(three.talk()) print(three.say('Пока')) print('Three is subclass One:', issubclass(Three, One)) # class Three: # Меня зовут Аня # Пока Аня. # Three is subclass One: True print('Three is subclass Two:', issubclass(Three, Two)) # Three is subclass Two: False 

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Пространство имен и область видимости в классах
• Определение классов
• Объект класса и конструктор класса
• Создание экземпляра класса
• Метод экземпляра класса
• Что такое метод класса и зачем нужен
• Что такое статический метод в классах Python и зачем нужен
• Атрибуты класса и переменные экземпляра класса
• Кэширование методов экземпляра декоратором lru_cache
• Закрытые/приватные методы и переменные класса Python
• Наследование классов
• Множественное наследование классов
• Абстрактные классы
• Перегрузка методов в классе Python
• Что такое миксины и как их использовать
• Класс Python как структура данных, подобная языку C
• Создание пользовательских типов данных
• Специальные (магические) методы класса Python
• Базовая настройка классов Python магическими методами
• Настройка доступа к атрибутам класса Python
• Дескриптор класса для чайников
• Протокол дескриптора класса
• Практический пример дескриптора
• Использование метода .__new__() в классах Python
• Специальный атрибут __slots__ класса Python
• Специальный метод __init_subclass__ класса Python
• Определение метаклассов metaclass
• Эмуляция контейнерных типов в классах Python
• Другие специальные методы класса
• Как Python ищет специальные методы в классах
• Шаблон проектирования Фабрика и его реализация

Введение в множественное наследование и super()

Введение в множественное наследование и super() для Python-разработчиков. Также в этой статье мы рассмотрим, как справляться с проблемой алмаза.

Краткий обзор наследования

По мере расширения ваших проектов и пакетов Python вы неизбежно захотите использовать классы и т.о. применять один из фундаментальных принципов программирования – принцип DRY (Don’t repeat yourself – не повторяйся!). Наследование классов — это фантастический способ создать класс на основе другого класса, следуя принципу DRY.

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

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

В приведенном ниже блоке кода мы продемонстрируем наследование. У нас есть дочерний класс Child , наследуемый от родительского класса Parent .

class Parent: def __init__(self): self.parent_attribute = 'I am a parent' def parent_method(self): print('Back in my day. ') # Create a child class that inherits from Parent class Child(Parent): def __init__(self): Parent.__init__(self) self.child_attribute = 'I am a child' # Create instance of child child = Child() # Show attributes and methods of child class print(child.child_attribute) print(child.parent_attribute) child.parent_method()

Давайте его запустим и получим следующий результат:

I am a child I am a parent Back in my day.

Мы видим, что класс Child «унаследовал» атрибуты и методы от класса Parent . Без какой-либо работы с нашей стороны метод Parent.parent_method является частью класса Child . Чтобы воспользоваться методом Parent.__init__() , нам нужно было явно вызвать метод и передать self . Это потому, что, когда мы добавили метод __init__ в Child , мы перезаписали унаследованный __init__ .

После этого краткого и очень неполного обзора давайте перейдем к сути статьи.

Введение в super()

В простейшем случае функцию super() можно использовать для замены явного вызова Parent.__init__(self) . Наш вводный пример из первого раздела можно переписать с помощью super() , как это показано ниже.

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

Итак, при использовании super() наш код выглядел бы следующим образом:

class Parent: def __init__(self): self.parent_attribute = 'I am a parent' def parent_method(self): print('Back in my day. ') # Create a child class that inherits from Parent class Child(Parent): def __init__(self): super().__init__() self.child_attribute = 'I am a parent' # Create instance of child child = Child() # Show attributes and methods of child class print(child.child_attribute) print(child.parent_attribute) child.parent_method()

Честно говоря, super() в данном случае дает нам мало преимуществ, если вообще хоть что-то дает. В зависимости от имени нашего родительского класса мы можем сэкономить несколько нажатий клавиш, и нам не нужно передавать self вызову __init__ . Однако для других случаев super() может быть крайне полезен. Ниже приведены некоторые плюсы и минусы использования super() в случаях одиночного наследования.

Минусы

Можно сказать, что использование super() при одиночном наследовании делает код менее явным и интуитивно понятным. Создание менее явного кода нарушает дзен Python, в котором говорится: «Явное лучше, чем неявное».

Плюсы

С точки зрения поддерживаемости super() может быть полезен даже при одиночном наследовании. Если по какой-либо причине ваш дочерний класс меняет свой шаблон наследования (т.е. изменяется родительский класс или происходит переход к множественному наследованию), то нет необходимости искать и заменять все устаревшие ссылки на ParentClass.method_name() . Таким образом, использование super() позволит всем изменениям пройти через изменение в операторе класса.

Super() и множественное наследование

Прежде чем мы перейдем к множественному наследованию и super() , хотим сразу предупредить, что тема непростая. Однако потратьте немного своего времени, перечитайте статью несколько раз, и всё встанет на свои места!

Во-первых, что такое множественное наследование? Предыдущие примеры кода охватывали один дочерний класс Child , наследуемый от одного родительского класса Parent . При множественном наследовании существует более одного родительского класса. Дочерний класс может наследовать от 2, 3, 10 и т.д. родительских классов.

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

Множественное наследование без super()

Давайте рассмотрим пример множественного наследования без изменения каких-либо родительских методов и, в свою очередь, без super() .

Наш код будет выглядеть следующим образом:

class B: def b(self): print('b') class C: def c(self): print('c') class D(B, C): def d(self): print('d') d = D() d.b() d.c() d.d()

Вот такой результат мы получим:

b c d

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

Полученный вывод не слишком удивителен, учитывая концепцию множественного наследования. D унаследовал методы b и c от своих родительских классов, и все в мире хорошо… пока что.

А что, если и B , и C имеют методы с одинаковыми именами? Именно здесь вступает в действие концепция, называемая «multiple-resolution order» (порядок разрешения методов в Python), или сокращенно MRO.

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

Давайте рассмотрим следующий пример:

class B: def x(self): print('x: B') class C: def x(self): print('x: C') class D(B, C): pass d = D() d.x() print(D.mro()) # Output # x: B # [, , , ]

Когда мы вызываем унаследованный метод x , мы видим только выходные данные, унаследованные от класса B .

Мы можем увидеть MRO нашего класса D , вызвав метод класса mro() . Из вывода D.mro() мы узнаем следующее. По умолчанию наша программа попытается вызвать методы D , затем прибегнет к B , затем к C и, наконец, к классу object . Если метод не будет найден ни в одном из этих мест, то мы получим сообщение об ошибке, говорящее, что в D нет запрошенного нами метода.

Стоит отметить, что по умолчанию каждый класс наследуется от класса object , который и находится в конце каждого MRO.

Множественное наследование, super() и проблема алмаза

Давайте разберем пример использования super() для обработки порядка разрешения методов __init__ более выгодным образом. В примере мы создаем серию классов обработки текста и объединяем их функциональность в другом классе с множественным наследованием. Мы создадим 4 класса, и структура наследования будет соответствовать структуре, показанной на диаграмме ниже.

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

На самом деле это пример «проблемы алмаза» множественного наследования. Название проблемы связано с формой фигуры, которую образует схема наследования.

Код, представленный ниже, написан с использованием super() :

class Tokenizer: """Tokenize text""" def __init__(self, text): print('Start Tokenizer.__init__()') self.tokens = text.split() print('End Tokenizer.__init__()') class WordCounter(Tokenizer): """Count words in text""" def __init__(self, text): print('Start WordCounter.__init__()') super().__init__(text) self.word_count = len(self.tokens) print('End WordCounter.__init__()') class Vocabulary(Tokenizer): """Find unique words in text""" def __init__(self, text): print('Start init Vocabulary.__init__()') super().__init__(text) self.vocab = set(self.tokens) print('End init Vocabulary.__init__()') class TextDescriber(WordCounter, Vocabulary): """Describe text with multiple metrics""" def __init__(self, text): print('Start init TextDescriber.__init__()') super().__init__(text) print('End init TextDescriber.__init__()') td = TextDescriber('row row row your boat') print('--------') print(td.tokens) print(td.vocab) print(td.word_count)

Запустим наш код и получим следующий результат:

Start init TextDescriber.__init__() Start WordCounter.__init__() Start init Vocabulary.__init__() Start Tokenizer.__init__() End Tokenizer.__init__() End init Vocabulary.__init__() End WordCounter.__init__() End init TextDescriber.__init__() -------- ['row', 'row', 'row', 'your', 'boat'] 5

Прежде всего, мы видим, что класс TextDescriber унаследовал все атрибуты генеалогического дерева классов. Благодаря множественному наследованию мы можем объединять функциональность более чем одного класса.

Давайте теперь обсудим результаты, полученные от методов инициализации класса:

Каждый метод __init__ вызывался один и только один раз.

Класс TextDescriber унаследован от двух классов, унаследованных от Tokenizer . Почему Tokenizer.__init__ не вызывался дважды?

Если бы мы заменили все наши вызовы super() старомодным способом, мы получили бы 2 вызова Tokenizer.__init__ . Использование super() заранее «обдумывает» наш код и пропускает лишнее действие в виде двойного вызова Tokenizer.__init__ .

Каждый метод __init__ был запущен до того, как любой из других был завершен.

На порядок начала и окончания каждого __init__ стоит обращать внимание, если вы пытаетесь установить атрибут, имя которого конфликтует с другим родительским классом. Атрибут будет перезаписан, и это может все запутать.

В нашем случае мы избежали конфликтов имен с унаследованными атрибутами, поэтому все работает как положено.

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

Заключение

Итак, сегодня мы поговорили про множественное наследование и super() . Мы узнали о функции super() и о том, как ее можно использовать для замены ParentName.method в одиночном наследовании. Это может быть более удобной практикой.

Также мы обсудили множественное наследование и о то, как мы можем передать функциональность нескольких родительских классов одному дочернему классу.

Кроме того, мы узнали о порядке разрешения методов MRO и о том, как он решает, что происходит при множественном наследовании, когда возникает конфликт имен между родительскими методами.

И в конце мы поговорили про проблему алмаза и увидели пример того, как использование super() взаимодействует с этой проблемой.