Что будет, если наследоваться от нескольких классов, а у них есть одинаковые методы?

Множественное наследование и конфликты методов

Это проблема "алмазного наследования" (Diamond Problem). Python решает её через MRO (Method Resolution Order) с использованием C3 линеаризации.

Что происходит?

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

class A:
    def method(self):
        return "A"

class B(A):
    def method(self):
        return "B"

class C(A):
    def method(self):
        return "C"

# Множественное наследование
class D(B, C):
    pass

d = D()
print(d.method())  # Что вернётся?

MRO (Method Resolution Order)

Python использует C3 линеаризацию для определения порядка поиска методов.

print(D.mro())
# [<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>]

print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

Результат: d.method() вернёт "B" (первый класс в наследовании class D(B, C))

Порядок наследования имеет значение

class A:
    def method(self):
        print("A")

class B:
    def method(self):
        print("B")

class C(A, B):  # Порядок A, B
    pass

class D(B, A):  # Порядок B, A
    pass

C().method()  # "A" — A первый в наследовании
D().method()  # "B" — B первый в наследовании

Классический алмаз

class Animal:
    def speak(self):
        print("Some sound")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

class Hybrid(Dog, Cat):  # Наследуется от обоих
    pass

h = Hybrid()
h.speak()  # "Woof!" — Dog первый в списке

print(Hybrid.mro())
# [<class 'Hybrid'>, <class 'Dog'>, <class 'Cat'>, <class 'Animal'>, <class 'object'>]

Проблема: почему это опасно

class Base:
    def __init__(self, name):
        self.name = name

class Flyer:
    def __init__(self, speed):
        self.speed = speed

class Bird(Base, Flyer):
    def __init__(self, name, speed):
        # Какого родителя вызвать?
        pass

# Если забыть вызвать оба __init__
class BadBird(Base, Flyer):
    def __init__(self, name, speed):
        Base.__init__(self, name)  # Вызовем только Base!

# Flyer.__init__ НИКОГДА не вызовется
b = BadBird("Tweety", 50)
print(b.name)    # "Tweety" — ОК
print(b.speed)   # AttributeError! Не инициализировано

Правильно: используй super()

class Base:
    def __init__(self, name):
        print(f"Base.__init__({name})")
        self.name = name
        super().__init__()  # Важно!

class Flyer:
    def __init__(self, speed):
        print(f"Flyer.__init__({speed})")
        self.speed = speed
        super().__init__()  # Важно!

class Bird(Base, Flyer):
    def __init__(self, name, speed):
        print(f"Bird.__init__({name}, {speed})")
        Base.__init__(self, name)  # ❌ ПЛОХО
        Flyer.__init__(self, speed)  # ❌ ПЛОХО

# ПРАВИЛЬНО
class GoodBird(Base, Flyer):
    def __init__(self, name, speed):
        print(f"GoodBird.__init__({name}, {speed})")
        super().__init__(name)  # ✅ Использует MRO!

# Результат выполнения GoodBird("Tweety", 50):
# GoodBird.__init__(Tweety, 50)
# Base.__init__(Tweety)
# Flyer.__init__(50)
# object.__init__()

# Все родители инициализированы через MRO!
b = GoodBird("Tweety", 50)
print(b.name)   # "Tweety" ✓
print(b.speed)  # 50 ✓

Почему super() работает правильно?

# super() использует MRO для вызова СЛЕДУЮЩЕГО класса в цепи

class A:
    def method(self):
        print("A.method")
        super().method()  # Следующий в MRO

class B:
    def method(self):
        print("B.method")
        super().method()  # Следующий в MRO

class C:
    def method(self):
        print("C.method")
        # Дальше идёт object, у которого нет method

class D(A, B, C):
    pass

# MRO: D -> A -> B -> C -> object
D().method()
# A.method
# B.method
# C.method

Полный пример: правильное множественное наследование

from abc import ABC, abstractmethod

class TimestampMixin:
    def __init__(self):
        print("TimestampMixin.__init__")
        self.created_at = None
        super().__init__()

class LoggingMixin:
    def __init__(self):
        print("LoggingMixin.__init__")
        self.logs = []
        super().__init__()

class User(TimestampMixin, LoggingMixin):
    def __init__(self, name):
        print(f"User.__init__({name})")
        self.name = name
        super().__init__()

u = User("Alice")
print(f"\nРезультат:")
print(f"name: {u.name}")
print(f"created_at: {u.created_at}")
print(f"logs: {u.logs}")
print(f"\nMRO: {User.mro()}")

# Вывод:
# User.__init__(Alice)
# TimestampMixin.__init__
# LoggingMixin.__init__
# 
# Результат:
# name: Alice
# created_at: None
# logs: []
# MRO: [<class 'User'>, <class 'TimestampMixin'>, <class 'LoggingMixin'>, <class 'object'>]

Что нельзя делать

1. Вызывать несколько init напрямую:

# ❌ ПЛОХО
class Bird(Dog, Cat):
    def __init__(self):
        Dog.__init__(self)   # Дублирование Animal.__init__!
        Cat.__init__(self)   # Дублирование Animal.__init__!

2. Забывать вызывать super():

# ❌ ПЛОХО
class Bird(Dog, Cat):
    def __init__(self):
        self.name = "Bird"
        # Никто больше не инициализируется!

3. Смешивать super() и прямые вызовы:

# ❌ ПЛОХО
class Bird(Dog, Cat):
    def __init__(self):
        Dog.__init__(self)       # Прямой вызов
        super().__init__()       # super() вызовет Cat после Dog
        # Возможно двойное инициализирование!

Когда множественное наследование вообще нужно?

1. Миксины (очень распространено):

class TimestampMixin:
    def set_timestamp(self):
        self.timestamp = datetime.now()

class Model(TimestampMixin):
    pass

2. Интерфейсы (Protocol):

from typing import Protocol

class Drawable(Protocol):
    def draw(self): ...

class Printable(Protocol):
    def print(self): ...

class Document(Drawable, Printable):
    def draw(self): print("Drawing...")
    def print(self): print("Printing...")

3. Комбинирование функциональности:

class Serializable:
    def to_json(self): ...

class Validatable:
    def validate(self): ...

class User(Serializable, Validatable):
    pass

Лучшая практика

Предпочитай композицию наследованию:

# ❌ Множественное наследование
class BadBird(Dog, Cat, Animal):
    pass

# ✅ Композиция
class GoodBird:
    def __init__(self):
        self.dog_part = Dog()
        self.cat_part = Cat()
    
    def bark(self):
        return self.dog_part.bark()
    
    def meow(self):
        return self.cat_part.meow()

Итог

1. Порядок имеет значение — class D(B, C) выберет методы B перед C
2. MRO решает конфликты — D.__mro__ показывает порядок поиска
3. Всегда используй super() — это гарантирует правильный порядок инициализации
4. Избегай множественного наследования — композиция часто проще
5. Миксины — исключение — они специально созданы для множественного наследования
6. Профилируй MRO — используй ClassName.mro() или ClassName.__mro__ для отладки