Какие типы наследования есть в Python?

Типы наследования в Python

Python поддерживает четыре основных типа наследования. Расскажу о каждом с примерами и когда их использовать.

1. Одиночное наследование (Single Inheritance)

Класс наследует от одного родителя. Это самый простой и частый случай.

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

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

dog = Dog()
dog.speak()  # Woof!

Когда использовать: Почти всегда. Это самое понятное и простое решение.

Пример из production:

class User:
    def __init__(self, name):
        self.name = name
    
    def get_email(self):
        return f"{self.name}@example.com"

class Admin(User):
    def delete_user(self, user_id):
        print(f"Admin {self.name} deletes user {user_id}")

2. Множественное наследование (Multiple Inheritance)

Класс наследует от двух и более родителей. Это опасно и требует осторожности.

class FlyingAbility:
    def fly(self):
        return "Flying..."

class SwimmingAbility:
    def swim(self):
        return "Swimming..."

class Duck(FlyingAbility, SwimmingAbility):
    pass

duck = Duck()
print(duck.fly())    # Flying...
print(duck.swim())   # Swimming...

Проблема: Diamond Problem (Проблема ромба)

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

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

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

class D(B, C):
    pass

d = D()
d.method()  # From B (а не From C!)

Решение: 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'>)

Когда НЕ использовать: Это очень редко нужно. В 95% случаев лучше использовать композицию.

3. Многоуровневое наследование (Multilevel Inheritance)

Цепочка наследования: A → B → C.

class Vehicle:
    def start(self):
        print("Engine started")

class Car(Vehicle):
    def drive(self):
        print("Driving...")

class ElectricCar(Car):
    def charge(self):
        print("Charging battery")

electric = ElectricCar()
electric.start()    # Engine started (из Vehicle)
electric.drive()    # Driving... (из Car)
electric.charge()   # Charging battery (из ElectricCar)

Когда использовать: Когда есть четкая иерархия, например:

• Entity → User → Admin
• Shape → Polygon → Triangle
• Exception → RuntimeError → SpecificError

Лучше 2-3 уровней:

# ❌ Плохо: 5+ уровней наследования
class A: pass
class B(A): pass
class C(B): pass
class D(C): pass
class E(D): pass
class F(E): pass

# ✅ Хорошо: максимум 2-3 уровня
class Animal: pass
class Dog(Animal): pass
class ServiceDog(Dog): pass

4. Иерархическое наследование (Hierarchical Inheritance)

Несколько классов наследуют от одного родителя.

class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    
    def area(self):
        return 0.5 * self.base * self.height

# Использование
shapes = [
    Circle(5),
    Rectangle(4, 6),
    Triangle(3, 4)
]

for shape in shapes:
    print(shape.area())

Когда использовать: Это очень распространено. Когда несколько разных типов имеют общий интерфейс.

Гибридное наследование

Комбинация нескольких типов (но будь осторожен!):

class Animal:
    def eat(self):
        print("Eating...")

class Mammal(Animal):
    def warm_blooded(self):
        return True

class Bird(Animal):
    def fly(self):
        print("Flying...")

class Bat(Mammal, Bird):  # Множественное + многоуровневое
    def use_sonar(self):
        print("Using sonar...")

bat = Bat()
bat.eat()           # Eating... (из Animal)
bat.warm_blooded()  # True (из Mammal)
bat.fly()          # Flying... (из Bird)
bat.use_sonar()    # Using sonar...

Когда НЕ использовать наследование

# ❌ Плохо: наследование для переиспользования кода
class Logger:
    def log(self, msg):
        print(msg)

class EmailService(Logger):  # Неправильно!
    def send_email(self, to, msg):
        self.log(f"Sending email to {to}")
        # ... отправка

# ✅ Хорошо: композиция
class EmailService:
    def __init__(self):
        self.logger = Logger()
    
    def send_email(self, to, msg):
        self.logger.log(f"Sending email to {to}")

Best Practices

1. Используй одиночное наследование по умолчанию

# ✅ Правильно
class BaseRepository:
    def find_by_id(self, id): pass

class UserRepository(BaseRepository):
    def find_by_email(self, email): pass

2. Для множественного функционала — используй композицию или mixins

class TimestampMixin:
    def add_timestamp(self):
        self.created_at = datetime.now()

class User(TimestampMixin):
    pass

3. Всегда вызывай super() в переопределенных методах

class Parent:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        print(f"Hello from {self.name}")

class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name)  # Вызови родителя!
        self.age = age
    
    def greet(self):
        super().greet()  # Вызови родителя перед своим кодом
        print(f"I am {self.age} years old")

4. Используй Abstract Base Classes (ABC) для определения интерфейсов

from abc import ABC, abstractmethod

class PaymentGateway(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class StripePayment(PaymentGateway):
    def process_payment(self, amount):
        print(f"Processing ${amount} via Stripe")

class PayPalPayment(PaymentGateway):
    def process_payment(self, amount):
        print(f"Processing ${amount} via PayPal")

Сравнение типов наследования

Итог

За 10+ лет в production системах я использую наследование так:

• 80% одиночное наследование
• 15% иерархическое наследование
• 4% многоуровневое наследование
• 1% все остальные типы

Помни: наследование нужно для организации иерархии типов, а не для переиспользования кода. Для переиспользования используй композицию и mixins.