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

Общее поведение в родителе и частное в наследниках

Начать стоит с боли, знакомой каждому, кто писал код чуть дольше недели. Есть класс Собака с именем, возрастом и методом голос. Рядом просится класс Кошка. Сознание подсказывает лёгкий путь: скопировать файл, поменять пару строк, готово. Через месяц таких копипаст набирается два десятка, и правка одной буквы в общем методе превращается в утомительную охоту по всему проекту. Именно эту ловушку и закрывает наследование.

Идея проста до изящества. Общие черты записываются один раз в родительский класс. Классы-наследники получают их автоматически и добавляют только свои отличия. Собака и Кошка оба умеют есть и спать, но подают голос по-разному. Питонисты часто описывают наследование фразой "является": собака является животным, круг является фигурой. Если между двумя классами встаёт именно такое отношение, наследование почти наверняка подходит.

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

Кстати, наследование в Python пришло не на пустое место: та же идея живёт в Java, C# и других объектных языках, так что усилия, вложенные сейчас, окупятся и при знакомстве с ними. Отличие питона в мягкости: здесь нет строгих требований к иерархии, любой класс может стать родителем, а проверка отношений между классами делается парой строк. Для обучения это удачный расклад: синтаксис почти не мешает усваивать саму идею.

Синтаксис наследования и общие методы

Синтаксис лаконичен. Имя родительского класса записывается в скобках после имени наследника, и на этом договор подписан:

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

    def eat(self):
        print(self.name + " ест с аппетитом")

class Dog(Animal):
    pass

dog = Dog("Шарик")
dog.eat()
print(dog.name)

Класс Dog не содержит ни одной собственной строки поведения, но у объекта уже есть имя и метод eat. Конструкция pass здесь означает "ничего своего пока не добавляем". Питон ищет метод по чёткому маршруту: сначала в классе самого объекта, затем в его родителе, потом выше по цепочке, если иерархия глубже. Найдя eat в Animal, интерпретатор спокойно его вызывает. Запись Dog(Animal) читается как "собака является животным" и отражает саму суть отношения. Порядок обхода этой цепочки в языке называется поиском метода, и новичку достаточно запомнить простое правило: своё ценится выше унаследованного.

Цепочка может тянуться дальше, чем на один шаг. От Собаки, в свою очередь, можно унаследовать служебную собаку, и она получит и общие черты животного, и собачьи умения:

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

    def eat(self):
        print(self.name + " ест")

class Dog(Animal):
    def speak(self):
        print(self.name + " говорит: Гав")

class GuardDog(Dog):
    def guard(self):
        print(self.name + " сторожит участок")

rex = GuardDog("Рекс")
rex.speak()
rex.eat()
rex.guard()

GuardDog не писала ни speak, ни eat, но владеет обоими методами: первый унаследован от Dog, второй проделал путь сразу через два уровня вверх. Так семейное дерево разрастается постепенно, и каждый уровень добавляет ровно один слой смысла, не трогая соседние.

Расширение конструктора через super

Часто наследнику нужны все данные родителя плюс пара своих. Собаке из питомника, например, ещё и порода. Писать в наследнике новый конструктор с нуля и дублировать строку self.name = name выглядит глупо. Для этого случая в языке есть функция super, которая возвращает родителя текущего класса:

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

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

dog = Dog("Шарик", "овчарка")
print(dog.name, dog.breed)

Строка super().__init__(name) означает: сначала выполни то, что обычно делает родитель, потом продолжай со своими делами. Порядок именно такой, и это хороший стиль: конструктор наследника начинается с чужой работы, а затем добавляет свою. Если однажды в конструктор Animal добавится, скажем, поле energy, то Dog подхватит его автоматически, ведь вызов super уже стоит на месте. Без super пришлось бы править каждый наследник вручную, и вся экономия испарялась бы на глазах.

Частая ошибка новичков здесь в другом направлении: вызвать super и забыть присвоить собственное поле, либо наоборот присвоить всё самому и не вызвать родителя вовсе. Во втором случае объект формально создастся, но какие-то поля родителя окажутся не заполнены, и ошибка вылезет позже, в самом неожиданном месте. Привычка начинать конструктор наследника с вызова super избавляет от целого класса трудноуловимых проблем, и эта привычка стоит одной лишней строки.

Переопределение и добавление методов

Наследник не обязан терпеть всё, что дал родитель. Любой метод можно переопределить, просто написав в наследнике метод с тем же именем. Новая версия затмевает старую для всех объектов этого класса:

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

    def speak(self):
        print(self.name + " издаёт какой-то звук")

class Dog(Animal):
    def speak(self):
        print(self.name + " говорит: Гав")

class Cat(Animal):
    def speak(self):
        print(self.name + " говорит: Мяу")

Dog("Шарик").speak()
Cat("Мурка").speak()

Здесь speak в родителе объявляет, что каждое животное умеет издавать звук, а наследники уточняют, какой именно. Такой приём называют полиморфизмом: одинаковый вызов на разных объектах даёт разный результат. Вторая половина свободы в том, что наследник может не только менять чужие методы, но и добавлять собственные, которых у родителя нет вовсе:

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

class Dog(Animal):
    def fetch(self, thing):
        print(self.name + " принёс " + thing)

dog = Dog("Шарик")
dog.fetch("мяч")

Метод fetch есть только у собак. Кошка, созданная от Animal, про мяч знать не знает, и это правильно: частное поведение живёт там, где ему место. Иногда хочется не выбирать между старым и новым, а соединить их: переопределить метод и внутри вызвать родительскую версию через super:

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

    def speak(self):
        print(self.name + " издаёт какой-то звук")

class Parrot(Animal):
    def speak(self):
        super().speak()
        print(self.name + " повторяет услышанное")

Parrot("Кеша").speak()

Попугай сначала выполняет родительское поведение, а затем добавляет своё. Приём ценен тем, что при изменении базового метода наследник продолжит работать корректно: своя часть накручивается поверх общей, а не копирует её. Это второй способ применить super, и в профессиональном коде он встречается даже чаще, чем в конструкторе.

Проверка типа через isinstance

Когда в программе живут животные разных видов, встаёт практический вопрос: как отличить собаку от кошки в общем списке? Функция isinstance проверяет, принадлежит ли объект классу, и при этом понимает семейные связи:

class Dog:
    def fetch(self):
        print("Принёс мяч")

class Cat:
    def purr(self):
        print("Мурлычет")

animals = [Dog(), Cat(), Dog()]

for animal in animals:
    if isinstance(animal, Dog):
        animal.fetch()
    else:
        animal.purr()

Проверка isinstance(animal, Dog) сработает для обоих псов, а мурку аккуратно пропустит. Показательная деталь: для объекта Dog выражение isinstance(dog, Animal) тоже вернёт True, ведь собака является животным. Проверка идёт по всей родословной вверх, а не только по прямому классу. В больших программах isinstance связывает наследование с реальными задачами: один цикл обрабатывает всю семейку, а ветка с проверкой достаёт частное поведение в нужный момент.

Ещё одно законное место для isinstance находится внутри обычных функций. Если функция принимает любое животное, но собаке готовит особое угощение, проверка пишется прямо в её теле:

def feed(animal):
    if isinstance(animal, Dog):
        print("Собаке досталась косточка")
    else:
        print("Обычная порция корма")

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

Иерархия животных от простого к сложному

Теперь настал момент собрать всё в один законченный пример. Строится иерархия по накатанной схеме:

  1. Записываем в родителя всё общее: имя, приём пищи, отдых;
  2. Выносим в базовый класс метод, который у всех похож по смыслу, но отличается по исполнению;
  3. В каждом наследнике пишем свой конструктор с super и добавляем частные поля;
  4. Переопределяем общий метод там, где поведение расходится;
  5. Дописываем наследникам их уникальные методы и проверяем иерархию через isinstance.

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

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

    def eat(self):
        print(self.name + " ест")

    def sleep(self):
        print(self.name + " спит, свернувшись клубком")

    def speak(self):
        print(self.name + " издаёт какой-то звук")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

    def speak(self):
        print(self.name + " говорит: Гав")

    def fetch(self, thing):
        print(self.name + " принёс " + thing)

class Cat(Animal):
    def __init__(self, name):
        super().__init__(name)
        self.lives_left = 9

    def speak(self):
        print(self.name + " говорит: Мяу")

    def purr(self):
        print(self.name + " мурлычет у окна")

zoo = [Dog("Полкан", "дворняга"), Cat("Мурка"), Dog("Шарик", "боксёр")]
for animal in zoo:
    animal.eat()
    animal.speak()

Три строки цикла просят каждого обитателя есть и подавать голос, а объекты сами разбираются, как именно это делать. Новое животное, скажем Ворона, добавится классом в десять строк, и цикл трогать не придётся: он уже умеет работать с любым наследником Animal:

class Crow(Animal):
    def speak(self):
        print(self.name + " говорит: Кар")

zoo.append(Crow("Зюзя"))
for animal in zoo:
    animal.speak()

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

Наследование в больших программах

В учебных примерах иерархия занимает двадцать строк, но настоящая сила вскрылась бы в проекте на тысячи строк. Игре не важно, кто перед ней: каждый объект рисуется одной командой draw и обновляется одной update, а наследники лишь уточняют детали. Тот же принцип виден в геометрии, где у Круга и Прямоугольника есть общий метод area:

import math

class Shape:
    def area(self):
        return 0.0

class Circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        return math.pi * self.r ** 2

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h

    def area(self):
        return self.w * self.h

figures = [Circle(3), Rectangle(4, 5), Circle(1)]
total = sum(f.area() for f in figures)
print(total)

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

Есть у наследования и правила гигиены. Иерархия должна отражать реальные отношения "является", а не собирать классы в кучу ради экономии строк. Глубины в два-три уровня обычно достаточно, иначе поиск нужного метода превращается в долгую экскурсию по родословной. И помнить: общее поведение правится в одном месте, так что родительский класс заслуживает особой аккуратности и внятных имён.

Наследование завершает разговор об объектной модели: классы умеют строить объекты, а теперь ещё и целые семьи с общими чертами и характерами. Следующий урок переносит фокус на компактные приёмы: генераторы списков, лямбда-функции, map и filter, с которыми однотипные циклы сжимаются в одну выразительную строку.