Как сделать наследуемый класс в python
Добавил пользователь Евгений Кузнецов Обновлено: 05.10.2024
Объектно-ориентированное программирование считается одним из самых эффективных методов создания программ. В объектно-ориентированном программирование создаются классы, описывающие реальные предметы и ситуации, а затем создаете объекты на основе этих описаний. Созданием объекта на основе класса называется созданием экземпляра.
1. Создание класса в Python
Классы в Python могут моделировать практически все что угодно. Создадим простой класс, который будет описывать конкретный автомобиль:
class Car ():
"""Описание автомобиля"""
def __init__ ( self , brand, model):
"""Инициализирует атрибуты brand и model"""
self .brand = brand
self .model = model
def sold ( self ):
"""Автомобиль продан"""
print(f"Автомобиль < self .brand> < self .model>продан ")
def discount ( self ):
"""Скидка на автомобиль"""
print(f"На автомобиль < self .brand> < self .model>скидка 5%")
Разберем код по порядку. В начале определяется класс с именем Car ( class Car ). По общепринятым соглашение название класса начинается с символа верхнего регистра. Круглые скобки в определение класса пусты, так как класс создается с нуля. Далее идет строка документации с кратким описанием. ( """Описание автомобиля""" ).
1.1. Метод __init__()
Функция, являющаяся частью класса, называется методом. Все свойства функций так же относятся и к методам, единственное отличие это способ вызова метода. Метод __init__() - специальный метод, который автоматически выполняется при создание нового экземпляра. Имя метода начинается и заканчивается двумя символами подчеркивания. Метод __init__() определяется с тремя параметрами: self, brand, model. Параметр self обязателен в определение метода и должен стоять перед всеми остальными параметрами. При создании экземпляра на основе класса Car, необходимо передать только два последних аргумента brand и model.
Каждая из двух переменных self.brand = brand и self.model = model снабжена префиксом self и к ним можно обращаться вызовом self.brand и self.model. Значения берутся из параметров brand и model. Переменные, к которым вы обращаетесь через экземпляры, также называются атрибутами.
В классе Car также есть два метода: sold() и discount() . Этим методам не нужна дополнительная информация и они определяются с единственным параметром self. Экземпляры, которые будут созданы на базе этого класса смогут вызывать данные методы, которые просто выводят информацию.
1.2. Создание экземпляра класса
С помощью класса Car мы можем создавать экземпляры для конкретного автомобиля. Каждый экземпляр описывает конкретный автомобиль и его параметры.
car_1 = Car ('Bmw', 'X5')
Создадим переменную car_1 и присвоим ей класс с параметрами автомобиля которые нужно обязательно передать (brand, model). При выполнение данного кода Python вызывает метод __init__ , создавая экземпляр, описывающий конкретный автомобиль и присваивает атрибутам brand и model переданные значения. Этот экземпляр сохраняется в переменной car_1.
1.3. Обращение к атрибутам класса
К атрибутам экземпляра класса мы можем обращаться через запись:
В записи используется имя экземпляра класса и после точки имя атрибута (car_1.brand) или (car_1.model). В итоге на экран выведется следующая информация:
Bmw
X5
1.4. Вызов методов класса
После создания экземпляра на основе класса Car можете вызывать любые методы, написанные в классе. Чтобы вызвать метод, укажите экземпляр (car_1) и вызываемый метод после точки:
car_1. sold ()
car_1. discount ()
При вызове данных методов, Python выполнит код, написанный в этом методе.
Автомобиль Bmw X5 продан
На автомобиль Bmw X5 скидка 5%
2. Работа с классами на Python
Большая часть времени работы программиста - это работа с классами и их экземплярами. Изменим наш предыдущий класс Car и добавим дополнительные атрибуты, которые сможем в последующем менять при работе с экземплярами класса.
class Car ():
"""Описание автомобиля"""
def __init__ ( self , brand, model, years):
"""Инициализирует атрибуты"""
self .brand = brand
self .model = model
self .years = years
self .mileage = 0
def read_mileage ( self ):
"""Пробег автомобиля"""
print(f"Пробег автомобиля < self .mileage>км.")
В описание автомобиля есть три атрибута(параметра) это brand, model, years. Также мы создали новый атрибут mileage (пробег) и присвоили ему начальное значение 0. Так как пробег у всех автомобилей разный, в последующем мы сможем изменять этот атрибут. Метод get_full_name будет возвращать полное описание автомобиля. Метод read_mileage будет выводить пробег автомобиля.
Создадим экземпляр с классом Car и запустим методы:
car_2 = Car('audi', 'a4', 2019)
print(car_2. get_full_name() )
car_2. read_mileage()
В результате в начале Python вызывает метот __init__() для создания нового экземпляра. Сохраняет название, модель, год выпуска и создает новый атрибут с пробегом равным 0. В итоге мы получим такой результат:
Автомобиль Audi A4 2019
Пробег автомобиля 0 км.
2.1. Прямое изменение значения атрибута
Для изменения значения атрибута можно обратиться к нему напрямую и присвоить ему новое значение. Изменим пробег автомобиля car_2:
car_2 = Car('audi', 'a4', 2019)
print(car_2.get_full_name())
car_2.mileage = 38
car_2. read_mileage()
Мы обратились к нашему экземпляру car_2 и связанным с ним атрибутом пробега(mileage) и присвоили новое значение 38. Затем вызвали метод read_mileage() для проверки. В результате мы получим следующие данные.
Автомобиль Audi A4 2019
Пробег автомобиля 38 км.
2.2. Изменение значения атрибута с использованием метода
В Python удобнее писать методы, которые будут изменять атрибуты за вас. Для этого вы просто передаете новое значение методу, который обновит значения. Добавим в наш класс Car метод update_mileage() который будет изменять показания пробега.
class Car ():
"""Описание автомобиля"""
def __init__ ( self , brand, model, years):
"""Инициализирует атрибуты"""
self .brand = brand
self .model = model
self .years = years
self .mileage = 0
def read_mileage ( self ):
"""Пробег автомобиля"""
print(f"Пробег автомобиля < self .mileage>км.")
def update_mileage ( self , new_mileage):
"""Устанавливает новое значение пробега"""
self .mileage = new_mileage
car_2 = Car('audi', 'a4', 2019)
print(car_2.get_full_name())
car_2. read_mileage()
car_2. update_mileage (17100)
car_2. read_mileage()
Вначале выведем текущие показания пробега ( car_2. read_mileage() ). Затем вызовем метод update_mileage() и передадим ему новое значение пробега ( car_2. update_mileage (17100) ). Этот метод устанавливает пробег 17100. Выведем текущие показания ( car_2. read_mileage() ) и у нас получается:
Автомобиль Audi A4 2019
Пробег автомобиля 0 км.
Пробег автомобиля 17100 км.
2.3. Изменение значения атрибута с приращением
Если вместо того, чтобы присвоить новое значение, требуется изменить с значение с приращением, то в этом случаем мы можем написать еще один метод, который будет просто прибавлять пробег к уже имеющемся показаниям. Для этого добавим метод add_mileage в класс Car :
def add_mileage (self, km):
"""Добавляет пробег"""
self .mileage += km
Новый метод add_mileage() получает пробег в км и добавлет его к self.mileage.
car_2. add_mileage (14687)
car_2. read_mileage ()
Пробег автомобиля 31787 км.
В итоге после вызова метода add_mileage() пробег автомобиля в экземпляре car_2 увеличится на 14687 км и станет равным 31787 км. Данный метод мы можем вызывать каждый раз при изменении пробега и передавать новые значение, на которое будет увеличивать основной пробег.
3. Наследование класса в Python
Создавая новые классы не обязательно их создавать с нуля. Новый класс может наследовать свои атрибуты (переменные) и методы (функции принадлежащие классам) от ранее определенного исходного класса ( суперкласса ). Также исходный класс называют родителем, а новый класс - потомком или подклассом. В класс-потомок можно добавлять собственные атрибуты и методы. Напишем новый класс ElectricCar, который будет создан на базе класса Car:
class Car():
"""Описание автомобиля"""
def __init__(self, brand, model, years):
"""Инициализирует атрибуты brand и model"""
self.brand = brand
self.model = model
self.years = years
self.mileage = 0
def get_full_name(self):
"""Автомобиль"""
name = f"Автомобиль "
return name.title()
def read_mileage(self):
"""Пробег автомобиля"""
print(f"Пробег автомобиля км.")
def update_mileage(self, new_mileage):
"""Устанавливает новое значение пробега"""
self.mileage = new_mileage
def add_mileage(self, km):
"""Добавляет пробег"""
self.mileage += km
def battery_power ( self ):
"""Выводит мощность аккумулятора авто"""
print(f"Мощность аккумулятора < self .battery_size>кВт⋅ч")
Мы создали класс ElectriCar на базе класса Car . Имя класса-родителя в этом случае ставится в круглые скобки( class ElectricCar ( Car ) ). Метод __init__ в классе потомка (подклассе) инициализирует атрибуты класса-родителя и создает экземпляр класса Car . Функция super() .- специальная функция, которая приказывает Python вызвать метод __init__() родительского класса Car , в результате чего экземпляр ElectricCar получает доступ ко всем атрибутам класса-родителя. Имя super как раз и происходит из-за того, что класс-родителя называют суперклассом, а класс-потомок - подклассом.
Далее мы добавили новый атрибут self .battery_size и присвоили исходное значение 100. Этот атрибут будет присутствовать во всех экземплярах класса ElectriCar . Добавим новый метод battery_power() , который будет выводить информацию о мощности аккумулятора.
Создадим экземпляр класса ElectriCar и сохраним его в переменную tesla_1
tesla_1 = ElectricCar ('tesla', 'model x', 2021)
print(tesla_1. get_full_name ())
tesla_1. battery_power ( )
При вызове двух методов мы получим:
Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч
В новый класс ElectriCar мы можем добавлять любое количество атрибутов и методов связанных и не связанных с классом-родителем Car .
3.1. Переопределение методов класса-родителя
Методы, которые используются в родительском классе можно переопределить в классе-потомке (подклассе). Для этого в классе-потомке определяется метод с тем же именем, что и у класса-родителя. Python игнорирует метод родителя и переходит на метод, написанный в классе-потомке (подклассе). Переопределим метод def get_full_name() чтобы сразу выводилась мощность аккумуляторов.
def battery_power ( self ):
"""Выводит мощность аккумулятора авто"""
print(f"Мощность аккумулятора < self .battery_size>кВт⋅ч")
В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя Car и сразу перейдет к методу def get_full_name() написанный в классе ElectricCar.
tesla_1 = ElectricCar ('tesla', 'model x', 2021)
print(tesla_1. get_full_name ())
В этой статье мы изучим полиморфизм, разные типы полиморфизма и рассмотрим на примерах как мы можем реализовать полиморфизм в Python.
Что такое полиморфизм?
В буквальном значении полиморфизм означает множество форм.
Полиморфизм — очень важная идея в программировании. Она заключается в использовании единственной сущности(метод, оператор или объект) для представления различных типов в различных сценариях использования.
Давайте посмотрим на пример:
Пример 1: полиморфизм оператора сложения
Мы знаем, что оператор + часто используется в программах на Python. Но он не имеет единственного использования.
Для целочисленного типа данных оператор + используется чтобы сложить операнды.
Итак, программа выведет на экран 3 .
Подобным образом оператор + для строк используется для конкатенации.
В результате будет выведено Python Programming .
Здесь мы можем увидеть единственный оператор + выполняющий разные операции для различных типов данных. Это один из самых простых примеров полиморфизма в Python.
Полиморфизм функций
В Python есть некоторые функции, которые могут принимать аргументы разных типов.
Одна из таких функций — len() . Она может принимать различные типы данных. Давайте посмотрим на примере, как это работает.
Пример 2: полиморфизм на примере функции len()
Вывод:
Здесь мы можем увидеть, что различные типы данных, такие как строка, список, кортеж, множество и словарь могут работать с функцией len() . Однако, мы можем увидеть, что она возвращает специфичную для каждого типа данных информацию.
Полиморфизм функции len()
Полиморфизм в классах
Полиморфизм — очень важная идея в объектно-ориентированном программировании.
Чтобы узнать больше об ООП в Python, посетите эту статью: Python Object-Oriented Programming.
Мы можем использовать идею полиморфизма для методов класса, так как разные классы в Python могут иметь методы с одинаковым именем.
Позже мы сможем обобщить вызов этих методов, игнорируя объект, с которым мы работаем. Давайте взглянем на пример:
Пример 3: полиморфизм в методах класса
Вывод:
Здесь мы создали два класса Cat и Dog . У них похожая структура и они имеют методы с одними и теми же именами info() и make_sound() .
Однако, заметьте, что мы не создавали общего класса-родителя и не соединяли классы вместе каким-либо другим способом. Даже если мы можем упаковать два разных объекта в кортеж и итерировать по нему, мы будем использовать общую переменную animal . Это возможно благодаря полиморфизму.
Полиморфизм и наследование
Как и в других языках программирования, в Python дочерние классы могут наследовать методы и атрибуты родительского класса. Мы можем переопределить некоторые методы и атрибуты специально для того, чтобы они соответствовали дочернему классу, и это поведение нам известно как переопределение метода(method overriding).
Полиморфизм позволяет нам иметь доступ к этим переопределённым методам и атрибутам, которые имеют то же самое имя, что и в родительском классе.
Давайте рассмотрим пример:
Пример 4: переопределение метода
Вывод:
Здесь мы можем увидеть, что такие методы как __str__() , которые не были переопределены в дочерних классах, используются из родительского класса.
Благодаря полиморфизму интерпретатор питона автоматически распознаёт, что метод fact() для объекта a (класса Square ) переопределён. И использует тот, который определён в дочернем классе.
С другой стороны, так как метод fact() для объекта b не переопределён, то используется метод с таким именем из родительского класса( Shape ).
Полиморфизм на примере дочерних и родительских классов в питоне
Заметьте, что перегрузка методов(method overloading) — создание методов с одним и тем же именем, но с разными типами аргументов не поддерживается в питоне.
Как и в других языках программирования, в языке Python реализован механизм наследования. Наследование — это возможность расширения (наследования) ранее написанного программного кода класса с целью дополнения, усовершенствования или привязки под новые требования.
Наследование позволяет создавать иерархии классов. В этих иерархиях классы верхних уровней представляют наиболее обобщенные атрибуты, а классы нижних уровней (подклассы) реализуют более подробную специализацию атрибутов. Иерархии классов образуют дерево иерархии, в котором чем ниже находится класс, тем больше он является специализированным.
Если один класс наследует (расширяет) другой класс, то этот класс называется подкласс. А класс, который наследуется, называется суперкласс.
2. Правила, определяющие работу механизма наследования в Python. Примеры
В языке Python наследование реализуется с соблюдением следующих правил.
2.1. Правило 1. Указание имени суперкласса
Если некоторый класс наследует другой суперкласс, то имя суперкласса задается в круглых скобках в заголовке инструкции class .
Пример.
2.2. Правило 2. Наследование атрибутов суперкласса подклассом
Подкласс наследует атрибуты своих суперклассов.
Пример.
После запуска на выполнение программа выдала следующий результат
2.3. Правило 3. Наследование атрибутов суперкласса экземпляром подкласса
Экземпляры классов наследуют атрибуты всех доступных классов. Например. Из экземпляра objB можно доступиться к методам (атрибутам) A1() , A2() , A3() класса A .
Результат выполнения программы
2.4. Правило 4. Обращение к атрибуту суперкласса из экземпляра класса
Чтобы доступиться к атрибуту суперкласса из экземпляра класса, нужно выполнить обращение вроде
- obj – имя экземпляра подкласса;
- attribute – имя атрибута суперкласса.
Такое обращение включает в себя:
- ссылку на экземпляры и классы по инструкции class (например A.attribute )
- ссылку на атрибуты аргумента экземпляра self в методах класса (например self.attribute ).
Примеры использования данного правила приведены в предыдущих двух правилах 3.
2.5. Правило 5. Изменения в подклассе не затрагивают суперкласс. Перегрузка атрибутов
Если в подклассе вносятся изменения, то эти изменения не затрагивают суперкласс. Это касается также замены имен суперклассов в подклассах, расположенных на более низких уровнях в дереве классов. В этом случае изменяется только унаследованное поведение. Замена атрибутов суперкласса за счет их переопределения в подклассах называется перегрузкой.
Например. В нижеследующем коде демонстрируется замещение имени метода HelloWorld() класса A в подклассе B .
Результат выполнения программы
Как видно из результата, замещение имени метода в подклассе B не влияет на одноименный метод класса A .
3. Пример использования наследования. Расширение класса Point к классу ColorPoint
Условие задачи. Задан класс Point , описывающий точку с координатами x , y на координатной плоскости. Используя механизм наследования нужно расширить возможности класса Point путем добавления нового атрибута цвета. Для этого реализовать подкласс PointColor .
Наследование — это способность объекта принимать одну или несколько характеристик от других классов объектов, обычно переменных или функций-членов. Можно провести аналогию между этим понятием и наследственностью как передачей характерных черт от родителей к потомству. Например, у ребенка могут быть глаза отца и улыбка матери. Глаза отца и улыбка матери — это черты, которые ребенок наследует от своих родителей. Они выглядят/проявляются одинаково у родителей и потомства.
Информатика использует понятие наследования при создании классов, между которыми устанавливаются отношения “род-вид”. В отношениях “род-вид” один объект связан с другим объектом. Например, собака — это домашнее животное, сельдерей — овощ, а Марс — планета. В отношениях “род-вид” есть две сущности: родитель и ребенок. Родитель в этих отношениях является общей версией ребенка. Собака (ребенок) — это домашнее животное (родитель). В информатике мы называем родительский класс в отношениях “род-вид” “суперклассом”, а дочерний — “подклассом”. Подкласс наследует методы и/или переменные от суперкласса. Теперь напишем код для отношений dog/pet (собака/домашнее животное).
Создание подкласса
Обратите внимание на то, что в приведенных примерах для создания класса Dog мы заключаем Pet в скобки в объявлении класса: Dog(Pet) . Использование этого синтаксиса позволяет сообщить Python, что класс, который мы создаем, является подклассом суперкласса Pet. Поскольку ни один из методов и переменных в классе Pet не является закрытым, подкласс Dog сможет получить доступ ко всем элементам класса Pet. Именно так экземпляр собаки способен вызывать методы feedme() и eat() .
Некоторые атрибуты класса могут быть созданы закрытыми. Создать переменную закрытой означает, что этот атрибут не будет доступен подклассу. Имейте это в виду при проектировании классов!
Полиморфизм
Теперь, когда вы получили представление о наследовании, можно перейти к понятию “полиморфизм”. Полиморфизм — это способность чего-либо иметь несколько форм. Вернемся к предыдущему примеру. Все домашние животные в конечном итоге нуждаются в еде, но способ, которым они питаются, может отличаться. Например, попугай будет есть, клюя корм для птиц, в то время как собака будет есть, пережевывая собачий корм. И попугай, и собака — домашние животные, которые едят пищу, но разница в том, что они едят разную пищу по-разному. Взглянем на пример в коде.
В этом примере собака и попугай переопределяют метод eat(self,food_name) . Переопределение метода означает, что метод в подклассе переопределяет метод, указанный в суперклассе. В этом суть полиморфизма: один и тот же метод, но разные характеристики в зависимости от класса.
Заключение
Читайте также: