Питон ооп: концепции, принципы и примеры реализации

Содержание

Что такое объектно-ориентированное программирование. Урок 1 курса «Объектно-ориентированное программирование на Python»

Циклы, ветвления и функции – все это элементы структурного программирования. Его возможностей вполне хватает для написания небольших, простых программ и сценариев. Однако крупные проекты часто реализуют, используя парадигму объектно-ориентированного программирования (ООП). Что оно из себя представляет и какие преимущества дает?

Истоки ООП берут начало с 60-х годов XX века. Однако окончательное формирование основополагающих принципов и популяризацию идеи следует отнести к 80-м годам. Большой вклад внес Алан Кей.

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

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

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

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

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

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

Каждый воин, оружие, дерево, дом – это цифровой объект, в котором «упакованы» его свойства и действия, с помощью которых он может изменять свои свойства и свойства других объектов.

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

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

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

Класс и объект

Что такое класс или тип? Проведем аналогию с реальным миром. Если мы возьмем конкретный стол, то это объект, но не класс. А вот общее представление о столах, их назначении – это класс. Ему принадлежат все реальные объекты столов, какими бы они ни были. Класс столов дает общую характеристику всем столам в мире, он их обобщает.

То же самое с целыми числами в Python. Тип int – это класс целых чисел. Числа 5, 100134, -10 и т. д. – это конкретные объекты этого класса.

В языке программирования Python объекты принято называть также экземплярами. Это связано с тем, что в нем все классы сами являются объектами класса type. Точно также как все модули являются объектами класса module.

>>> type(list), type(int)
(<class 'type'>, <class 'type'>)
>>> import math
>>> type(math)
<class 'module'>

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

Наследование, инкапсуляция, полиморфизм

Следующее по важности понятие объектно-ориентированного программирования – наследование. Вернемся к столам. Пусть есть класс столов, описывающий общие свойства всех столов. Однако можно разделить все столы на письменные, обеденные и журнальные и для каждой группы создать свой класс, который будет наследником общего класса, но также вносить ряд своих особенностей. Таким образом, общий класс будет родительским, а классы групп – дочерними, производными.

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

Основное (но не единственное) преимущество, которое дает концепция наследования в программировании, – это вынос одинакового кода из разных классов в один родительский класс. Другими словами, наследование позволяет сводить на нет повторение кода в разных частях программы.

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

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

Отсутствие сокрытия данных в Python делает программирование на нем проще, но привносит ряд особенностей, связанных с пространствами имен.

Второй смысл инкапсуляции – объединение описания свойств объектов и их поведения в единое целое, то есть в класс. Инкапсуляция в этом смысле вытекает из самой идеи объектно-ориентированного программирования и, соответственно, имеется во всех ОО-языках.

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

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

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

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

Пример объектно-ориентированной программы на Python

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

В программе определены три класса. Класс A является родительским по отношению к

B и C. Последние наследуют от A поле-переменную field1 и метод make_str, который потом переопределяют.

От каждого класса мы создаем по одному объекту и присваиваем их переменным a, b, c. Метод make_str выводит на экран значения полей объекта. У объектов разных классов разный набор полей, поэтому код метода отличается.

class A:
    field1 = 1
 
    def make_str(self):
        print(self.field1)
 
 
class B(A):
    field2 = 2
 
    def make_str(self):
        print(self.field1, self.field2)
 
 
class C(A):
    field3 = 3
 
    def make_str(self):
        print(self.field1, self.field3)
 
 
a = A()
b = B()
c = C()
 
for i in (a, b, c):
    i.make_str()

Результат выполнения программы:

1
1 2
1 3

Практическая работа

Рассмотрите схему. Подумайте над следующими вопросами:

Какие фигуры на ней вы бы назвали классами, а какие – объектами? Что обозначают пунктирные линии?
Может ли объект принадлежать множеству классов? Может ли у класса быть множество объектов?
Звезды скорее обладают разными свойствами или разным поведением? Могут ли свойства оказывать влияние на поведение?
Что могли бы обозначать стрелки?

Курс с примерами решений практических работ:
pdf-версия, android-приложение

введение в ооп на языке питон для начинающих, 11 уроков

Включено в курс

11 уроков (видео и/или текст)

13 упражнений в тренажере

33 проверочных теста

Дополнительные материалы

Помощь в «Обсуждениях»

Доступ к остальным курсам платформы

Чему вы научитесь

Грамотно использовать контекст self в зависимости от ситуации
Описывать сущности предметной области с помощью объектов и классов
Понимать, как работают объекты в Python на самом низком уровне
Использовать исключения в своем коде

Описание

На этом курсе вы изучите концепцию ООП — объектно-ориентированного программирования. Вы познакомитесь с такими понятиями как классы и объекты, раскроете основные принципы ООП как инкапсуляция, полиморфизм и наследование. В итоге научитесь описывать сущности предметной области, поймете как изнутри работают объекты в Python и как использовать исключения в коде. Знания из этого курса помогут писать более структурированный и гибкий код, который легко дополнять и изменять. Чтобы учиться было проще, стоит заранее изучить функции и основные типы коллекций в Python: списки и словари.

классы инкапсуляция связывание исключения конструктор

Программа курса

Продолжительность 12 часов

Введение
Узнать о целях курса.
теория
Концепции ООП
Познакомиться с основными концепциями ООП: классами, объектами, наследованием, инкапсуляцией, полиморфизмом.
теория
тесты
Классы, пространства имен, атрибуты
Познакомиться с концепцией классов и синтаксисом описания классов и их атрибутов.
теория
тесты
упражнение
Объекты-одиночки и глобальные переменные
Узнать, почему не стоит модифицировать классы после объявления или держать в их атрибутах изменяемые объекты, а также как это относится к модулям.
теория
тесты
упражнение
Инстанцирование классов и экземпляры
Узнать, как создаются экземпляры классов, как они зависят от самого класса и что, напротив, имеют своего.
теория
тесты
упражнение
Методы
Познакомиться с синтаксисом описания методов, концепцией связанности метода и объекта. Научиться вызывать как связанные методы, так и не связанные.
теория
тесты
упражнение
Инициализация и протоколы
Узнать, как настраивать вновь созданные объекты. Познакомиться с понятием протоколов.
теория
тесты
упражнение
Свойства
Узнать, как объявить «свойство» — атрибут класса, вычисляемый динамически. Научиться управлять изменением свойств.
теория
тесты
упражнение
Наследование
Познакомиться с механизмом наследования классов в Python. Узнать о том, как наследование помогает повторно использовать объектный код.
теория
тесты
упражнение
Исключения
Познакомиться с исключениями — важным механизмом языка Python, предназначенными для работы с ошибками и широко использующим наследование классов.
теория
тесты
упражнение
Заключение
Подвести итоги курса.
теория

Формат обучения

Испытания

Это практические задания, которые мы советуем выполнить после завершения курса. Задания помогут вам получить дополнительный опыт в программировании и закрепить полученные навыки. Обычно мы рекомендуем выполнить 3-5 испытаний. Но если не получается, не отчаивайтесь. Просто вернитесь к ним позже

Savelii Stepura15 мая 2020

Хекслет))) ну вот сложные вы задания даете конечно)))

Из всего курса ООП только первые два практических задания седлал — остальное просто мозги сломать можно)

Petr Che13 апреля 2020

Вопросов нет.

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

Рекомендуемые программы

Профессия

с нуля

Python-разработчик

Разработка веб-приложений на Django

30 марта 10 месяцев

Объектно-ориентированное программирование на Python: Учитесь на примерах

В этом руководстве рассказывается об объектно-ориентированном программировании (ООП) на Python с примерами. Это пошаговое руководство, предназначенное для людей, не имеющих опыта программирования. Объектно-ориентированное программирование популярно и доступно на других языках программирования, помимо Python, таких как Java, C++, PHP.

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

В объектно-ориентированном программировании (ООП) у вас есть возможность представлять в своем коде объекты реального мира, такие как автомобиль, животное, человек, банкомат и т. д. Простыми словами, объект – это то, что обладает некоторыми характеристиками и может выполнять определенные функции. Например, автомобиль является объектом и может выполнять такие функции, как запуск, остановка, движение и торможение. Это функции автомобиля. И характеристики это цвет автомобиля, пробег, максимальная скорость, год выпуска и т.д.

В приведенном выше примере автомобиль является объектом . Функции называются методами в мире ООП. Характеристики атрибутов (свойств) . Технически атрибуты — это переменные или значения, связанные с состоянием объекта, тогда как методы — это функции, которые влияют на атрибуты объекта.

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

Используют ли специалисты по данным объектно-ориентированное программирование?

Это один из самых распространенных вопросов, который возникает у ученых, занимающихся данными, перед изучением ООП. Когда дело доходит до манипулирования данными и машинного обучения с использованием Python, обычно рекомендуется изучать библиотеки pandas, numpy, matplotlib, scikit-learn. Эти библиотеки были написаны опытными разработчиками Python для автоматизации или упрощения большинства задач, связанных с наукой о данных. Все эти библиотеки зависят от ООП и его концепций. Например, вы строите регрессионную модель, используя библиотеку scikit-learn. Сначала вы должны объявить свою модель как объект, а затем использовать метод подгонки. Не зная основ ООП, вы не сможете понять, почему вы пишете код таким образом.

В python в основном существует 3 стиля программирования: объектно-ориентированное программирование, функциональное программирование и процедурное программирование. Проще говоря, есть 3 разных способа решения проблемы в Python. Функциональное программирование наиболее популярно среди специалистов по данным, поскольку оно имеет преимущество в производительности. ООП полезен, когда вы работаете с большими кодовыми базами, а ремонтопригодность кода очень важна.

Вывод: Хорошо изучить основы ООП, чтобы понять, что стоит за используемыми вами библиотеками. Если вы стремитесь стать отличным разработчиком Python и хотите создать библиотеку Python, вам необходимо изучить ООП (обязательно!). В то же время есть много специалистов по данным, которые не знакомы с концепциями ООП и все еще преуспевают в своей работе.

Основы: ООП в Python

В этом разделе мы подробно рассмотрим концепции, связанные с ООП в Python.

Объект и класс

Класс — это архитектура объекта. Это правильное описание атрибутов и методов класса. Например, дизайн автомобиля одного типа — это класс. Вы можете создать множество объектов из класса. Как вы можете сделать много автомобилей одного и того же типа из конструкции автомобиля.

Существует множество реальных примеров классов, описанных ниже —

Рецепт омлета — это класс. Омлет — это объект.
Владелец банковского счета — это класс. Атрибутами являются Имя, Фамилия, Дата рождения, Профессия, Адрес и т. д. Методы могут быть «Смена адреса», «Смена профессии», «Смена фамилии» и т. д. «Смена фамилии» обычно применима к женщины, когда они меняют фамилию после замужества
Собака — это класс. Атрибуты: Порода, Количество ног, Размер, Возраст, Цвет и т. д. Методы могут быть Едят, Спят, Сидят, Лают, Бегают и т. д.

В Python мы можем создать класс, используя ключевое слово class . Метод класса может быть определен ключевым словом def . Она похожа на обычную функцию, но определена внутри класса и является функцией класса. Первым параметром в определении метода всегда является self и метод вызывается без параметра self .

Пример 1: Создать класс автомобиля

класс : автомобиль
атрибуты : год, мили на галлон и скорость
методы : ускорение и торможение
объект : автомобиль1

класс автомобиля:
    
    # атрибуты
        year = 2016 # год выпуска модели автомобиля
        миль на галлон = 20 # пробег
        скорость = 100 # текущая скорость
        
    # методы
        Ускорение по определению (само):
            вернуть автомобиль. скорость + 20
        деф тормоз(сам):
            скорость возврата автомобиля - 50

автомобиль1=автомобиль()
car1.ускорить()
120
car1.тормоз()
50
автомобиль1.год
2016
машина1.миль на галлон
20
автомобиль1.скорость
100

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

Пример 2: Создание класса компании

В приведенном ниже примере мы создаем класс с именем company. Здесь атрибутами являются название, оборот, выручка и количество сотрудников, работающих в компании. Метод — доход, полученный на одного работника (назовем его производительность для демонстрационных целей).

# Создает класс Company
класс Компания:
    
    # атрибуты
    имя = "Банк XYZ"
    оборот = 5000
    доход = 1000
    количество_сотрудников = 100
    
    # метод
    Производительность по определению (я):
        вернуть Company.revenue/Company.no_of_employees

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

Название компании
  Выход 
«XYZ Банк»
Компания.оборот
  Выход 
5000
Company.no_of_employees
  Выход 
100
Компания().производительность()
  Выход 
10,0

Конструктор

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

Объекты являются экземплярами класса. Слова «экземпляр» и «объект» взаимозаменяемы. Процесс создания объекта класса называется экземпляр .

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

классный человек:
        def __init__(я,имя,фамилия):
            self.first = имя
            self.last = фамилия
мое имя = человек ("Дипаншу", "Бхалла")
распечатать (мое имя.последнее)

Мы создали myname объект класса person.

 При создании нового объекта >>> вызывается метод __init__ >>> Поведение внутри метода __init__ выполняется

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

.
класс Моя компания:
        
    # методы
    def __init__(я, название компании, доход, размер сотрудников):
        self.name = название компании
        собственный доход = доход
        self.no_of_employees = количество сотрудников
    Производительность по определению (я):
        вернуть self.revenue/self.no_of_employees
Моя компания('Банк XYZ', 1000,100).производительность()
  Выход 
10,0
MyCompany('ABC Bank', 5000,200). productivity()
  Выход 
25,0

Альтернативный способ вызова метода класса

Банк = MyCompany('ABC Bank', 5000,200)
MyCompany.productivity(Банк)

Переменные

Атрибуты класса также называются переменными. Существует два вида переменных: одна объявляется внутри класса, но вне методов класса, а другая объявляется внутри __init__ .

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

класс Моя компания:
    #Переменная класса
    рост = 0,1
            
    def __init__(я, название компании, доход, размер сотрудников):
        #Переменные экземпляра
        self. name = название компании
        собственный доход = доход
        self.no_of_employees = количество сотрудников
МояКомпания.рост
  0,1

Как получить переменную дохода из класса MyCompany?

Неправильный путь

Моя компания.доход

AttributeError: объект типа «Моя компания» не имеет атрибута «доход»

Правильный путь

Банк = МояКомпания('Банк DBA',50000, 1000)
Банк.доход

50000

MyCompany.revenue возвращает ошибку, поскольку к ней невозможно получить доступ, поскольку объект не создан.

Методы

В python есть три типа методов: экземпляр, класс и статический.

Экземпляр принимает self в качестве первого аргумента. Их также называют Object или обычным методом . Это тот же метод, который мы уже изучили в предыдущих разделах.
Класс принимает cls в качестве первого аргумента. cls относится к классу. Чтобы получить доступ к переменной класса в методе, мы используем @classmethod 9декоратор 0010 и передать класс методу
Статический ничего не принимает в качестве первого аргумента. Он имеет ограниченное использование, которое объясняется в последней части этой статьи.

Чем отличаются методы экземпляра и класса?

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

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

Здесь мы создаем 3 метода: rateperkm , noofcabs , avgnoofpassengers . Первый — это метод экземпляра, а два других — методы класса.

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

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

Кабина класса:
    
    #Инициализировать переменные для первой итерации
    количество кабин = 0
    количество пассажиров = 0
    def __init__(я,водитель,км,места,оплата,пассажиры):
        self.driver = водитель
        автономный пробег = км
        self.places = места
        селф.билл = платить
        Cab.numberofcabs = Cab.numberofcabs + 1
        Cab.numpassengers = Cab.numpassengers + пассажиры
    #Возвращает цену такси за км
    def rateperkm(я):
        возврат self.bill/self.running
        
    #Возвращает количество запущенных кабин
    @классметод
    определение noofcabs (cls):
        вернуть cls.numberofcabs
    #Возвращает среднее количество пассажиров в кабине
    @классметод
    определение avgnoofpassengers (cls):
        вернуть целое (cls.numpassengers/cls.numberofcabs)
firstcab = Cab("Рамеш", 80, ['Дели', 'Нойда'], 2200, 3)
secondcab = Cab("Суреш", 60, ['Гургаон', 'Нойда'], 1500, 1)
Thirdcab = Cab("Дэйв", 20, ['Гургаон', 'Нойда'], 680, 2)
firstcab. водитель
  'Рамеш'
 
водитель второго такси
  'Суреш'
 
третий каб.водитель
  'Дэйв'

firstcab.rateperkm()
  27,5 
secondcab.rateperkm()
  25,0 
Thirdcab.rateperkm()
  34,0

Кабина.noofcabs()
  3
 
Cab.avgnoofpassengers()
  2

Cab.avgnoofpassengers() возвращает 2, что вычисляется как (3 + 1 + 2)/3

Статические методы

Статический метод является наименее популярным среди всех трех методов. В отличие от методов экземпляра и класса, статический метод не принимает в качестве первого параметра специальное ключевое слово (self, cls). Он имеет ограниченное использование, потому что ни вы не можете получить доступ к свойствам экземпляра (объекта) класса, ни вы не можете получить доступ к атрибутам класса. Единственное использование - его можно вызывать без объекта. Это в основном полезно для создания вспомогательных или служебных функций, таких как проверка имени водителя (имя водителя должно быть меньше 32 символов) или сумма счета должна быть больше нуля (не может быть отрицательной или нулевой). См. программу ниже для той же задачи.

Кабина класса:
    
    @статический метод
    деф биллинга (оплата):
        возврат int (оплата)> 0
Cab.billvalidation(0,2)
  Выход 
ЛОЖЬ

`Наследство`

Наследование использует код для класса Children , который уже был написан для класса Parent . Например, некоторые атрибуты класса транспортного средства совпадают с классами автомобилей, автобусов и грузовиков. Имя водителя, количество колес и т. д. одинаковы для всех классов. Автомобиль родительского класса и Автомобиль, автобус и грузовик относятся к классам детей . В ООО это означает, что класс наследует атрибуты и методы поведения от своего родительского класса.

Создать родительский класс Vehicle и использовать его атрибуты для дочернего класса Vehicle . В приведенной ниже программе нам не нужно указывать атрибуты класса cab. Он наследуется от транспортного средства.

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
класс Кабина(Автомобиль):
    проходить
cab_1 = Кабина («Сэнди», 4, 2)
кабина_1.водитель
  Выход 
'Сэнди'

 Как изменить переменную класса подкласса  Транспортное средство

класс Транспортное средство:
    минимальная ставка = 50
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
класс Кабина(Автомобиль):
    минимальная ставка = 75
Транспортное средство.минимальная ставка
  50 
Минимальная ставка кабины
  75

 Как создать дочерний класс с большим количеством параметров, чем у родительского класса

В этом примере у нас есть два класса Cab и Bus , у которых много схожих атрибутов, но есть несколько уникальных для данного класса. Чтобы решить эту проблему, мы создали родительский класс с именем Vehicle , который содержит общие атрибуты и метод.

класс Транспортное средство:
    минимальная ставка = 50
    def __init__(я,водитель,колеса,сиденья,км,счет):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
        автономный пробег = км
        селф.билл = счет
    
    def rateperkm(я):
        возврат self.bill/self.running
класс Кабина(Автомобиль):
    минимальная ставка = 75
    def __init__(я,водитель,колеса,сиденья,км,счет,тип кабины):
        Vehicle.__init__(я,водитель,колеса,сиденья,км,счет)
        self.category = тип такси
Класс Автобус(Автомобиль):
    минимальная ставка = 25
    def __init__(я,водитель,колеса,сиденья,км,счет,цвет):
        Vehicle.__init__(я,водитель,колеса,сиденья,км,счет)
        self.color = цвет
cab_1 = Cab('Prateek', 4, 3, 50, 700, 'Внедорожник')
cab_1.категория
cab_1.rateperkm()
bus_1 = Bus('Дэйв', 4, 10, 50, 400, 'зеленый')
bus_1. цвет
bus_1.rateperkm()

Мы можем заменить эту команду Vehicle.__init__(я,водитель,колеса,сиденья,км,счет) на super().__init__(водитель,колеса,сиденья,км,счет) . super() используется для ссылки на родительские атрибуты и методы.

`Полиморфизм`

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

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

Переопределение метода позволяет нам иметь метод в дочернем классе с тем же именем, что и в родительском классе, но определение метода дочернего класса отличается от метода родительского класса.

класс Транспортное средство:
    защитное сообщение (я):
        print("Метод родительского класса")
класс Кабина(Автомобиль):
    защитное сообщение (я):
        print("Метод класса дочерней кабины")
Класс Автобус(Автомобиль):
    защитное сообщение (я):
        print("Метод класса дочерней шины")
х = Транспортное средство ()
х. сообщение()
  Метод родительского класса 
у = кабина ()
у.сообщение()
  Метод класса Child Cab 
г = автобус ()
z.сообщение()
  Метод класса дочерней шины

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

`Перегрузка метода`

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

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

Сообщение класса:
    детали защиты (я, фраза = нет):
    
        если фраза не None:
            print('Мое сообщение - ' + фраза)
        еще:
            print('Добро пожаловать в мир Python')
        
# Объект
х = сообщение ()
    
# Вызов метода без параметров
х. детали()
    
# Вызов метода с параметром
x.details('Жизнь прекрасна')

`Что такое str?`

Он используется для создания удобочитаемого представления объекта.

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
veh_1 = Автомобиль ("Песчаный", 4, 2)
печать (veh_1)
  Выход 
 __main__.Объект транспортного средства по адресу 0x0000019ECCCA05F8

класс Транспортное средство:
    def __init__(я,водитель,колеса,сиденья):
        self.driver = водитель
        self.noofwheels = колеса
        self.noofseats = места
    защита __str__(я):
        return "Имя водителя:" + self.driver + ";" + "Количество мест в кабине:" + str(self.noofseats)
veh_1 = Автомобиль ("Песчаный", 4, 2)
печать (veh_1)
  Выход 
Имя водителя: Сэнди;
Количество мест в кабине: 2

`Инкапсуляция данных`

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

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

класс Квартира:
    защита __init__(сам):
        self.type = "премиум"
        self.__bhk = "3 BHK"
flat_1 = Квартира()
квартира_1.тип
премия
flat_1.__bhk
AttributeError: объект «Плоский» не имеет атрибута «__bhk»

В приведенной выше программе type является общедоступным атрибутом, а bhk — приватным атрибутом, к которому нельзя получить доступ за пределами класса.

`Добытчики и сеттеры`

Они используются для получения и обновления значения переменной. Сеттер — это метод, который обновляет значение переменной. Getter — это метод, который считывает значение переменной. Давайте узнаем это на примерах.

класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        self.email = self.fdriver + '.' + self.ldriver + '@uber.com'
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.fдрайвер
  Сэнди 
veh_1.email
  'Сэнди.Стюарт@uber.com'

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

veh_1.fdriver = 'Том'
veh_1.fдрайвер
  'Том' 
veh_1.email
  'Сэнди.Стюарт@uber.com'

Имя было изменено с Сэнди на Том, но адрес электронной почты остался прежним. Хорошо, возникает очевидный вопрос «как обновить адрес электронной почты?». С использованием @property декоратор мы можем изменить поведение электронной почты. email(self) — это метод, но он работает как обычное свойство. Этот специальный метод называется Getters and Setters

.
класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        
    @свойство
    адрес электронной почты (я):
        вернуть self.fdriver + '.' + self.ldriver + '@uber.com'
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.fdriver = 'Том'
veh_1.email
  '[email protected]'

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

класс Транспортное средство:
    def __init__(я,имя_водителя,фамилия_водителя):
        self.fdriver = имя_водителя
        self.ldriver = фамилия_водителя
        
    @свойство
    адрес электронной почты (я):
        вернуть self.fdriver + '.' + self.ldriver + '@uber.com'
    @email.setter
    адрес электронной почты (я, адрес):
        первый = адрес[:address. find('.')]
        последний = адрес[address.find('.')+1:address.find('@')]
        self.fdriver = первый
        self.ldriver = последний
veh_1 = Автомобиль ("Сэнди", "Стюарт")
veh_1.email = '[email protected]'
veh_1.fдрайвер
  'глубокий' 
veh_1.lдрайвер
  'бхалла'

Валидация

В реальном мире геттеры и сеттеры в основном используются для включения логики проверки. В приведенном ниже примере мы создаем класс пожертвований с атрибутом суммы. Сумма должна находиться в диапазоне от 10 до 1 000 000. Если пользователь вводит меньше 10, оно должно быть установлено как 10. Точно так же, если пользователь пытается ввести значение больше 1 миллиона, оно должно быть ограничено только 1 миллионом.

пожертвование класса:
    def __init__(я, количество):
        самостоятельная сумма = сумма
        
    @свойство
    Сумма защиты (я):
        вернуть себя.__сумма
    @amount.setter
    сумма защиты (я, сумма):
        если сумма 1000000:
            сам. __сумма = 1000000
        еще:
            self.__amount = количество
благотворительность = пожертвование (5)
благотворительность.сумма
  10

`Как импортировать класс`

В этом разделе мы расскажем, как загрузить класс из другого файла или каталога.

Сохраните следующий скрипт как Mymodule.py

"""
Класс автомобиля
"""
Кабина класса:
    
    #Инициализировать для первой итерации
    количество кабин = 0
    def __init__(я,водитель,км,оплата):
        self.driver = водитель
        автономный пробег = км
        селф.билл = платить
        Cab.numberofcabs = Cab.numberofcabs + 1
    #Возвращает среднюю цену за км
    def rateperkm(я):
        возврат self.bill/self.running
        
    #Возвращает количество запущенных кабин
    @классметод
    определение noofcabs (cls):
        вернуть cls.numberofcabs
если __name__ == "__main__":
    
    #Класс кабины
    firstcab = Cab("Рамеш", 80, 1200)
    Атрибут #driver в классе Cab
    печать (firstcab. driver)
    
    #метод класса
    печать (Cab.noofcabs())

В приведенном ниже коде укажите каталог, в котором хранится файл Mymodule.py

импорт ОС
os.chdir("C:/Пользователи/DELL/Рабочий стол/")
импортировать мой модуль

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

.#Класс кабины в Mymodule.py
firstcab = Mymodule.Cab("Рамеш", 80, 1200)
Атрибут #driver в классе кабины
firstcab.водитель
Метод экземпляра #rateperkm в Mymodule2.py
firstcab.rateperkm()
Метод класса #noofcabs в Mymodule2.py
Мой модуль.Cab.noofcabs()
 
Чтобы избежать написания имени модуля для доступа к классу, вы можете использовать «из», который загружает модуль в текущее пространство имен.из импорта Mymodule *
firstcab = Cab("Сэнди", 80, ['Дели', 'Нойда'], 1200, 3)

`Что такое name == "main"?`

Любой код, находящийся внутри , если __name__ == '__main__': , будет выполняться, когда вы запускаете файл . py напрямую (из терминала).

Если вы импортируете модуль , импортируйте Mymodule , код внутри if __name__ == '__main__': не будет запущен.

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

если __name__ == '__main__':
    print('Первый результат')
еще:
    print('Второй результат')

Как изменить каталог в командной строке

Введите cd , затем пробел и имя папки. После того, как правильный каталог установлен, вы можете ввести имя вашего файла сценария Python. См. снимок ниже.

`Упражнение`

Создайте класс Rectangle с атрибутами длины и ширины. Создайте 2 метода для вычисления площади прямоугольника и периметра прямоугольника. Площадь рассчитывается путем умножения длины на ширину. Периметр в 2 раза больше (длина+ширина). Решите и опубликуйте свое решение в поле для комментариев.

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

`ООП в Python | Концепции ООП в Python для начинающих`

Эта статья была опубликована в рамках блога по науке о данных.

`Введение`

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

Определенно нет. Для таких поклонников Python, как мы, Python предлагает объектно-ориентированный стиль программирования.

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

 Изображение взято из блога. glugmvit.com
 Основы объектно-ориентированного программирования (ООП) в Python  Чтобы изучить суть объектно-ориентированного программирования на Python, мы изучим следующие темы в этой статье, как теоретическую часть, так и часть реализации.
 Темы для обсуждения: -
 Классы
 объектов
 Наследство
 Атрибуты
 Методы
 Давайте начнем наше путешествие по изучению ООП в Python!
  ПРИМЕЧАНИЕ . В оставшейся части статьи я буду называть объектно-ориентированное программирование аббревиатурой ООП.
 Необходимые условия  В этой статье, поскольку мы собираемся реализовать и эти концепции, вот предварительные условия:-
 Дистрибутив Anaconda должен быть установлен на компьютере
 Блокнот Jupyter (установится автоматически при установке дистрибутива Anaconda)
 Либо ОС Windows, либо дистрибутив на базе Linux, например. Убунту
 Здесь я буду реализовывать все эти концепции в блокноте Jupyter в Ubuntu 20.04.2 LTS. Опять же, выбор ОС не влияет, так как это личные предпочтения. Все концепции, которые мы собираемся изучить, будут одинаковыми независимо от используемой операционной системы.
 Класс в ООП  Что такое классы в ООП? Давайте легко поймем эту концепцию с помощью картинки.
 Если мы проанализируем изображение выше, мы увидим там класс, объект, атрибуты, методы и Пикачу :). Вы можете подумать о том, какое отношение все это имеет к ООП. Что ж, приведенное выше изображение — это именно то, что нам нужно, чтобы легко понять концепции ООП.
 Итак, переходим к первой теме. Что понимается под классом в ООП? Техническое определение класса: « Класс представляет собой набор объектов того же типа  «.Давайте свяжем это с нашим примером выше.
 Здесь, на этом изображении, мы видим прямоугольник с названием «Покемон». Это в основном имя нашего класса. Проще говоря, класс — это не что иное, как набор объектов. Таким образом, все покемоны во вселенной покемонов будут относиться к классу «покемон».
 Объект в ООП  В предыдущем разделе мы видели, что подразумевается под классом в ООП. Теперь давайте разберемся с концепцией объекта в ООП.
  
 В ООП объект в основном является составной частью или членом класса. Принимая во внимание наш пример с покемонами, каждый покемон является объектом класса покемонов. Например. Пикачу — объект класса покемонов.
 Атрибуты в ООП  Вернемся к нашему примеру с покемонами. Давайте сосредоточимся на Пикачу на изображении. Просто заметил это на мгновение. Что вы видите?
 Просто взглянув на изображение Пикачу, мы можем увидеть, что у него два уха, две руки, две ноги, две маленькие красные точки на щеках и характерный желтый цвет. В дополнение к этому в соседней таблице на изображении мы видим еще несколько вещей, таких как Имя = «Пикачу», Тип = «Электрик» и Здоровье = 70. Так что все они известны как атрибуты. Атрибуты — это элементы, предоставляющие дополнительную информацию о классах или объектах. В данном случае все эти атрибуты предоставляют дополнительную информацию об объекте Пикачу, такую как цвет, тип здоровья и т. д.
 Методы в ООП  В нашем примере под тремя нижними строками мы видим что-то вроде Attack(), Dodge() и Evolution(). Они известны как методы. Проще говоря, методы — это, по сути, действия, связанные с определенным объектом. В данном случае эти действия связаны с нашим объектом Пикачу.
 Теперь у нас есть теоретическое понимание различных объектно-ориентированных концепций в Python. Теперь давайте реализуем эти концепции в Python, используя блокнот Jupyter.
 Здесь я собираюсь реализовать эти концепции с помощью ноутбука Jupyter в Ubuntu 20.04.2 LTS, но. Опять же, выбор ОС является личным предпочтением, поскольку все концепции, которые мы здесь видим, будут одинаковыми на любой платформе.
 Практическая реализация ООП на Python  Давайте начнем реализовывать концепции ООП в Python. Здесь мы будем кодировать с помощью блокнота Jupyter. Опять же, выбор IDE зависит от личных предпочтений. Будучи специалистом по данным, я провел большую часть своего времени, используя блокнот jupyter, и поэтому я использую то же самое здесь и для ООП.
 Создание класса в Python  Давайте создадим наш класс с именем «Покемон» на питоне.
 Код для создания класса:  #Создание класса "Покемон"
класс Покемон(): 
 Как видно из приведенного выше кода, существует определенная структура, которой необходимо следовать при создании класса в Python. По соглашению нужно начинать с ключевого слова с именем «класс ».  Таким образом, Python может распознать, что все, что мы пытаемся создать, будет считаться классом. Затем за классом ключевого слова следует имя класса, в данном случае Pokemon. В конце концов, за ним следует ( ), за которым снова следует символ «:».
 Теперь у вас может возникнуть вопрос – «Завершено ли создание нашего класса?». Пока нет. Есть еще несколько строк кода, которые нам нужно записать в нашем классе, чтобы завершить его создание.
 Создание метода __init__ для класса  Продолжая нашу задачу по созданию класса, следующим шагом было создание очень специального метода с именем «__init__». Вы можете спросить: «Что это за метод __init__ и почему он так называется?». Чтобы легко понять эту концепцию, рассмотрим метод init, аналогичный основному методу в Java.
 Если мы проанализируем любой java-код, мы увидим, что с каждым классом связан основной метод. Та же концепция и в Python. Здесь вместо того, чтобы называть его «основным» методом, он известен как метод «__init__». Давайте добавим этот код в наш класс.
 Код для создания метода __init__() для класса:  #Создание класса "Покемон"
класс Покемон():
защита __init__(): 
 Как видно из приведенного выше кода, здесь мы создали наш метод __init__ в Python. Здесь мы замечаем одну вещь, а именно ключевое слово с именем 9. 0025 «защита».  Для чего здесь используется ключевое слово def? По сути, def — это ключевое слово в Python, которое мы используем для определения метода определения объекта.
 Также здесь вы заметили одну вещь. По умолчанию Python выравнивает некоторые отступы в коде, который мы пишем. Мы наблюдаем то, что известно как «Синтаксический движок» в Python. Этот синтаксический движок работает сам по себе. Его основная цель — сделать наш код аккуратным и чистым.
 Поскольку мы определили наш метод __init__() для нашего класса, он все еще не определен полностью. Тем не менее, некоторые аргументы должны быть переданы в метод __init__() для завершения его определения. Давайте добавим эти аргументы в наш метод __init__().
 Код для определения атрибутов, связанных с классом:  #Создание класса "Покемон"
класс Покемон():
  def __init__(я, имя, тип, здоровье):
  self.name = имя
  self.Type = Тип
self.health = здоровье 
 Как видно из приведенного выше кода, мы передали множество аргументов в наш метод __init__(). Теперь давайте немного вернемся назад, чтобы понять, какие параметры здесь передаются.
 Помните, недавно мы обсуждали, что у нашего Пикачу желтый цвет, две красные точки на щеках и т. д. По сути, это атрибуты, связанные с объектом, и в этом методе __init__() мы просто передаем определение этих атрибутов.
 Теперь у вас может возникнуть другой вопрос: «Какой смысл в ключевом слове «я» и что такое «я» ниже. строка кодов делает?». Чтобы объяснить это простыми словами, «я» — это ключевое слово, которое отвечает за связь этих атрибутов с нашим классом, которым в данном случае является покемон.
 Следующие 3 строки кода «self…» отвечают за подключение этих атрибутов к нашему классу. Теперь приступим к дальнейшей части
 Создание методов для класса  До этого момента мы объявили наш класс, специальный метод с именем __init__() и атрибуты для класса. Теперь давайте приступим к нашей последней части — созданию метода.
 Код для создания метода в Python:  защитная атака (на себя):
print("Электрическая атака!!. Упс!!!") 
 Как видно из приведенного выше кода, здесь мы создаем метод с именем Attack(). Если вы внимательно изучили этот фрагмент кода, то увидите, что для этого метода мы передали здесь аргумент с именем «self». Причина опять та же. Здесь мы подключаем этот метод к нашему классу, используя ключевое слово self.
 Если вы видите наш пример изображения выше, с нашим классом Pokemon связаны три метода — Attack(), Dodge(), Evolve(). Здесь, поскольку мы уже создали наш метод Attack(), давайте включим оставшиеся два метода в наш класс.
 Как только мы включим все эти изменения, наш окончательный класс покемонов будет выглядеть так
 Класс покемонов с включенными атрибутами и методами:  #Создание класса "Покемон"
класс Покемон():
  def __init__(я, имя, тип, здоровье):
  self.name = имя
  self.Type = Тип
  self.health = здоровье

  Защитная атака (на себя):
  print("Электрическая атака!!.Упс!!!")


  Уклонение от защиты (от себя):
  print("Пикачу Додж!")

  деф эволюция(сам):
print("Эволюция в Райчу!!!!") 
 Теперь осталось только выполнить нашу строку кода, и мы закончили с созданием класса. Как только эта строка кода будет выполнена, вы увидите что-то подобное в блокноте Jupyter.
 Окончательный результирующий класс покемонов Следующая часть нашего ООП-путешествия — создание экземпляра класса, который по сути является объектом.
 Создание объекта в Python  Теперь продолжим создание объекта в Python.
 Код для создания объекта в Python:  #Создание объекта класса "Покемон"
pk1 = Покемон ("Пикачу", "Электрик", 120) 
 Здесь вы видите, что мы создали объект с именем pk1.
 Доступ к атрибутам, связанным с объектом  Доступ к атрибутам, связанным с объектом, можно получить с помощью. (точка) операторы. Давайте получим доступ ко всем атрибутам, связанным с нашим объектом pk1 в блокноте Jupyter.
 Код для доступа к атрибуту имени объекта pk1:  В приведенном выше коде мы видим, что получили доступ к атрибуту имени, связанному с нашим объектом pk1. Таким же образом давайте получим доступ ко всем атрибутам, связанным с нашим объектом.
 Код для доступа к атрибуту типа объекта pk1:  # Доступ к атрибуту Type объекта pk1
pk1.Тип 
  Вывод: 
 «Электрик» 
 Доступ к методам, связанным с объектом  Мы также можем получить доступ к методам, связанным с нашим объектом, используя оператор точки. Итак, давайте быстро получим доступ ко всем методам, связанным с нашим объектом pk1.
 Код для доступа к методу атаки() объекта pk1:  pk1.атака() 
  Вывод: 
 Электрическая атака!! 
 Код для доступа к методу evolution() объекта pk1:  #Доступ к методу evolution() объекта pk1
pk1.evolve() 
  Вывод: 
 Эволюция в Райчу!!!! 
 Код для доступа к методу dodge() объекта pk1:  #Доступ к методу dodge() объекта pk1
pk1.увернуться() 
  Вывод: 
 Пикачу Додж! 
 Здесь важно отметить, что при доступе к методам, связанным с нашим объектом, нам нужно поставить () после имени метода.
 Наследование в ООП  Наследование — одна из ключевых концепций ООП. Давайте легко поймем эту концепцию с помощью простого примера.
 Рассмотрим пример суперкара ex. Макларен 720С Спайдер. По сути это суперкар. Для тех из вас, кто интересуется автомобилями, я говорю именно об этом.
 McLaren 720S — изображение взято с сайта slashgear.com Как видите, как и у большинства других автомобилей, у него есть некоторые общие характеристики, такие как двери, лобовое стекло, 4 колеса, фары, задние фонари и т. д. Однако, поскольку это суперкар, у него есть свои особенности, такие как 720-сильный V8. двигатель с турбонаддувом, изготовленная на заказ коробка передач, разработанная McLaren, и настроенная система полного привода (AWD).
 Теперь, соотнося это с объектно-ориентированной терминологией, мы можем сказать, что этот автомобиль наследует определенную функцию от своего родительского класса, который в данном случае будет классом автомобиля. И это концепция наследования.
 Наследование — это явление, при котором элемент приобретает характеристики своего родительского класса. Так что в данном случае наш McLaren 720S spyder наследует все общие черты от легкового класса, но в то же время сам имеет некоторые особенности.
 Надкласс и подкласс 
 Класс, от которого наследуется наш элемент (в данном случае класс Car), известен как суперкласс и является универсальным по своей природе. В то время как класс, который наследует эти характеристики, известен как подкласс, который является специфичным по своей природе.
 Давайте сейчас реализуем эти концепции в Python. В этом случае мы создадим два класса. Один будет классом с именем «Автомобиль» и будет нашим суперклассом. Другой класс будет называться «McLaren» и будет нашим подклассом. Этот класс McLaren унаследует все свойства класса Car.
 Создание класса Car в Python:  класс Автомобиль():
  def __init__(self,ndoors,nwheels,tailLight,headLight):
  self. ndoors = ndoors
  self.nwheels = nwheels
  self.tailLight = хвостовой свет
self.headLight = головной свет 
  
 Здесь мы создали наш первый класс под названием «Автомобиль». Теперь мы собираемся создать наш новый класс с именем «McLaren», который унаследует все атрибуты этого класса
.  Создание класса McLaren в Python: 
 класс McLaren(автомобиль):
  def __init__(self,ndoors,nWheels,tailLight,headLight,Engine,Wheel_Drive):
  Car.__init__(self,ndoors,nWheels,tailLight,headLight)
  self.Engine = Двигатель
  self.Wheel_Drive = Wheel_Drive

Защитный диск (я):

print("Я за рулем McLaren 720S Spyder") 
 Как вы можете видеть в этом коде выше, поскольку наш класс McLaren наследует класс Car, мы упомянули Car в качестве одного из параметров при создании нашего класса McLaren, и это в основном представляет этот механизм наследования в Python.
 Теперь пришло время проверить нашу теорию о том, наследует ли наш класс McLaren черты класса Car или нет.
 Код для создания объекта класса McLaren:  #Создание объекта класса McLaren
mk1 = McLaren("4","4","Да","Да","V8","Полный привод") 
 Теперь давайте попробуем получить доступ к атрибуту, специфичному для класса McLaren
.  Код для доступа к атрибуту двигателя класса McLaren: 
 Атрибут #Aceesing Engine для класса McLaren
mk1.Двигатель 
  Вывод: 
 'В8' 
 Код для доступа к полному приводу класса McLaren:  #Доступ к атрибуту Wheel_Drive для класса McLaren
mk1.Wheel_Drive 
  Вывод: 
 «Полный привод» 
 Здесь мы видим, что можем получить доступ к атрибутам, специфичным для объекта McLaren. Поскольку здесь мы наследуем наш базовый класс, который в данном случае является классом Car, давайте посмотрим, были ли эти атрибуты из базового класса унаследованы или нет в нашем классе McLaren.
  Код для доступа к унаследованным атрибутам: 
  Унаследованные атрибуты головного света: 
  мк1.