>>> класс MyClass:
...     проходить
...
  

Вы объявили класс MyClass , который мало что делает, но он иллюстрирует самые основные концепции наследования. Теперь, когда у вас объявлен класс, вы можете использовать функцию dir () для вывода списка его членов:

  >>> c = MyClass ()
>>> dir (c)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__']
  

dir () возвращает список всех членов в указанном объекте.Вы не указали участников в MyClass , так откуда берется список? Вы можете узнать с помощью интерактивного переводчика:

  >>> o = object ()
>>> dir (o)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__', '__getattribute__', '__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__']
  

Как видите, два списка почти идентичны.В MyClass есть несколько дополнительных членов, например __dict__ и __weakref__ , но каждый отдельный член класса объекта также присутствует в MyClass .

Это связано с тем, что каждый класс, который вы создаете в Python, неявно является производным от объекта . Вы могли бы быть более явным и написать class MyClass (object): , но это избыточно и ненужно.

Примечание: В Python 2 необходимо явно наследовать от объект по причинам, выходящим за рамки данной статьи, но вы можете прочитать об этом в разделе «Классические классы нового стиля» документации Python 2.

Исключения являются исключением

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

Вы можете увидеть проблему с помощью интерактивного интерпретатора Python:

  >>> класс MyError:
...     проходить
...
>>> поднять MyError ()

Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: исключения должны быть производными от BaseException
  

Вы создали новый класс, чтобы указать тип ошибки.Затем вы попытались использовать его, чтобы вызвать исключение. Возникает исключение, но в выходных данных указано, что исключение имеет тип TypeError , а не MyError , и что все исключения должны быть производными от BaseException .

BaseException — это базовый класс, предоставляемый для всех типов ошибок. Чтобы создать новый тип ошибки, вы должны унаследовать свой класс от BaseException или одного из его производных классов. По соглашению в Python пользовательские типы ошибок выводятся из исключения Exception , которое, в свою очередь, является производным от BaseException .

Правильный способ определить тип ошибки следующий:

  >>> класс MyError (Исключение):
...     проходить
...
>>> поднять MyError ()

Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
__main __. MyError
  

Как видите, когда вы вызываете MyError , в выходных данных правильно указывается тип возникшей ошибки.

Создание иерархии классов

Наследование — это механизм, который вы будете использовать для создания иерархий связанных классов.Эти связанные классы будут иметь общий интерфейс, который будет определен в базовых классах. Производные классы могут специализировать интерфейс, предоставляя конкретную реализацию там, где это применимо.

В этом разделе вы начнете моделировать систему управления персоналом. В этом примере будет продемонстрировано использование наследования и то, как производные классы могут предоставить конкретную реализацию интерфейса базового класса.

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

Вы начинаете с реализации класса PayrollSystem , который обрабатывает расчет заработной платы:

  # В часах в год

класс PayrollSystem:
    def calculate_payroll (самостоятельно, сотрудники):
        print ('Расчет заработной платы')
        print ('===================')
        для сотрудника в составе сотрудников:
            print (f'Payroll for: {employee.id} - {employee.name} ')
            print (f'- Проверить сумму: {employee.calculate_payroll ()} ')
            Распечатать('')
  

Система расчета заработной платы реализует .calculate_payroll () , который берет коллекцию сотрудников и печатает их идентификатор , имя и проверяет сумму с помощью метода .calculate_payroll () , доступного для каждого объекта сотрудника.

Теперь вы реализуете базовый класс Employee , который обрабатывает общий интерфейс для каждого типа сотрудника:

  # В часах в год

класс Сотрудник:
    def __init __ (я, идентификатор, имя):
        self.id = id
        self.name = имя
  

Сотрудник — это базовый класс для всех типов сотрудников.Он построен с идентификатором id и именем . Вы говорите, что каждому сотруднику должен быть назначен идентификатор , а также имя.

Система HR требует, чтобы каждый обработанный Сотрудник предоставлял интерфейс .calculate_payroll () , который возвращает еженедельную зарплату для сотрудника. Реализация этого интерфейса различается в зависимости от типа Сотрудник .

Например, у административных работников фиксированная зарплата, поэтому каждую неделю они получают одинаковую сумму:

  # В час.ру

class SalaryEmployee (Сотрудник):
    def __init __ (self, id, name, weekly_salary):
        super () .__ init __ (идентификатор, имя)
        self.weekly_salary = weekly_salary

    def calculate_payroll (самостоятельно):
        return self.weekly_salary
  

Вы создаете производный класс SalaryEmployee , который наследует Employee . Класс инициализируется с идентификатором и именем , требуемым базовым классом, и вы используете super () для инициализации членов базового класса.Вы можете прочитать все о super () в Supercharge Your Classes With Python super ().

SalaryEmployee также требуется параметр инициализации weekly_salary , который представляет сумму, которую сотрудник зарабатывает в неделю.

Класс предоставляет требуемый метод .calculate_payroll () , используемый системой HR. Реализация просто возвращает сумму, хранящуюся в weekly_salary .

Компания также нанимает рабочих, получающих почасовую оплату, поэтому вы добавляете HourlyEmployee в систему управления персоналом:

  # В час.ру

class HourlyEmployee (Сотрудник):
    def __init __ (self, id, name, hours_worked, hour_rate):
        super () .__ init __ (идентификатор, имя)
        self.hours_worked = hours_worked
        self.hour_rate = часовой_рейт

    def calculate_payroll (самостоятельно):
        вернуть self.hours_worked * self.hour_rate
  

Класс HourlyEmployee инициализируется идентификатором и именем , как и базовый класс, плюс hours_worked и hour_rate , необходимые для расчета заработной платы.Метод .calculate_payroll () реализуется путем возврата количества отработанных часов, умноженного на почасовую ставку.

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

  # В часах в год

class CommissionEmployee (SalaryEmployee):
    def __init __ (self, id, name, weekly_salary, Commission):
        super () .__ init __ (идентификатор, имя, недельная_ зарплата)
        себя.комиссия = комиссия

    def calculate_payroll (самостоятельно):
        fixed = super (). calculate_payroll ()
        возврат фиксированный + self.commission
  

Вы выводите CommissionEmployee из SalaryEmployee , потому что оба класса должны учитывать weekly_salary . В то же время CommissionEmployee инициализируется значением комиссии , которое основано на продажах для сотрудника.

.calculate_payroll () использует реализацию базового класса для получения фиксированной зарплаты и добавляет значение комиссии.

Поскольку CommissionEmployee является производным от SalaryEmployee , у вас есть доступ напрямую к свойству weekly_salary , и вы могли бы реализовать .calculate_payroll () , используя значение этого свойства.

Проблема с прямым доступом к свойству заключается в том, что если реализация SalaryEmployee.calculate_payroll () изменится, вам также придется изменить реализацию CommissionEmployee.calculate_payroll () .Лучше полагаться на уже реализованный метод в базовом классе и расширять функциональность по мере необходимости.

Вы создали свою иерархию первого класса для системы. UML-диаграмма классов выглядит так:

На схеме показана иерархия наследования классов. Производные классы реализуют интерфейс IPayrollCalculator , который требуется для PayrollSystem . Реализация PayrollSystem.calculate_payroll () требует, чтобы переданные объекты employee содержали id , name и реализацию calculate_payroll () .

Интерфейсы представлены аналогично классам со словом interface над именем интерфейса. Имена интерфейсов обычно начинаются с заглавной буквы I .

Приложение создает своих сотрудников и передает их в систему расчета заработной платы для обработки расчета заработной платы:

  # В program.py

импортные часы

salary_employee = hr.SalaryEmployee (1, 'Джон Смит', 1500)
hourly_employee = hr.HourlyEmployee (2, 'Джейн Доу', 40, 15)
Commission_employee = hr.CommissionEmployee (3, 'Кевин Бэкон', 1000, 250)
payroll_system = час.Система начисления заработной платы()
payroll_system.calculate_payroll ([
    salary_employee,
    hourly_employee,
    Commission_employee
])
  

Вы можете запустить программу в командной строке и посмотреть результат:

  $ python program.py

Расчет заработной платы
===================
Заработная плата для: 1 - Джон Смит
- Сумма чека: 1500

Зарплата для: 2 - Джейн Доу
- Сумма чека: 600

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250
  

Программа создает три объекта сотрудников, по одному для каждого из производных классов.Затем он создает систему расчета заработной платы и передает список сотрудников своему методу .calculate_payroll () , который рассчитывает заработную плату для каждого сотрудника и распечатывает результаты.

Обратите внимание, что базовый класс Employee не определяет метод .calculate_payroll () . Это означает, что если вы создадите простой объект Employee и передадите его в PayrollSystem , то получите сообщение об ошибке. Вы можете попробовать это в интерактивном интерпретаторе Python:

  >>> импорт ч.
>>> Сотрудник = час.Сотрудник (1, «Недействительный»)
>>> payroll_system = hr.PayrollSystem ()
>>> payroll_system.calculate_payroll ([сотрудник])

Заработная плата для: 1 - недействительна
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
  Файл "/hr.py", строка 39, в файле calculate_payroll
    print (f'- Проверить сумму: {employee.calculate_payroll ()} ')
AttributeError: объект "Сотрудник" не имеет атрибута "calculate_payroll"
  

Хотя вы можете создать экземпляр объекта Employee , этот объект не может использоваться системой PayrollSystem .Почему? Потому что не может .calculate_payroll () для Сотрудника . Чтобы соответствовать требованиям PayrollSystem , вам нужно преобразовать класс Employee , который в настоящее время является конкретным классом, в абстрактный класс. Таким образом, ни один сотрудник не будет просто сотрудником , а будет реализован .calculate_payroll () .

Абстрактные базовые классы в Python

Класс Employee в приведенном выше примере называется абстрактным базовым классом.Абстрактные базовые классы существуют для наследования, но никогда не создаются. Python предоставляет модуль abc для определения абстрактных базовых классов.

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

Модуль abc в стандартной библиотеке Python предоставляет функциональные возможности для предотвращения создания объектов из абстрактных базовых классов.

Вы можете изменить реализацию класса Employee , чтобы исключить возможность его создания:

  # В часах в год

from abc import ABC, abstractmethod

класс Сотрудник (ABC):
    def __init __ (я, идентификатор, имя):
        self.id = id
        self.name = имя

    @abstractmethod
    def calculate_payroll (самостоятельно):
        проходить
  

Вы производите Employee из ABC , что делает его абстрактным базовым классом. Затем вы украшаете .Calcul_payroll () с декоратором @abstractmethod .

У этого изменения есть два хороших побочных эффекта:

1. Вы сообщаете пользователям модуля, что объекты типа Employee не могут быть созданы.
2. Вы говорите другим разработчикам, работающим над модулем hr , что если они являются производными от Employee , то они должны переопределить абстрактный метод .calculate_payroll () .

Вы можете видеть, что объекты типа Сотрудник не могут быть созданы с помощью интерактивного интерпретатора:

  >>> импорт ч.
>>> Сотрудник = час.Сотрудник (1, 'аннотация')

Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: невозможно создать экземпляр абстрактного класса Employee с абстрактными методами
Calcul_payroll
  

Выходные данные показывают, что нельзя создать экземпляр класса, поскольку он содержит абстрактный метод calculate_payroll () . Производные классы должны переопределять метод, чтобы разрешить создание объектов своего типа.

Наследование реализации против наследования интерфейса

Когда вы производите один класс от другого, производный класс наследует оба:

1. Интерфейс базового класса: Производный класс наследует все методы, свойства и атрибуты базового класса.

2. Реализация базового класса: Производный класс наследует код, реализующий интерфейс класса.

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

Современные языки программирования разработаны с учетом этой базовой концепции. Они позволяют наследовать от одного класса, но вы можете реализовать несколько интерфейсов.

В Python нет необходимости явно объявлять интерфейс. Любой объект, реализующий желаемый интерфейс, может использоваться вместо другого объекта. Это известно как утка , набирающая . Утиный набор текста обычно объясняется так: «Если он ведет себя как утка, значит, это утка».

Чтобы проиллюстрировать это, теперь вы добавите класс DisgruntledEmployee в приведенный выше пример, который не является производным от Employee :

  # В disgruntled.py

класс DisgruntledEmployee:
    def __init __ (я, идентификатор, имя):
        себя.id = id
        self.name = имя

    def calculate_payroll (самостоятельно):
        возврат 1000000
  

Класс DisgruntledEmployee не является производным от Employee , но предоставляет тот же интерфейс, который требуется для PayrollSystem . PayrollSystem.calculate_payroll () требует список объектов, реализующих следующий интерфейс:

• Свойство или атрибут id , который возвращает идентификатор сотрудника
• A name свойство или атрибут, представляющий имя сотрудника
• А .Calcul_payroll () метод, который не принимает никаких параметров и возвращает сумму заработной платы для обработки

Всем этим требованиям удовлетворяет класс DisgruntledEmployee , поэтому PayrollSystem все еще может рассчитывать свою заработную плату.

Вы можете изменить программу, чтобы использовать класс DisgruntledEmployee :

  # В program.py

импортные часы
недовольный импорт

salary_employee = hr.SalaryEmployee (1, 'Джон Смит', 1500)
hourly_employee = час.HourlyEmployee (2, 'Джейн Доу', 40, 15)
Commission_employee = hr.CommissionEmployee (3, 'Кевин Бэкон', 1000, 250)
disgruntled_employee = disgruntled.DisgruntledEmployee (20000, 'Анонимный')
payroll_system = hr.PayrollSystem ()
payroll_system.calculate_payroll ([
    salary_employee,
    hourly_employee,
    Commission_employee,
    disgruntled_employee
])
  

Программа создает объект DisgruntledEmployee и добавляет его в список, обрабатываемый системой PayrollSystem .Теперь вы можете запустить программу и увидеть ее результат:

  $ python program.py

Расчет заработной платы
===================
Заработная плата для: 1 - Джон Смит
- Сумма чека: 1500

Зарплата для: 2 - Джейн Доу
- Сумма чека: 600

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250

Заработная плата для: 20000 - Аноним
- Сумма чека: 1000000
  

Как видите, PayrollSystem все еще может обрабатывать новый объект, потому что он соответствует желаемому интерфейсу.

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

• Используйте наследование для повторного использования реализации: Производные классы должны использовать большую часть своей реализации базового класса. Они также должны моделировать отношения как . Класс Customer может также иметь идентификатор и имя , но Customer не является Employee , поэтому не следует использовать наследование.

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

Теперь вы можете очистить приведенный выше пример, чтобы перейти к следующей теме. Вы можете удалить файл disgruntled.py , а затем изменить модуль hr в исходное состояние:

  # В часах в год

класс PayrollSystem:
    def calculate_payroll (самостоятельно, сотрудники):
        print ('Расчет заработной платы')
        print ('===================')
        для сотрудника в составе сотрудников:
            print (f'Payroll for: {employee.id} - {employee.name} ')
            print (f'- Проверить сумму: {сотрудник.Calcul_payroll ()} ')
            Распечатать('')

класс Сотрудник:
    def __init __ (я, идентификатор, имя):
        self.id = id
        self.name = имя

class SalaryEmployee (Сотрудник):
    def __init __ (self, id, name, weekly_salary):
        super () .__ init __ (идентификатор, имя)
        self.weekly_salary = weekly_salary

    def calculate_payroll (самостоятельно):
        return self.weekly_salary

class HourlyEmployee (Сотрудник):
    def __init __ (self, id, name, hours_worked, hour_rate):
        super () .__ init __ (идентификатор, имя)
        себя.hours_worked = hours_worked
        self.hour_rate = часовой_рейт

    def calculate_payroll (самостоятельно):
        вернуть self.hours_worked * self.hour_rate

class CommissionEmployee (SalaryEmployee):
    def __init __ (self, id, name, weekly_salary, Commission):
        super () .__ init __ (идентификатор, имя, недельная_ зарплата)
        self.commission = комиссия

    def calculate_payroll (самостоятельно):
        fixed = super (). calculate_payroll ()
        возврат фиксированный + self.commission
  

Вы удалили импорт модуля abc , поскольку класс Employee не обязательно должен быть абстрактным.Вы также удалили из него абстрактный метод calculate_payroll () , поскольку он не предоставляет никакой реализации.

По сути, вы наследуете реализацию атрибутов id и name класса Employee в производных классах. Поскольку .calculate_payroll () — это просто интерфейс для метода PayrollSystem.calculate_payroll () , вам не нужно реализовывать его в базовом классе Employee .

Обратите внимание, как класс CommissionEmployee является производным от SalaryEmployee . Это означает, что CommissionEmployee наследует реализацию и интерфейс SalaryEmployee . Вы можете увидеть, как метод CommissionEmployee.calculate_payroll () использует реализацию базового класса, поскольку он полагается на результат от super (). Calculate_payroll () для реализации своей собственной версии.

Проблема взрыва класса

Если вы не будете осторожны, наследование может привести вас к огромной иерархической структуре классов, которую трудно понять и поддерживать.Это известно как проблема взрыва класса .

Вы начали построение иерархии классов из типов сотрудников , используемых системой PayrollSystem для расчета заработной платы. Теперь вам нужно добавить к этим классам некоторые функции, чтобы их можно было использовать с новой ProductivitySystem .

Система ProductivitySystem отслеживает производительность в зависимости от ролей сотрудников. Существуют разные роли сотрудников:

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

С этими требованиями вы начинаете видеть, что Employee и его производные классы могут принадлежать не к модулю hr , а где-то еще, потому что теперь они также используются ProductivitySystem .

Вы создаете модуль сотрудников и перемещаете туда классы:

  # В employee.py

класс Сотрудник:
    def __init __ (я, идентификатор, имя):
        self.id = id
        self.name = имя

class SalaryEmployee (Сотрудник):
    def __init __ (self, id, name, weekly_salary):
        супер().__init __ (идентификатор, имя)
        self.weekly_salary = weekly_salary

    def calculate_payroll (самостоятельно):
        return self.weekly_salary

class HourlyEmployee (Сотрудник):
    def __init __ (self, id, name, hours_worked, hour_rate):
        super () .__ init __ (идентификатор, имя)
        self.hours_worked = hours_worked
        self.hour_rate = часовой_рейт

    def calculate_payroll (самостоятельно):
        вернуть self.hours_worked * self.hour_rate

class CommissionEmployee (SalaryEmployee):
    def __init __ (self, id, name, weekly_salary, Commission):
        супер().__init __ (id, name, weekly_salary)
        self.commission = комиссия

    def calculate_payroll (самостоятельно):
        fixed = super (). calculate_payroll ()
        возврат фиксированный + self.commission
  

Реализация остается той же, но вы перемещаете классы в модуль employee . Теперь вы измените свою программу, чтобы поддержать изменение:

  # В program.py

импортные часы
импортные сотрудники

salary_employee = сотрудники.SalaryEmployee (1, 'Джон Смит', 1500)
hourly_employee = сотрудники.HourlyEmployee (2, 'Джейн Доу', 40, 15)
Commission_employee = employee.CommissionEmployee (3, 'Кевин Бэкон', 1000, 250)
payroll_system = hr.PayrollSystem ()
payroll_system.calculate_payroll ([
    salary_employee,
    hourly_employee,
    Commission_employee
])
  

Вы запускаете программу и проверяете, что она по-прежнему работает:

  $ python program.py

Расчет заработной платы
===================
Заработная плата для: 1 - Джон Смит
- Сумма чека: 1500

Зарплата для: 2 - Джейн Доу
- Сумма чека: 600

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250
  

Когда все готово, вы начинаете добавлять новые классы:

  # У сотрудников.ру

Менеджер класса (SalaryEmployee):
    def работа (самостоятельно, часы):
        print (f '{self.name} кричит и кричит в течение {hours} часов.')

классный секретарь (SalaryEmployee):
    def работа (самостоятельно, часы):
        print (f '{self.name} тратит {hours} часов на оформление офисных документов.')

class SalesPerson (CommissionEmployee):
    def работа (самостоятельно, часы):
        print (f '{self.name} тратит на телефон {hours} часов.')

класс FactoryWorker (HourlyEmployee):
    def работа (самостоятельно, часы):
        print (f '{self.name} производит гаджеты в течение {часов} часов.')
  

Сначала вы добавляете класс Manager , производный от SalaryEmployee . Класс предоставляет метод work () , который будет использоваться системой повышения производительности. Метод занимает часа, отработанных сотрудником.

Затем вы добавляете Secret , SalesPerson и FactoryWorker , а затем реализуете интерфейс work () , чтобы их можно было использовать в системе повышения производительности.

Теперь вы можете добавить класс ProductivitySytem :

  # По производительности.ру

class ProductivitySystem:
    def track (я, сотрудники, часы):
        print ('Отслеживание производительности сотрудников')
        print ('==============================')
        для сотрудника в составе сотрудников:
            employee.work (часы)
        Распечатать('')
  

Класс отслеживает сотрудников с помощью метода track () , который берет список сотрудников и количество часов для отслеживания. Теперь вы можете добавить в свою программу систему повышения производительности:

  # В program.py

импортные часы
импортные сотрудники
производительность импорта

менеджер = сотрудники.Менеджер (1, 'Мэри Поппинс', 3000)
secretary = сотрудники.Secretary (2, 'Джон Смит', 1500)
sales_guy = сотрудники.SalesPerson (3, 'Кевин Бэкон', 1000, 250)
factory_worker = employee.FactoryWorker (2, 'Джейн Доу', 40, 15)
сотрудники = [
    менеджер,
    секретарь,
    sales_guy,
    рабочий,
]
performance_system = продуктивность.ProductivitySystem ()
performance_system.track (сотрудников, 40)
payroll_system = hr.PayrollSystem ()
payroll_system.calculate_payroll (сотрудники)
  

Программа формирует список сотрудников разного типа.Список сотрудников отправляется в систему продуктивности для отслеживания их работы в течение 40 часов. Затем тот же список сотрудников отправляется в систему расчета заработной платы для расчета их заработной платы.

Вы можете запустить программу, чтобы увидеть результат:

  $ python program.py

Отслеживание производительности сотрудников
==============================
Мэри Поппинс кричит и кричит 40 часов.
Джон Смит тратит 40 часов на оформление офисных документов.
Кевин Бэкон проводит по телефону 40 часов.
Джейн Доу производит гаджеты 40 часов.Расчет заработной платы
===================
Заработная плата для: 1 - Мэри Поппинс
- Сумма чека: 3000

Зарплата для: 2 - Джон Смит
- Сумма чека: 1500

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250

Зарплата для: 4 - Джейн Доу
- Сумма чека: 600
  

Программа показывает сотрудников, работающих по 40 часов через систему продуктивности. Затем он рассчитывает и отображает платежную ведомость для каждого из сотрудников.

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

На следующей диаграмме показана новая иерархия классов:

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

Наследование нескольких классов

Python — один из немногих современных языков программирования, поддерживающих множественное наследование.Множественное наследование — это возможность одновременно наследовать класс из нескольких базовых классов.

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

Этот подход накладывает некоторые ограничения на ваши проекты.Вы можете унаследовать реализацию одного класса только путем прямого наследования от него. Вы можете реализовать несколько интерфейсов, но не можете наследовать реализацию нескольких классов.

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

Оказывается, иногда нанимают временных секретарей, когда нужно делать слишком много документов. Класс TemporarySecretary выполняет роль секретаря в контексте ProductivitySystem , но для целей расчета заработной платы это HourlyEmployee .

Вы смотрите на дизайн своего класса. Он немного вырос, но вы все еще можете понять, как это работает. Кажется, у вас есть два варианта:

1. Унаследовать от Секретарь : Вы можете унаследовать от Секретарь , чтобы унаследовать .work () для роли, а затем переопределите метод .calculate_payroll () , чтобы реализовать его как HourlyEmployee .

2. Производный от HourlyEmployee : Вы можете наследовать от HourlyEmployee метод .calculate_payroll () , а затем переопределить метод .work () , чтобы реализовать его как секретарь .

Затем вы помните, что Python поддерживает множественное наследование, поэтому вы решили наследовать как от Secret , так и от HourlyEmployee :

  # У сотрудников.ру

class TemporarySecretary (Секретарь, Почасовой сотрудник):
    проходить
  

Python позволяет вам наследовать от двух разных классов, указав их в скобках в объявлении класса.

Теперь вы измените свою программу, добавив нового временного секретаря:

  импортных часов
импортные сотрудники
производительность импорта

manager = employee.Manager (1, 'Мэри Поппинс', 3000)
secretary = сотрудники.Secretary (2, 'Джон Смит', 1500)
sales_guy = сотрудники.SalesPerson (3, 'Кевин Бэкон', 1000, 250)
factory_worker = сотрудники.FactoryWorker (4, 'Джейн Доу', 40, 15)
временный_секретарий = сотрудники.Темверинсекретарий (5, 'Робин Уильямс', 40, 9)
company_employees = [
    менеджер,
    секретарь,
    sales_guy,
    рабочий,
    временный_секретарь,
]
performance_system = продуктивность.ProductivitySystem ()
performance_system.track (company_employees, 40)
payroll_system = hr.PayrollSystem ()
payroll_system.calculate_payroll (company_employees)
  

Вы запускаете программу для проверки:

  $ программа на Python.ру

Отслеживание (последний вызов последний):
 Файл ". \ Program.py", строка 9, в 
  Временный_секретари = сотрудник.Темверинсекретарий (5, 'Робин Уильямс', 40, 9)
TypeError: __init __ () принимает 4 позиционных аргумента, но было дано 5
  

Вы получаете исключение TypeError , в котором говорится, что 4 позиционных аргумента там, где ожидалось, но было дано 5 .

Это связано с тем, что вы получили TemporarySecretary сначала из секретарь , а затем из HourlyEmployee , поэтому переводчик пытается использовать секретарь.__init __ () для инициализации объекта.

Ладно, перевернем:

  класс Временный секретарь (почасовая, секретарь):
    проходить
  

Теперь запустите программу еще раз и посмотрите, что произойдет:

  $ python program.py

Отслеживание (последний вызов последний):
 Файл ". \ Program.py", строка 9, в 
  Временный_секретари = сотрудник.Темверинсекретарий (5, 'Робин Уильямс', 40, 9)
 Файл "employee.py", строка 16, в __init__
  super () .__ init __ (идентификатор, имя)
TypeError: __init __ () отсутствует 1 обязательный позиционный аргумент: 'weekly_salary'
  

Теперь кажется, что вам не хватает параметра weekly_salary , который необходим для инициализации секретаря , но этот параметр не имеет смысла в контексте TemporarySecretary , потому что это HourlyEmployee .

Может быть, реализация TemporarySecretary .__ init __ () поможет:

  # В employee.py

class TemporarySecretary (Почасовой сотрудник, секретарь):
    def __init __ (self, id, name, hours_worked, hour_rate):
        super () .__ init __ (идентификатор, имя, часы работы, скорость_часа)
  

Попробуйте:

  $ python program.py

Отслеживание (последний вызов последний):
 Файл ". \ Program.py", строка 9, в 
  Временный_секретари = сотрудник.Темверинсекретарий (5, 'Робин Уильямс', 40, 9)
 Файл "Сотрудник".py ", строка 54, в __init__
  super () .__ init __ (идентификатор, имя, часы работы, скорость_часа)
 Файл "employee.py", строка 16, в __init__
  super () .__ init __ (идентификатор, имя)
TypeError: __init __ () отсутствует 1 обязательный позиционный аргумент: 'weekly_salary'
  

Это тоже не сработало. Хорошо, пришло время погрузиться в порядок разрешения метода Python (MRO), чтобы увидеть, что происходит.

Когда осуществляется доступ к методу или атрибуту класса, Python использует класс MRO, чтобы найти его. MRO также используется super () , чтобы определить, какой метод или атрибут вызывать.Вы можете узнать больше о super () в Supercharge Your Classes With Python super ().

Вы можете оценить MRO класса TemporarySecretary с помощью интерактивного интерпретатора:

  >>> из сотрудников ввозят временного секретаря
>>> Временный секретарь .__ mro__

(<класс 'employee.TemporarySecretary'>,
 <класс 'employee.HourlyEmployee'>,
 <класс 'сотрудники. Секретарь'>,
 <класс 'employee.SalaryEmployee'>,
 <класс сотрудников.Сотрудник '>,
 <класс 'объект'>
)
  

MRO показывает порядок, в котором Python будет искать соответствующий атрибут или метод. В этом примере это происходит, когда мы создаем объект TemporarySecretary :

1. Вызывается метод TemporarySecretary .__ init __ (self, id, name, hours_worked, hour_rate) .

2. Вызов super () .__ init __ (id, name, hours_worked, hour_rate) соответствует HourlyEmployee.__init __ (self, id, name, hour_worked, hour_rate) .

3. HourlyEmployee вызывает super () .__ init __ (id, name) , который MRO собирается сопоставить с Secret .__ init __ () , который унаследован от SalaryEmployee .__ init __ (self, id, name, weekly_salary ) .

Поскольку параметры не совпадают, возникает исключение TypeError .

Вы можете обойти MRO, изменив порядок наследования и напрямую позвонив по номеру HourlyEmployee.__init __ () следующим образом:

  класс TemporarySecretary (секретарь, почасовая оплата):
    def __init __ (self, id, name, hours_worked, hour_rate):
        HourlyEmployee .__ init __ (self, id, name, hours_worked, hour_rate)
  

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

  $ python program.py

Отслеживание производительности сотрудников
==============================
Мэри Поппинс кричит и кричит 40 часов.Джон Смит тратит 40 часов на оформление офисных документов.
Кевин Бэкон проводит по телефону 40 часов.
Джейн Доу производит гаджеты 40 часов.
Робин Уильямс тратит 40 часов на оформление офисных документов.

Расчет заработной платы
===================
Заработная плата для: 1 - Мэри Поппинс
- Сумма чека: 3000

Зарплата для: 2 - Джон Смит
- Сумма чека: 1500

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250

Зарплата для: 4 - Джейн Доу
- Сумма чека: 600

Зарплата для: 5 - Робин Уильямс
Отслеживание (последний вызов последний):
  Файл ".\ program.py ", строка 20, в 
    payroll_system.calculate_payroll (сотрудники)
  Файл "hr.py", строка 7, в файле calculate_payroll
    print (f'- Проверить сумму: {employee.calculate_payroll ()} ')
  Файл employee.py, строка 12, в файле calculate_payroll
    return self.weekly_salary
AttributeError: объект TemporarySecretary не имеет атрибута weekly_salary
  

Проблема в том, что, поскольку вы изменили порядок наследования, MRO находит метод .calculate_payroll () для SalariedEmployee перед методом в HourlyEmployee .Вам нужно переопределить .calculate_payroll () в TemporarySecretary и вызвать из него правильную реализацию:

  класс TemporarySecretary (секретарь, почасовая оплата):
    def __init __ (self, id, name, hours_worked, hour_rate):
        HourlyEmployee .__ init __ (self, id, name, hours_worked, hour_rate)

    def calculate_payroll (самостоятельно):
        return HourlyEmployee.calculate_payroll (self)
  

Метод calculate_payroll () напрямую вызывает HourlyEmployee.calculate_payroll () , чтобы убедиться, что вы получите правильный результат. Вы можете снова запустить программу, чтобы убедиться, что она работает:

  $ python program.py

Отслеживание производительности сотрудников
==============================
Мэри Поппинс кричит и кричит 40 часов.
Джон Смит тратит 40 часов на оформление офисных документов.
Кевин Бэкон проводит по телефону 40 часов.
Джейн Доу производит гаджеты 40 часов.
Робин Уильямс тратит 40 часов на оформление офисных документов.

Расчет заработной платы
===================
Заработная плата для: 1 - Мэри Поппинс
- Сумма чека: 3000

Зарплата для: 2 - Джон Смит
- Сумма чека: 1500

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250

Зарплата для: 4 - Джейн Доу
- Сумма чека: 600

Зарплата для: 5 - Робин Уильямс
- Сумма чека: 360
  

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

Как видите, множественное наследование может сбивать с толку, особенно когда вы сталкиваетесь с проблемой ромба.

На следующей диаграмме показана проблема ромба в иерархии классов:

На диаграмме показана проблема с ромбами при текущем дизайне класса. TemporarySecretary использует множественное наследование для наследования от двух классов, которые в конечном итоге также являются производными от Employee . Это приводит к достижению базового класса Employee двумя путями, чего вы хотите избежать в своих проектах.

Проблема ромба возникает, когда вы используете множественное наследование и унаследованы от двух классов, имеющих общий базовый класс. Это может привести к вызову неправильной версии метода.

Как вы видели, Python предоставляет способ принудительного вызова нужного метода, и анализ MRO может помочь вам понять проблему.

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

Производные классы Employee используются двумя разными системами:

1. Система продуктивности , отслеживающая продуктивность сотрудников.

2. Система расчета заработной платы , которая рассчитывает заработную плату сотрудников.

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

  # По производительности.ру

class ProductivitySystem:
    def track (я, сотрудники, часы):
        print ('Отслеживание производительности сотрудников')
        print ('==============================')
        для сотрудника в составе сотрудников:
            result = employee.work (часы)
            print (f '{имя сотрудника}: {результат}')
        Распечатать('')

класс ManagerRole:
    def работа (самостоятельно, часы):
        ответь f'scream и кричит в течение {hours} часов ».

класс Секретарь
    def работа (самостоятельно, часы):
        return f'expends {hours} часов на оформление офисных документов.'

class SalesRole:
    def работа (самостоятельно, часы):
        return f 'тратит {hours} часов на телефон.'

класс FactoryRole:
    def работа (самостоятельно, часы):
        вернуть гаджеты на {hours} часов ».
  

Модуль продуктивности реализует класс ProductivitySystem , а также связанные роли, которые он поддерживает. Классы реализуют интерфейс work () , необходимый для системы, но они не являются производными от Employee .

То же самое можно сделать и с модулем hr :

  # В час.ру

класс PayrollSystem:
    def calculate_payroll (самостоятельно, сотрудники):
        print ('Расчет заработной платы')
        print ('===================')
        для сотрудника в составе сотрудников:
            print (f'Payroll for: {employee.id} - {employee.name} ')
            print (f'- Проверить сумму: {employee.calculate_payroll ()} ')
            Распечатать('')

класс SalaryPolicy:
    def __init __ (self, weekly_salary):
        self.weekly_salary = weekly_salary

    def calculate_payroll (самостоятельно):
        return self.weekly_salary

класс HourlyPolicy:
    def __init __ (self, hours_worked, hour_rate):
        себя.hours_worked = hours_worked
        self.hour_rate = часовой_рейт

    def calculate_payroll (самостоятельно):
        вернуть self.hours_worked * self.hour_rate

класс CommissionPolicy (SalaryPolicy):
    def __init __ (self, weekly_salary, Commission):
        super () .__ init __ (недельная_ зарплата)
        self.commission = комиссия

    def calculate_payroll (самостоятельно):
        fixed = super (). calculate_payroll ()
        возврат фиксированный + self.commission
  

Модуль hr реализует систему PayrollSystem , которая рассчитывает заработную плату для сотрудников.Он также реализует классы политики для расчета заработной платы. Как видите, классы политик больше не являются производными от Employee .

Теперь вы можете добавить необходимые классы в модуль сотрудник :

  # В employee.py

из часов импорта (
    SalaryPolicy,
    CommissionPolicy,
    Почасовая политика
)
из импорта производительности (
    ManagerRole,
    Секретарь роль,
    SalesRole,
    FactoryRole
)

класс Сотрудник:
    def __init __ (я, идентификатор, имя):
        себя.id = id
        self.name = имя

Менеджер класса (Сотрудник, ManagerRole, SalaryPolicy):
    def __init __ (self, id, name, weekly_salary):
        SalaryPolicy .__ init __ (self, weekly_salary)
        super () .__ init __ (идентификатор, имя)

класс Секретарь (Employee, SecretRole, SalaryPolicy):
    def __init __ (self, id, name, weekly_salary):
        SalaryPolicy .__ init __ (self, weekly_salary)
        super () .__ init __ (идентификатор, имя)

class SalesPerson (Сотрудник, SalesRole, CommissionPolicy):
    def __init __ (self, id, name, weekly_salary, Commission):
        CommissionPolicy.__init __ (самостоятельно, недельная_ зарплата, комиссия)
        super () .__ init __ (идентификатор, имя)

класс FactoryWorker (Сотрудник, FactoryRole, HourlyPolicy):
    def __init __ (self, id, name, hours_worked, hour_rate):
        HourlyPolicy .__ init __ (self, hours_worked, hour_rate)
        super () .__ init __ (идентификатор, имя)

класс TemporarySecretary (Сотрудник, SecretRole, HourlyPolicy):
    def __init __ (self, id, name, hours_worked, hour_rate):
        HourlyPolicy .__ init __ (self, hours_worked, hour_rate)
        super () .__ init __ (идентификатор, имя)
  

Модуль сотрудников импортирует политики и роли из других модулей и реализует различные типы сотрудников .Вы по-прежнему используете множественное наследование для наследования реализации классов политики заработной платы и ролей производительности, но реализация каждого класса должна иметь дело только с инициализацией.

Обратите внимание, что вам по-прежнему необходимо явно инициализировать политики заработной платы в конструкторах. Вы, наверное, видели, что инициализации Manager и Secret идентичны. Кроме того, инициализации FactoryWorker и TemporarySecretary одинаковы.

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

Вот диаграмма UML для нового дизайна:

На схеме показаны отношения для определения секретарей и TemporarySecretary с использованием множественного наследования, но без проблемы ромба.

Вы можете запустить программу и посмотреть, как она работает:

  $ python program.py

Отслеживание производительности сотрудников
==============================
Мэри Поппинс: кричит и кричит 40 часов.Джон Смит: тратит 40 часов на оформление офисных документов.
Кевин Бэкон: 40 часов разговаривает по телефону.
Джейн Доу: производит гаджеты 40 часов.
Робин Уильямс: тратит 40 часов на оформление офисных документов.

Расчет заработной платы
===================
Заработная плата для: 1 - Мэри Поппинс
- Сумма чека: 3000

Зарплата для: 2 - Джон Смит
- Сумма чека: 1500

Зарплата для: 3 - Кевин Бэкон
- Сумма чека: 1250

Зарплата для: 4 - Джейн Доу
- Сумма чека: 600

Зарплата для: 5 - Робин Уильямс
- Сумма чека: 360
  

Вы видели, как наследование и множественное наследование работают в Python.Теперь вы можете изучить тему композиции.

Наследование в объектно-ориентированном программировании

Обзор

• Узнайте о наследовании в объектно-ориентированном программировании и различных формах наследования
• Общие сведения о переопределении методов и функции super () в мире объектно-ориентированного программирования

Введение

Наследование — один из наиболее важных аспектов объектно-ориентированного программирования (ООП). Ключом к пониманию наследования является то, что оно обеспечивает возможность повторного использования кода.Вместо того, чтобы писать один и тот же код снова и снова, мы можем просто наследовать свойства одного класса другому.

Это, как вы понимаете, экономит массу времени. А в науке о данных время — деньги!

ООП — это объекты реального мира, а наследование — это способ представления отношений в реальном мире. Вот пример — автомобиль, автобус, велосипед — все они подпадают под более широкую категорию под названием Автомобиль . Это означает, что они унаследовали свойства автомобилей i-го класса.Все они используются для транспортировки.

Мы можем представить эти отношения в коде с помощью наследования.

Еще одна интригующая особенность наследования заключается в том, что оно транзитивно по своей природе. Но что это значит? Мы увидим подробности позже в этой статье. Python также поддерживает различные типы наследования, о которых я подробно расскажу в этой статье.

Это вторая статья из серии статей, связанных с объектно-ориентированным программированием. Просмотрите также первую статью:

Содержание

1. Что такое наследование в объектно-ориентированном программировании?
2. Различные формы наследования в объектно-ориентированном программировании
   • Одиночное наследование
   • Множественное наследование
   • Многоуровневое наследование
   • Иерархическое наследование
   • Гибридное наследование
3. Переопределение метода
4. Функция super ()

Что такое наследование в объектно-ориентированном программировании?

Наследование — это процедура, в которой один класс наследует атрибуты и методы другого класса.Класс, свойства и методы которого наследуются, известен как родительский класс. А класс, наследующий свойства от родительского класса, — это дочерний класс.

Интересно, что наряду с унаследованными свойствами и методами дочерний класс может иметь свои собственные свойства и методы.

Вы можете использовать следующий синтаксис: \ для реализации наследования в Python:

 класс parent_class:
тело родительского класса

класс child_class (родительский_класс):
тело дочернего класса 

Давайте посмотрим на реализацию:

 class Car: #parent class

 def __init __ (я, имя, пробег):
 себя.name = имя
собственный пробег = пробег

 def описание (self):
return f "Автомобиль {self.name} показывает пробег {self.m900} км / л"

class BMW (Автомобиль): #child class
    проходить

class Audi (Автомобиль): #child class
    def audi_desc (сам):
        return "Это метод описания класса Audi." 

 obj1 = BMW ("BMW 7-й серии", 39,53)
печать (obj1.description ())

obj2 = Audi («Audi A8 L», 14)
печать (obj2.описание())
печать (obj2.audi_desc ()) 

Выход:

Мы создали два дочерних класса, а именно «BMW» и «Audi», которые унаследовали методы и свойства родительского класса «Car». Мы не предоставили никаких дополнительных функций и методов в классе BMW. А внутри класса Audi есть еще один метод.

Обратите внимание, что описание метода экземпляра () родительского класса доступно объектам дочерних классов с помощью obj1.description () и obj2.description (). И отдельный метод класса Audi также доступен с помощью obj2.audi_desc ().

Мы можем проверить базовый или родительский класс любого класса с помощью встроенного атрибута класса __bases__

 принт (BMW .__ base__, Audi .__ base__) 

Как мы видим, базовым классом обоих подклассов является Автомобиль. Теперь давайте посмотрим, что происходит при использовании __base__ с родительским классом Car:

 принт (Автомобиль .__ баз__) 

Каждый раз, когда мы создаем новый класс в Python 3.x он унаследован от встроенного базового класса Object. Другими словами, класс Object является корнем всех классов.

Формы наследования в объектно-ориентированном программировании

Существует пять основных форм наследования, основанных на участии родительского и дочернего классов.

1. Единоличное наследство

Это форма наследования, при которой класс наследует только один родительский класс. Это простая форма наследования, поэтому ее также называют простым наследованием .

 class Parent:
  def f1 (себя):
    print ("Функция родительского класса.")

class Child (Родитель):
  def f2 (себя):
    print ("Функция дочернего класса.")

object1 = Ребенок ()
object1.f1 ()
объект1.f2 () 

Здесь класс Child наследует только один класс Parent, следовательно, это пример наследования Single.

2. Множественное наследование

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

 класс Parent_1:
  def f1 (себя):
    print ("Функция класса parent_1.")

класс Parent_2:
  def f2 (себя):
    print ("Функция класса parent_2.")

класс Parent_3:
  def f3 (себя):
    print ("функция класса parent_3.")

класс Child (Родитель_1, Родитель_2, Родитель_3):
  def f4 (себя):
    print ("Функция дочернего класса.")

object_1 = Дочерний ()
object_1.f1 ()
object_1.f2 ()
object_1.f3 ()
объект_1.f4 () 

Здесь у нас есть один дочерний класс, который наследует свойства трех родительских классов Parent_1, Parent_2 и Parent_3. Все классы имеют разные функции, и все функции вызываются с использованием объекта класса Child.

Но предположим, что дочерний класс наследует два класса, выполняющих одну и ту же функцию:

 класс Parent_1:
  def f1 (себя):
    print ("Функция класса parent_1.")

класс Parent_2:
  def f1 (себя):
    print ("Функция класса parent_2.")

класс Child (Родитель_1, Родитель_2):
  def f2 (себя):
    print ("Функция дочернего класса.")
 

Здесь классы Parent_1 и Parent_2 имеют одинаковую функцию f1 (). Теперь, когда объект дочернего класса вызывает f1 (), поскольку дочерний класс наследует оба родительских класса, что, по вашему мнению, должно произойти?

 obj = Ребенок ()
obj.f1 () 

Но почему не унаследована функция f1 () класса Parent_2?

При множественном наследовании дочерний класс сначала ищет метод в своем собственном классе.Если не найден, поиск выполняется в родительских классах depth_first и в порядке слева направо. Поскольку это был простой пример с двумя родительскими классами, мы ясно видим, что класс Parent_1 был унаследован первым, поэтому дочерний класс будет искать метод в классе Parent_1 перед поиском в классе Parent_2.

Но для сложных проблем наследования трудно определить порядок. Фактический способ сделать это в Python называется Порядок разрешения методов (MRO) . Мы можем найти ТОиР любого класса с помощью атрибута __mro__

 Ребенок.__mro__ 

Это говорит о том, что класс Child сначала посетил класс Parent_1, а затем Parent_2, поэтому будет вызван метод f1 () класса Parent_1.

Давайте рассмотрим немного сложный пример на Python:

 класс Parent_1:
проходить

класс Parent_2:
проходить

класс Parent_3:
проходить

класс Child_1 (Родитель_1, Родитель_2):
проходить

класс Child_2 (Родитель_2, Родитель_3):
проходить

класс Child_3 (Ребенок_1, Ребенок_2, Родитель_3):
пройти 

Здесь класс Child_1 наследует два класса — Parent_1 и Parent_2.Класс Child_2 также наследует два класса — Parent_2 и Parent_3. Другой класс Child_3 наследует три класса — Child_1, Child_2 и Parent_3.

Теперь, просто взглянув на это наследование, довольно сложно определить порядок разрешения методов для класса Child_3. Итак, вот фактическое использование __mro __-

Мы видим, что сначала интерпретатор ищет Child_3, затем Child_1, а затем Parent_1, Child_2, Parent_2 и Parent_3 соответственно.

3.Многоуровневое наследование

Например, class_1 наследуется class_2, и этот class_2 также наследуется class_3, и этот процесс продолжается. Это называется многоуровневым наследованием. Давайте разберемся на примере:

 class Parent:
  def f1 (себя):
    print ("Функция родительского класса.")

класс Child_1 (Родитель):
  def f2 (себя):
    print ("Функция класса child_1.")

класс Child_2 (Ребенок_1):
  def f3 (себя):
    print ("Функция класса child_2.")

obj_1 = Ребенок_1 ()
obj_2 = Ребенок_2 ()

obj_1.f1 ()
obj_1.f2 ()

печать ("\ п")
obj_2.f1 ()
obj_2.f2 ()
obj_2.f3 () 

Здесь класс Child_1 наследует класс Parent, а класс Child_2 наследует класс Child_1. В этом случае Child_1 имеет доступ к функциям f1 () и f2 (), тогда как Child_2 имеет доступ к функциям f1 (), f2 () и f3 (). Если мы попытаемся получить доступ к функции f3 () с помощью объекта класса Class_1, то возникнет ошибка:

Объект «Ребенок_1» не имеет атрибута «f3»

 obj_1.f3 () 

4- Иерархическое наследование

В этом случае различные дочерние классы наследуют один родительский класс. Пример, приведенный во введении наследования, является примером иерархического наследования, поскольку классы BMW и Audi наследуют класс Car.

Для простоты рассмотрим другой пример:

 class Parent:
deff1 (сам):
print ("Функция родительского класса.")

класс Child_1 (Родитель):
deff2 (сам):
print ("Функция класса child_1.")

класс Child_2 (Родитель):
deff3 (сам):
print ("Функция класса child_2.")

obj_1 = Ребенок_1 ()
obj_2 = Ребенок_2 ()

obj_1.f1 ()
obj_1.f2 ()

печать ('\ п')
obj_2.f1 ()
obj_2.f3 () 

Здесь два дочерних класса наследуют один и тот же родительский класс. Класс Child_1 имеет доступ к функциям f1 () родительского класса и самой функции f2 (). В то время как класс Child_2 имеет доступ к функциям f1 () родительского класса и самой функции f3 ().

5- Гибридное наследование

Когда существует комбинация более чем одной формы наследования, это называется гибридным наследованием. Будет более понятно после этого примера:

 class Parent:
  def f1 (себя):
    print ("Функция родительского класса.")

класс Child_1 (Родитель):
  def f2 (себя):
    print ("Функция класса child_1.")

класс Child_2 (Родитель):
  def f3 (себя):
    print ("Функция класса child_2.")

класс Child_3 (Ребенок_1, Ребенок_2):
  def f4 (себя):
    print ("Функция класса child_3.")

obj = Child_3 ()
obj.f1 ()
obj.f2 ()
obj.f3 ()
obj.f4 () 

В этом примере два класса «Child_1» и «Child_2» являются производными от базового класса «Parent» с использованием иерархического наследования. Другой класс «Child_3» является производным от классов «Child_1» и «Child_2» с использованием множественного наследования. Класс «Child_3» теперь является производным с использованием гибридного наследования.

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

Концепция переопределения очень важна в наследовании. Это дает особую возможность дочерним классам / подклассам предоставлять конкретную реализацию метода, который уже присутствует в их родительских классах.

 class Parent:
  def f1 (себя):
    print ("Функция родительского класса.")

class Child (Родитель):
  def f1 (себя):
    print ("Функция дочернего класса.")

obj = Ребенок ()
obj.f1 () 

Здесь функция f1 () дочернего класса переопределила функцию f1 () родительского класса.Каждый раз, когда объект класса Child вызывает f1 (), выполняется функция класса Child. Однако объект родительского класса может вызывать функцию f1 () родительского класса.

 obj_2 = Родитель ()
obj_2.f1 () 

Функция super ()

Функция super () в Python возвращает прокси-объект, который ссылается на родительский класс с помощью ключевого слова super . Это ключевое слово super () в основном полезно для доступа к переопределенным методам родительского класса.

1. В иерархии классов с единичным наследованием super помогает ссылаться на родительские классы, не называя их явным образом, что делает код более удобным в сопровождении.

   Например —

    class Parent:
     def f1 (себя):
       print ("Функция родительского класса.")
   
   class Child (Родитель):
     def f1 (себя):
       супер (). f1 ()
       print ("Функция дочернего класса.")
   
   obj = Ребенок ()
   obj.f1 () 

   Здесь с помощью super ().f1 () метод f1 () суперкласса дочернего класса, то есть родительский класс, был вызван без явного его имени.

   Следует отметить, что класс super () может принимать два параметра: первый — это имя подкласса, а второй — объект, являющийся экземпляром этого подкласса. Посмотрим, как —

    class Parent:
     def f1 (себя):
       print ("Функция родительского класса.")
   
   class Child (Родитель):
     def f1 (себя):
       super (Ребенок, я) .f1 ()
       print ("Функция дочернего класса.")
   
   obj = Ребенок ()
   obj.f1 () 

   Первый параметр относится к подклассу Child , а второй параметр относится к объекту Child, которым в данном случае является self . Вы можете увидеть результат после использования super () и super (Child, self) одинаковым, потому что в Python 3 super (Child, self) эквивалентен self ().

   Теперь рассмотрим еще один пример с использованием функции __init__.

    класс Родитель (объект):
     def__init __ (self, ParentName):
       print (ParentName, 'является производным от другого класса.')
   
   class Child (Родитель):
     def__init __ (я, ChildName):
       print (name, 'это подкласс.')
       super () .__ init __ (Имя ребенка)
   
   obj = Ребенок ('Ребенок') 

   Здесь мы вызвали функцию __init__ родительского класса (внутри дочернего класса), используя super () .__ init __ (ChildName) . И поскольку для метода __init__ родительского класса требуется один аргумент, он был передан как «ChildName». Итак, после создания объекта класса Child сначала выполнялась функция __init__ класса Child, а после этого — функция __init__ класса Parent.

2. Второй вариант использования — поддержка совместного множественного наследования в динамической среде выполнения.

    класс Первый ():
     def __init __ (сам):
       print ("первый")
       супер () .__ init __ ()
   
   класс Второй ():
     def __init __ (сам):
       print ("второй")
       супер () .__ init __ ()
   
   класс Третий (Второй, Первый):
     def __init __ (сам):
       print ("третий")
       супер () .__ init __ ()
   
   obj = Третий () 

   
   Вызов super () находит следующий метод в MRO на каждом шаге, поэтому первый и второй тоже должны иметь его, в противном случае выполнение останавливается в конце first ().__init__ .

   Обратите внимание, что суперкласс Первого и Второго — это Объект.

   Давайте также найдем MRO Третьего () —

    Третий .__ mro__ 

   Порядок: Третий> Второй> Первый, и такой же порядок наших выходных данных.

Конечные ноты

В заключение, в этой статье я продвинул концепцию наследования в объектно-ориентированном программировании на Python. Я рассмотрел различные формы наследования и некоторые общие концепции наследования, такие как переопределение метода и функция super ().