Skip to content

Inheritance - Наследование ​

Наследование позволяет новому классу получить атрибуты и методы существующего, не переписывая их. Базовый (родительский) класс описывает общее, наследник (дочерний) — добирает своё и при необходимости переопределяет методы.

Базовый класс: общее поведение ​

python
class Vehicle:
    def __init__(self, make, model, price, year):
        self.make = make
        self.model = model
        self.__price = None
        self.set_price(price)
        self.__year = None
        self.set_year(year)

    def get_price(self):
        return self.__price

    def set_price(self, price):
        if price >= 0:
            self.__price = price
        else:
            raise ValueError(f'Price must be >= 0, got: {price}')

    def get_year(self):
        return self.__year

    def set_year(self, year):
        if year >= 1900:
            self.__year = year
        else:
            raise ValueError(f'Year must be >= 1900, got: {year}')

Vehicle сам по себе уже полезен: у него есть цена и год с валидацией. Конкретные типы транспорта наследуют от него.

Наследник: super() + свои данные ​

python
class Car(Vehicle):
    def __init__(self, make, model, year, price, num_doors=4):
        super().__init__(make, model, price, year)   # за базовую часть отвечает родитель
        self.num_doors = num_doors

    def __repr__(self):
        return (f'{self.make} {self.model} {self.get_year()} '
                f'with {self.num_doors} doors price {self.get_price()}')


class Bike(Vehicle):
    def __init__(self, make, model, year, bike_type, price):
        super().__init__(make, model, price, year)
        self.bike_type = bike_type

    def __repr__(self):
        return f'{self.make} {self.model} {self.get_year()} {self.bike_type} {self.get_price()}'

Что здесь происходит:

  • Car(Vehicle) — Vehicle становится родителем;
  • super().__init__(...) — базовый конструктор инициализирует общие атрибуты (make, model, __price, __year);
  • self.num_doors — только свой атрибут;
  • __repr__ — переопределение: у каждого класса своя строка.
python
car = Car('Toyota', 'Corolla', 2022, 4000, 2)
bike = Bike('Yamaha', 'MT-07', 2021, 'sport', 3000)
print(car)     # Toyota Corolla 2022 with 2 doors price 4000
print(bike)    # Yamaha MT-07 2021 sport 3000
print(isinstance(car, Vehicle), isinstance(bike, Vehicle))   # True True

isinstance(obj, Vehicle) — ключ к полиморфизму: код, принимающий «любой транспорт», работает и с машиной, и с велосипедом, не зная конкретных классов.

Что наследник получает, а что — нет ​

НаследуетсяПример
методы и атрибуты классаget_price, set_year
поведение __init__ родителятолько если вызвать super().__init__
атрибуты экземпляра родителятолько если super().__init__ их создал
приватные __x родителяда, но не напрямую: mangling привязывает имя к классу (_Vehicle__price), из Car читать нужно через get_price

Переопределение: принцип LSP ​

Переопределяя метод, сохраняйте его «контракт»: если set_year у родителя бросает ValueError на 1899, наследник не должен вдруг молча принимать 0. Клиентский код, написанный под базовый класс, должен работать с наследником без изменений (principle of Liskov Substitution).

Проверьте себя (автопроверка) ​

Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Классы Vehicle, Car, Bike и объекты car, bike уже определены в предыдущих разделах урока.

Тест 1. Кто родитель:

python
print(isinstance(car, Vehicle), isinstance(bike, Vehicle))   # True True
print([c.__name__ for c in Car.__mro__])   # ['Car', 'Vehicle', 'object']

Тест 2. Методы наследуются, но не дублируются:

python
print(hasattr(Car, 'set_year'), hasattr(Bike, 'get_price'))   # True True
print('set_year' in vars(Car))   # False — определён в Vehicle, а не в Car

Тест 3. Приватные поля родителя и name mangling:

python
print('_Vehicle__price' in vars(car))   # True — имя замаглится в классе-определителе
print(hasattr(car, '__price'))   # False — «сырого» имени __price у объекта нет

Тест 4. Валидация наследуется вместе с методом:

python
try:
    car.set_year(1899)
except ValueError as err:
    print(err)   # Year must be >= 1900, got: 1899
print(car.get_year())   # 2022 — старое значение сохранилось
Пояснения к ответам

Тест 1. Car объявлен как Car(Vehicle), поэтому Vehicle — его родитель, а isinstance(car, Vehicle) — True. В MRO родитель всегда стоит после наследника, object — в конце.

Тест 2. hasattr находит метод где угодно по цепочке MRO, но vars(Car) (Car.__dict__) хранит только определения самого Car. Наследник ничего не копирует — он доходит до родителя в момент обращения.

Тест 3. Имя __price в теле Vehicle превращается в _Vehicle__price — префикс связан с классом, где имя написано, а не с классом, на котором лежит объект. Поэтому «внешнее» обращение car.__price не существует, а читать данные нужно через car.get_price().

Тест 4. set_year не переопределён в Car, поэтому работает ровно та версия, что в Vehicle, — с той же проверкой и тем же текстом ошибки. Ошибка возникает до присваивания, так что год не изменился.

Проверьте себя ​

❓Что даёт наследование?
❓Что делает `super().__init__(...)` в конструкторе `Car`?
❓Зачем нужно `isinstance(car, Vehicle)`?
❓Что наследник получает от родителя?
❓Почему в `vars(car)` есть ключ `_Vehicle__price`?
❓Чего требует принцип подстановки Лисков (LSP) при переопределении?

Практические упражнения ​

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

Упражнение 1: Электрокар (ElectricVehicle) ​

Задание: Создайте класс ElectricVehicle(Vehicle) с атрибутом battery_kwh (ёмкость батареи в кВт·ч) и __repr__, где видна батарея. Проверьте, что унаследованный get_price() работает.

python
# Ожидаемое поведение:
# ev = ElectricVehicle('Tesla', 'Model 3', 2023, 45000, 75)
# print(ev)                # Tesla Model 3 2023 with battery 75 kWh price 45000
# print(ev.get_price())    # 45000

Упражнение 2: Потолок цены велосипеда (BikePriceCap) ​

Задание: Переопределите в Bike метод set_price так, чтобы цена велосипеда не превышала 20000: своя проверка + ValueError, а базовые проверки (целостность, price >= 0) передайте родителю через super().

python
# Ожидаемое поведение:
# bike2 = Bike('Yamaha', 'MT-07', 2021, 'sport', 15000)
# print(bike2.get_price())   # 15000
# try:
#     bike2.set_price(25000)
# except ValueError as err:
#     print(err)   # Bike price must be <= 20000, got: 25000
# try:
#     bike2.set_price(-1)
# except ValueError as err:
#     print(err)   # Price must be >= 0, got: -1

Упражнение 3: Полиморфная функция (DescribeAll) ​

Задание: Напишите функцию describe(vehicles), принимающую список любого транспорта и печатающую repr каждого. Проверьте на смешанном списке [car, bike] из урока — функция не должна знать конкретных классов.

python
# Ожидаемое поведение:
# describe([car, bike])
# # Toyota Corolla 2022 with 2 doors price 4000
# # Yamaha MT-07 2021 sport 3000

Упражнение 4: Кто определяет метод (WhoDefines) ​

Задание: Напишите функцию who_defines(cls, method_name), обходящую cls.__mro__ и возвращающую имя первого класса, где метод определён прямо в __dict__ (или None, если метод нигде не найден).

python
# Ожидаемое поведение:
# print(who_defines(Car, 'get_price'))   # Vehicle
# print(who_defines(Car, '__repr__'))    # Car
# print(who_defines(Bike, 'set_year'))   # Vehicle

Упражнение 5: Иерархия на три уровня (DeliveryVan) ​

Задание: Создайте DeliveryVan(Car) с атрибутом cargo_tonnes (грузоподъёмность, по умолчанию 0.5). В __repr__ достройте строку родителя через super().__repr__(). Проверьте всю цепочку isinstance.

python
# Ожидаемое поведение:
# van = DeliveryVan('Ford', 'Transit', 2020, 9000, 2, 1.2)
# print(van)   # Ford Transit 2020 with 2 doors price 9000 cargo 1.2 t
# print(isinstance(van, Car), isinstance(van, Vehicle))   # True True

Упражнение 6: LSP — винтажный автомобиль (VintageCar) ​

Задание: Создайте VintageCar(Vehicle), который принимает только годы не позднее 1980 (своя проверка + ValueError), но сохраняет родительский контракт: годы раньше 1900 тоже должны отвергаться. Не переписывайте проверку родителя заново — вызывайте её.

python
# Ожидаемое поведение:
# vintage = VintageCar('GAZ', 'M-21', 1975, 30000)
# print(vintage.get_year())   # 1975
# try:
#     vintage.set_year(1990)
# except ValueError as err:
#     print(err)   # Vintage year must be <= 1980, got: 1990
# try:
#     vintage.set_year(1899)
# except ValueError as err:
#     print(err)   # Year must be >= 1900, got: 1899

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (ElectricVehicle)
python
class ElectricVehicle(Vehicle):
    def __init__(self, make, model, year, price, battery_kwh):
        super().__init__(make, model, price, year)
        self.battery_kwh = battery_kwh

    def __repr__(self):
        return (f'{self.make} {self.model} {self.get_year()} '
                f'with battery {self.battery_kwh} kWh price {self.get_price()}')


ev = ElectricVehicle('Tesla', 'Model 3', 2023, 45000, 75)
print(ev)                # Tesla Model 3 2023 with battery 75 kWh price 45000
print(ev.get_price())    # 45000

Пояснение: ElectricVehicle не реализует ни get_price, ни set_year — всё это пришло от Vehicle. Своё добавляет только battery_kwh и строку __repr__.

Посмотреть решение Упражнения 2 (BikePriceCap)
python
class Bike(Vehicle):
    def __init__(self, make, model, year, bike_type, price):
        super().__init__(make, model, price, year)
        self.bike_type = bike_type

    def set_price(self, price):
        if price > 20000:
            raise ValueError(f'Bike price must be <= 20000, got: {price}')
        super().set_price(price)   # базовая проверка price >= 0

    def __repr__(self):
        return f'{self.make} {self.model} {self.get_year()} {self.bike_type} {self.get_price()}'


bike2 = Bike('Yamaha', 'MT-07', 2021, 'sport', 15000)
print(bike2.get_price())   # 15000
try:
    bike2.set_price(25000)
except ValueError as err:
    print(err)   # Bike price must be <= 20000, got: 25000
try:
    bike2.set_price(-1)
except ValueError as err:
    print(err)   # Price must be >= 0, got: -1

Пояснение: наследник усиливает контракт (дороже 20000 — нельзя), но не снимает родительский (отрицательная цена по-прежнему ловится в Vehicle.set_price через super()).

Посмотреть решение Упражнения 3 (DescribeAll)
python
def describe(vehicles):
    for v in vehicles:
        print(repr(v))


describe([car, bike])
# Toyota Corolla 2022 with 2 doors price 4000
# Yamaha MT-07 2021 sport 3000

Пояснение: функция знает только, что элементы списка «наподобие Vehicle» (is-a). Какой именно класс — не важно: полиморфизм работает через общий интерфейс __repr__.

Посмотреть решение Упражнения 4 (WhoDefines)
python
def who_defines(cls, method_name):
    for base in cls.__mro__:
        if method_name in base.__dict__:
            return base.__name__
    return None


print(who_defines(Car, 'get_price'))   # Vehicle
print(who_defines(Car, '__repr__'))    # Car
print(who_defines(Bike, 'set_year'))   # Vehicle

Пояснение: обход __mro__ слева направо отвечает на вопрос «чья версия метода сработает». Метод, найденный первым, и вызывается при obj.method().

Посмотреть решение Упражнения 5 (DeliveryVan)
python
class DeliveryVan(Car):
    def __init__(self, make, model, year, price, num_doors=2, cargo_tonnes=0.5):
        super().__init__(make, model, year, price, num_doors)
        self.cargo_tonnes = cargo_tonnes

    def __repr__(self):
        return f'{super().__repr__()} cargo {self.cargo_tonnes} t'


van = DeliveryVan('Ford', 'Transit', 2020, 9000, 2, 1.2)
print(van)   # Ford Transit 2020 with 2 doors price 9000 cargo 1.2 t
print(isinstance(van, Car), isinstance(van, Vehicle))   # True True

Пояснение: цепочка DeliveryVan → Car → Vehicle → object. Каждый уровень добавляет своё и вызывает super(), поэтому данные инициализируются все три слоя.

Посмотреть решение Упражнения 6 (VintageCar)
python
class VintageCar(Vehicle):
    def __init__(self, make, model, year, price):
        super().__init__(make, model, price, year)

    def set_year(self, year):
        if year > 1980:
            raise ValueError(f'Vintage year must be <= 1980, got: {year}')
        super().set_year(year)   # родительская проверка year >= 1900


vintage = VintageCar('GAZ', 'M-21', 1975, 30000)
print(vintage.get_year())   # 1975
try:
    vintage.set_year(1990)
except ValueError as err:
    print(err)   # Vintage year must be <= 1980, got: 1990
try:
    vintage.set_year(1899)
except ValueError as err:
    print(err)   # Year must be >= 1900, got: 1899

Пояснение: это и есть LSP в действии — клиентский код, ожидающий «годовой контракт» Vehicle, продолжает работать: обе границы (>= 1900 и <= 1980) проверяются, а не одна вместо другой.