Прошлый урок показал, как классы и объекты собирают данные и поведение под одной крышей. Как только в проекте появляется пятый похожий класс, назойливо возникает вопрос: зачем каждый раз переписывать одни и те же строки? Наследование отвечает на него коротко и элегантно: общее поведение живёт в родителе, частные отличия переезжают в наследников. О семейных связях между классами, которые экономят сотни строк в реальных программах, и пойдёт речь.
Общее поведение в родителе и частное в наследниках
Начать стоит с боли, знакомой каждому, кто писал код чуть дольше недели. Есть класс Собака с именем, возрастом и методом голос. Рядом просится класс Кошка. Сознание подсказывает лёгкий путь: скопировать файл, поменять пару строк, готово. Через месяц таких копипаст набирается два десятка, и правка одной буквы в общем методе превращается в утомительную охоту по всему проекту. Именно эту ловушку и закрывает наследование.
Идея проста до изящества. Общие черты записываются один раз в родительский класс. Классы-наследники получают их автоматически и добавляют только свои отличия. Собака и Кошка оба умеют есть и спать, но подают голос по-разному. Питонисты часто описывают наследование фразой "является": собака является животным, круг является фигурой. Если между двумя классами встаёт именно такое отношение, наследование почти наверняка подходит.
Выгода проявляется не сразу, а с ростом проекта. Сначала экономия выглядит скромной: минус десять строк. Потом в иерархию добавляется десятый вид животного, и выясняется, что новый класс занимает пять строк вместо пятидесяти. Общий код правится в одном месте, и все наследники мгновенно получают исправление. Маленькое решение на старте оборачивается большим запасом прочности в конце. Похожая логика работает и в жизни: чертёж типового дома дорабатывается под участок, а не рисуется заново с нуля.
Кстати, наследование в 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("Обычная порция корма")
Такой стиль экономит отдельные классы там, где различие нужно лишь в паре ветвей, и в то же время не мешает при росте проекта: когда веток станет много, их несложно разнести по переопределённым методам.
Иерархия животных от простого к сложному
Теперь настал момент собрать всё в один законченный пример. Строится иерархия по накатанной схеме:
- Записываем в родителя всё общее: имя, приём пищи, отдых;
- Выносим в базовый класс метод, который у всех похож по смыслу, но отличается по исполнению;
- В каждом наследнике пишем свой конструктор с super и добавляем частные поля;
- Переопределяем общий метод там, где поведение расходится;
- Дописываем наследникам их уникальные методы и проверяем иерархию через 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, с которыми однотипные циклы сжимаются в одну выразительную строку.