Работа над новым классом не обязана начинаться с нуля. Если класс, который вы пишете, представляет собой специализированную версию ранее написанного класса, вы можете воспользоваться наследованием. Один класс, наследующий от другого, автоматически получает все атрибуты и методы первого класса. Исходный класс называется родителем, а новый класс — потомком. Класс-потомок наследует атрибуты и методы родителя, но при этом также может определять собственные атрибуты и методы.
Метод __init__() класса-потомка
Первое, что делает Python при создании экземпляра класса-потомка, — присваивает значения всем атрибутам класса-родителя. Для этого методу __init__() класса-потомка необходима помощь со стороны родителя.
Например, попробуем построить модель электромобиля. Электромобиль представляет собой специализированную разновидность автомобиля, поэтому новый класс ElectricCar можно создать на базе класса Car, написанного ранее. Тогда нам останется добавить в него код атрибутов и поведения, относящегося только к электромобилям.
Начнем с создания простой версии класса ElectricCar, который делает все, что делает класс Car:
electric_car.py
(1) class Car():
"""Простая модель автомобиля."""
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name.title()
def read_odometer(self):
print("This car has " + str(self.odometer_reading) + " miles on it.")
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
self.odometer_reading += miles
(2)class ElectricCar(Car):
. ."""Представляет аспекты машины, специфические для электромобилей."""
(3) . .def __init__(self, make, model, year):
. . . ."""Инициализирует атрибуты класса-родителя."""
(4) . . . .super().__init__(make, model, year)
. . . .
(5)my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
В точке (1) строится экземпляр Car. При создании класса-потомка класс-родитель должен быть частью текущего файла, а его определение должно предшествовать определению класса-потомка в файле. В точке (2) определяется класс-потомок ElectricCar. В определении потомка имя класса-родителя заключается в круглые скобки. Метод __init__() в точке (3) получает информацию, необходимую для создания экземпляра Car.
Функция super() в строке (4) — специальная функция, которая помогает Python связать потомка с родителем. Эта строка приказывает Python вызвать метод __init__() класса, являющегося родителем ElectricCar, в результате чего экземпляр ElectricCar получает все атрибуты класса-родителя. Имя super происходит из распространенной терминологии: класс-родитель называется суперклассом, а класс-потомок — субклассом.
Чтобы проверить, правильно ли сработало наследование, попробуем создать электромобиль с такой же информацией, которая передается при создании обычного экземпляра Car. В точке (5) мы создаем экземпляр класса ElectricCar и сохраняем его в my_tesla. Эта строка вызывает метод __init__(), определенный в ElectricCar, который в свою очередь приказывает Python вызвать метод __init__(), определенный в классе-родителе Car. При вызове передаются аргументы 'tesla', 'model s' и 2016.
Кроме __init__() класс еще не содержит никаких атрибутов или методов, специфических для электромобилей. Пока мы просто убеждаемся в том, что класс электромобиля содержит все поведение, присущее классу автомобиля:
2016 Tesla Model S
Экземпляр ElectricCar работает так же, как экземпляр Car; можно переходить к определению атрибутов и методов, специфических для электромобилей.
Наследование в Python 2.7
В Python 2.7 наследование реализовано немного иначе. Класс ElectricCar будет выглядеть примерно так:
class Car(object):
def __init__(self, make, model, year):
...
class ElectricCar(Car):
def __init__(self, make, model, year):
. . . .super(ElectricCar, self).__init__(make, model, year)
...
Функция super() должна получать два аргумента: ссылку на класс-потомок и объект self. Эти аргументы необходимы для того, чтобы Python мог правильно связать родителя с потомком. Если вы используете наследование в Python 2.7, убедитесь в том, что родитель также определяется с синтаксисом object.
Определение атрибутов и методов класса-потомка
После создания класса-потомка, наследующего от класса-родителя, можно переходить к добавлению новых атрибутов и методов, необходимых для того, чтобы потомок отличался от родителя.
Добавим атрибут, специфический для электромобилей (например, мощность аккумулятора), и метод для вывода информации об этом атрибуте:
class Car():
...
class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
def __init__(self, make, model, year):
. . . ."""
. . . .Инициализирует атрибуты класса-родителя.
. . . .Затем инициализирует атрибуты, специфические для электромобиля.
. . . ."""
super().__init__(make, model, year)
(1) . . . .self.battery_size = 70
. . . .
(2) . .def describe_battery(self):
. . . ."""Выводит информацию о мощности аккумулятора."""
. . . .print("This car has a " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
В точке (1) добавляется новый атрибут self.battery_size, которому присваивается исходное значение — скажем, 70. Этот атрибут будет присутствовать во всех экземплярах, созданных на основе класса ElectricCar (но не во всяком экземпляре Car). Также добавляется метод с именем describe_battery(), который выводит информацию об аккумуляторе в точке (2). При вызове этого метода выводится описание, которое явно относится только к электромобилям:
2016 Tesla Model S
This car has a 70-kWh battery.
Возможности специализации класса ElectricCar беспредельны. Вы можете добавить сколько угодно атрибутов и методов, чтобы моделировать электромобиль с любой нужной точностью. Атрибуты или методы, которые могут принадлежать любой машине (а не только электромобилю), должны добавляться в класс Car вместо ElectricCar. Тогда эта информация будет доступна всем пользователям класса Car, а класс ElectricCar будет содержать только код информации и поведения, специфических для электромобилей.
Переопределение методов класса-родителя
Любой метод родительского класса, который в моделируемой ситуации делает не то, что нужно, можно переопределить. Для этого в классе-потомке определяется метод с тем же именем, что и у метода класса-родителя. Python игнорирует метод родителя и обращает внимание только на метод, определенный в потомке.
Допустим, в классе Car имеется метод fill_gas_tank(). Для электромобилей заправка бензином бессмысленна, поэтому этот метод логично переопределить. Например, это можно сделать так:
def ElectricCar(Car):
...
. .def fill_gas_tank():
. . . ."""У электромобилей нет бензобака."""
. . . .print("This car doesn't need a gas tank!")
И если кто-то попытается вызвать метод fill_gas_tank() для электромобиля, Python игнорирует метод fill_gas_tank() класса Car и выполнит вместо него этот код. С применением наследования потомок сохраняет те аспекты родителя, которые вам нужны, и переопределяет все ненужное.
Экземпляры как атрибуты
При моделировании явлений реального мира в программах классы нередко дополняются все большим количеством подробностей. Списки атрибутов и методов растут, и через какое-то время файлы становятся длинными и громоздкими. В такой ситуации часть одного класса нередко можно записать в виде отдельного класса. Большой код разбивается на меньшие классы, которые работают во взаимодействии друг с другом.
Например, при дальнейшей доработке класса ElectricCar может оказаться, что в нем появилось слишком много атрибутов и методов, относящихся к аккумулятору. В таком случае можно остановиться и переместить все эти атрибуты и методы в отдельный класс с именем Battery. Затем экземпляр Battery становится атрибутом класса ElectricCar:
class Car():
...
(1) class Battery():
. ."""Простая модель аккумулятора электромобиля."""
(2) . .def __init__(self, battery_size=70):
. . . ."""Инициализирует атрибуты аккумулятора."""
. . . .self.battery_size = battery_size
(3) . .def describe_battery(self):
. . . ."""Выводит информацию о мощности аккумулятора."""
. . . .print("This car has a " + str(self.battery_size) + "-kWh battery.") . .
class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
def __init__(self, make, model, year):
"""
Инициализирует атрибуты класса-родителя.
Затем инициализирует атрибуты, специфические для электромобиля.
"""
super().__init__(make, model, year)
(4) . . . .self.battery = Battery()
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
В точке (1) определяется новый класс с именем Battery, который не наследует ни от одного из других классов. Метод __init__() в точке (2) получает один параметр battery_size, кроме self. Если значение не предоставлено, этот необязательный параметр задает battery_size значение 70. Метод describe_battery() также перемещен в этот класс (3).
Затем в класс ElectricCar добавляется атрибут с именем self.battery (4). Эта строка приказывает Python создать новый экземпляр Battery (со значением battery_size по умолчанию, равным 70, потому что значение не задано) и сохранить его в атрибуте self.battery. Это будет происходить при каждом вызове __init__(); теперь любой экземпляр ElectricCar будет иметь автоматически создаваемый экземпляр Battery.
Программа создает экземпляр электромобиля и сохраняет его в переменной my_tesla. Когда потребуется вывести описание аккумулятора, необходимо обратиться к атрибуту battery:
my_tesla.battery.describe_battery()
Эта строка приказывает Python обратиться к экземпляру my_tesla, найти его атрибут battery и вызвать метод describe_battery(), связанный с экземпляром Battery из атрибута.
Результат выглядит так же, как и в предыдущей версии:
2016 Tesla Model S
This car has a 70-kWh battery.
Казалось бы, новый вариант требует большой дополнительной работы, но теперь аккумулятор можно моделировать с любой степенью детализации без загромождения класса ElectricCar. Добавим в Battery еще один метод, который выводит запас хода на основании мощности аккумулятора:
class Car():
...
class Battery():
...
(1) . .def get_range(self):
. . . ."""Выводит приблизительный запас хода для аккумулятора."""
. . if self.battery_size == 70:
. . . . . .range = 240
. . . .elif self.battery_size == 85:
. . . . . .range = 270
. . . . . .
. . . .message = "This car can go approximately " + str(range)
. . . .message += " miles on a full charge."
. . . .print(message)
. . . . . .
class ElectricCar(Car):
...
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
(2)my_tesla.battery.get_range()
Новый метод get_range() в точке (1) проводит простой анализ. Если мощность равна 70, то get_range() устанавливает запас хода 240 миль, а при мощности 85 kWh запас хода равен 270 милям. Затем программа выводит это значение. Когда вы захотите использовать этот метод, его придется вызывать через атрибут battery в точке (2).
Результат сообщает запас хода машины в зависимости от мощности аккумулятора:
2016 Tesla Model S
This car has a 70-kWh battery.
This car can go approximately 240 miles on a full charge.
Моделирование объектов реального мира
Занявшись моделированием более сложных объектов — таких, как электромобили, — вы столкнетесь со множеством интересных вопросов. Является ли запас хода электромобиля свойством аккумулятора или машины? Если вы описываете только одну машину, вероятно, можно связать метод get_range() с классом Battery. Но, если моделируется целая линейка машин от производителя, вероятно, метод get_range() правильнее будет переместить в класс ElectricCar. Метод get_range() по-прежнему будет проверять мощность аккумулятора перед определением запаса хода, но он будет сообщать запас хода для той машины, с которой он связан. Также возможно связать метод get_range() с аккумулятором, но передавать ему параметр (например, car_model). Метод get_range() будет определять запас хода на основании мощности аккумулятора и модели автомобиля.
Если вы начнете ломать голову над такими вопросами, это означает, что вы мыслите на более высоком логическом уровне, не ограничиваясь уровнем синтаксиса. Вы думаете уже не о Python, а о том, как представить реальный мир в коде. И, достигнув этой точки, вы поймете, что однозначно правильного или неправильного подхода к моделированию реальных ситуаций часто не существует. Некоторые методы эффективнее других, но для того, чтобы найти наиболее эффективную реализацию, необходим практический опыт. Если ваш код работает именно так, как вы хотели, — значит, у вас все получается! Не огорчайтесь, если окажется, что вы по несколько раз переписываете свои классы для разных решений. На пути к написанию точного, эффективного кода все программисты проходят через этот процесс.
Упражнения
9-6. Киоск с мороженым: киоск с мороженым — особая разновидность ресторана. Напишите класс IceCreamStand, наследующий от класса Restaurant из упражнения 9-1 (с. 165) или упражнения 9-4 (с. 169). Подойдет любая версия класса; просто выберите ту, которая вам больше нравится. Добавьте атрибут с именем flavors для хранения списка сортов мороженого. Напишите метод, который выводит этот список. Создайте экземпляр IceCreamStand и вызовите этот метод.
9-7. Администратор: администратор — особая разновидность пользователя. Напишите класс с именем Admin, наследующий от класса User из упражнения 9-3 (с. 165) или упражнения 9-5 (с. 170). Добавьте атрибут privileges для хранения списка строк вида «разрешено добавлять сообщения», «разрешено удалять пользователей», «разрешено банить пользователей» и т.д. Напишите метод show_privileges() для вывода набора привилегий администратора. Создайте экземпляр Admin и вызовите свой метод.
9-8. Привилегии: напишите класс Privileges. Класс должен содержать всего один атрибут privileges со списком строк из упражнения 9-7. Переместите метод show_privileges() в этот класс. Создайте экземпляр Privileges как атрибут класса Admin. Создайте новый экземпляр Admin и используйте свой метод для вывода списка привилегий.
9-9. Обновление аккумулятора: используйте окончательную версию программы electric_car.py из этого раздела. Добавьте в класс Battery метод с именем upgrade_battery(). Этот метод должен проверять размер аккумулятора и устанавливать мощность равной 85, если она имеет другое значение. Создайте экземпляр электромобиля с аккумулятором по умолчанию, вызовите get_range(), а затем вызовите get_range() во второй раз после вызова upgrade_battery(). Убедитесь в том, что запас хода увеличился.