Python ООП

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

1.  Объекты: В ООП, "объект" - это экземпляр класса. Класс - это шаблон, описывающий атрибуты и методы объекта. Объекты могут быть созданы на основе классов.
2.  Классы: Классы определяют структуру и поведение объектов. Они содержат атрибуты (переменные) и методы (функции), которые могут быть использованы объектами, созданными на основе этого класса.
3.  Инкапсуляция: Это механизм, позволяющий скрывать детали реализации и предоставлять только необходимый интерфейс для работы с объектами. Это достигается с помощью уровней доступа и сокрытия данных.
4.  Наследование: Наследование позволяет создавать новые классы на основе существующих. Подкласс (наследник) наследует атрибуты и методы родительского класса, что способствует повторному использованию кода.
5.    Полиморфизм: Полиморфизм позволяет объектам разных классов использовать общий интерфейс. Это означает, что разные классы могут иметь методы с одним и тем же именем, но с разной реализацией.

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

1.  Простота и читаемость кода: Python славится своей читаемостью и простотой. Это означает, что код, написанный на Python, легче понимать и поддерживать. Это особенно важно в контексте ООП, где структура программы организована вокруг объектов и классов.
2.  Динамическая типизация: Python является динамически типизированным языком, что означает, что вы можете создавать объекты и изменять их типы во время выполнения программы. Это делает код более гибким при работе с объектами и данными.
3.  Автоматическое управление памятью: Python предоставляет автоматическое управление памятью, что означает, что вам не нужно беспокоиться о выделении и освобождении памяти вручную. Это снижает вероятность утечек памяти и делает работу с объектами более удобной.
4.  Большая стандартная библиотека: Python поставляется с обширной стандартной библиотекой, которая включает множество модулей и классов, готовых к использованию. Это упрощает создание объектов и решение разнообразных задач, не требуя разработки всего с нуля.
5.  Поддержка множества парадигм: Python не ограничивается только ООП. Он поддерживает и другие парадигмы программирования, такие как процедурное и функциональное программирование. Это позволяет разработчикам выбирать подход, который наилучшим образом подходит для конкретной задачи.
6.  Богатое сообщество и документация: Python имеет активное сообщество разработчиков, а также обширную документацию. Это означает, что всегда можно найти поддержку, учебные материалы и готовые решения для разработки объектно-ориентированных приложений.

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

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

Для создания класса в Python используется ключевое слово class, за которым следует имя класса. Общий синтаксис создания класса выглядит следующим образом:

class ClassName:
   # Атрибуты и методы класса

Пример создания простого класса:

class MyClass:
   # Атрибуты класса
   attribute_first = "Значение атрибута 1"
   attribute_second = "Значение атрибута 2"

   # Методы класса
   def method_first(self):
       return "Это метод 1"

   def method_second(self):
       return "Это метод 2"

Здесь MyClass - это имя созданного класса. Класс может содержать атрибуты (переменные) и методы (функции).

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

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

Создание объектов в Python выполняется путем инстанциации класса.

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

my_object = MyClass()

Созданный объект мой_объект будет иметь доступ к атрибутам и методам, определенным в классе MyClass. Например, чтобы получить значение атрибута attribute_first, вы можете использовать my_object.attribute_first, а для вызова метода method_first - my_object.method_first().

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

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

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

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

Пример определения базового класса:

class ParentClass:

   def parent_method(self):
       print("Это метод базового класса")

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

class Subclass(ParentClass):

   def child_method(self):
       print("Это метод подкласса")

• Использование унаследованных методов: В подклассе можно использовать методы и атрибуты, унаследованные от базового класса. Например, метод метод_родителя из базового класса можно вызвать из подкласса:

subclass_object = Subclass()
subclass_object.parent_method()  # Вызов метода родителя

• Переопределение методов: Подкласс может также переопределить (override) методы, унаследованные от базового класса. Это означает, что вы можете предоставить новую реализацию метода в подклассе, заменяя старую реализацию из базового класса.

Пример переопределения метода в подклассе:

class Subclass(ParentClass):

   def parent_method(self):
       print("Это новая реализация метода в подклассе")

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

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

3. Абстрактные классы - это особый тип классов в объектно-ориентированном программировании, который не предоставляет конкретную реализацию методов, но определяет интерфейс, который должен быть реализован в подклассах. В Python, абстрактные классы реализуются с использованием модуля abc (Abstract Base Classes). Вот как работает создание абстрактных классов:

• Импорт модуля abc: Для создания абстрактных классов в Python, вы должны импортировать модуль abc. Этот модуль предоставляет базовые классы и декораторы, необходимые для определения абстрактных классов.

from abc import ABC, abstractmethod

• Создание абстрактного класса: Чтобы создать абстрактный класс, определите новый класс, который наследуется от ABC, а также используйте декоратор @abstractmethod перед определением метода, который должен быть реализован в подклассах.

Пример:

from abc import ABC, abstractmethod

class AbstractClass(ABC):

   @abstractmethod
   def abstract_method(self):
       pass

• Определение подкласса: Теперь вы можете создать подкласс, который наследует от абстрактного класса. Этот подкласс должен обязательно реализовать абстрактные методы из абстрактного класса. Если это не будет сделано, Python выдаст ошибку.

Пример:

class Subclass(AbstractClass):

   def abstract_method(self):
       print("Реализация абстрактного метода в подклассе")

• Использование подкласса: Теперь можно создавать объекты подкласса и использовать их, включая вызов абстрактного метода, который был реализован в подклассе.

subclass_object = Subclass()
subclass_object.abstract_method()

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

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

В Python, инкапсуляция достигается с использованием следующих соглашений и механизмов:

1. Именование приватных атрибутов и методов: Для обозначения атрибутов и методов, которые предполагается, что будут доступны только внутри класса, используются имена, начинающиеся с одного или двух подчеркиваний (например, _приватный_атрибут или __приватный_метод). Однако, это больше соглашение, чем строгая защита, и данные атрибуты и методы могут быть доступны извне, если вы по-прежнему попытаетесь к ним обратиться.
2. Использование свойств (properties): В Python можно использовать свойства для обеспечения контролируемого доступа к атрибутам класса. Это позволяет выполнить дополнительную логику при доступе к атрибуту и защитить его от некорректных изменений.

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

class MyClass:

   def __init__(self):
       self.__private_attribute = 0

   @property
   def private_attribute(self):
       return self.__private_attribute

   @private_attribute.setter
   def private_attribute(self, value):
       if value >= 0:
           self.__private_attribute = value
       else:
           print("Значение должно быть неотрицательным")

my_object = MyClass()
my_object.private_attribute = 10  # Значение устанавливается
my_object.private_attribute = -5  # Значение не устанавливается

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

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

Пример:

class MyClass:
   attribute = 42

   def method(self):
       return "Открытый метод"

Атрибуты и методы, которые начинаются с одного подчеркивания (например, _protected_attribute), считаются "защищенными". Это соглашение о назначении, которое говорит, что эти атрибуты и методы предназначены для использования внутри класса и не должны быть непосредственно доступны извне. Однако, они все равно могут быть доступны.

Пример:

class MyClass:
  _protected_attribute = 42

   def _protected_method(self):
       return "Защищенный метод"

Атрибуты и методы, начинающиеся с двойного подчеркивания (например, __private_attribute), считаются "приватными". Это означает, что они должны быть доступны только внутри класса и не могут быть обращены извне класса. Однако, в Python они не совсем приватны и доступ к ним все равно можно получить.

Пример:

class MyClass:
   __private_attributeт = 42
   
   def __private_method(self):
       return "Приватный метод"

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

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

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

def polymorphic_function(argument):
   if isinstance(argument, int):
       return argument * 2
   elif isinstance(argument, str):
       return "Строка: " + argument

result_first = polymorphic_function(5)
result_second = polymorphic_function("Пример")

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

class Shape:
    def square(self):
        pass # Абстрактный метод

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def square(self):
        return 3.14 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def square(self):
        return self.length * self.width

circle = Circle(5)
rectangle = Rectangle(4, 6)

def calculate_area(figure):
    return figure.square()

print(calculate_area(circle))  # Полиморфное использование функции calculate_area
print(calculate_area(rectangle))  # Полиморфное использование функции calculate_area

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

class ParentClass:
   def polymorphic_method(self):
       return "Метод из родительского класса"

class Subclass(ParentClass):
   def polymorphic_method(self):
       return "Метод из подкласса"

object_first = ParentClass()
объект_second = Subclass()

result_first = object_first.polymorphic_method()
result_second = объект_second.polymorphic_method()

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

class Animal:
   def make_sound(self):
       pass

class Dog(Animal):
   def make_sound(self):
       return "Гав-гав!"
       
class Cat(Animal):
   def make_sound(self):
       return "Мяу-мяу!"

pet_first = Dog()
pet_second = Cat()

animals = [pet_first, pet_second]

for animal in animals:
   print(animal.make_sound())  # Полиморфное использование метода издать_звук

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

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

from abc import ABC, abstractmethod

class Figure(ABC):
   @abstractmethod
   def square(self):
       pass

class Circle(Figure):
   def __init__(self, radius):
       self.radius = radius       
   def square(self):
       return 3.14 * self.radius * self.radius

class Rectangle(Figure):
   def __init__(self, длина, ширина):
       self.length = length
       self.width = width       
   def square(self):
       return self.length * self.width

figure_first = Circle(5)
figure_second = Rectangle(4, 6)
print(figure_first.square())  # Полиморфное использование метода площадь
print(figure_second.square())  # Полиморфное использование метода площадь

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

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

• Определение классов: Сначала определите классы для объектов, которые вы хотите объединить в композицию. Эти классы могут иметь свои атрибуты и методы.
  Пример определения двух классов, которые будут объединены в композицию:

class Engine:
   def __init__(self, power):
       self.power = power
   def run(self):
       print("Двигатель работает")

class Vehicle:
   def __init__(self, model):
       self.model = model
       self.engine = Engine(150)
   def start(self):
       print(f"{self.model} заведен")
   def drive(self):
       print(f"{self.model} движется")

• Создание объектов внутри другого объекта: Внутри класса, который будет служить "контейнером" (в данном случае, класс Автомобиль), создайте объекты другого класса (в данном случае, класс Двигатель) и присвойте их атрибутам объекта-контейнера.

class Vehicle:
    def __init__(self, model):
        self.model = model
        self.engine = Engine(150)

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

• Использование объектов внутри композиции: Теперь вы можете использовать объекты внутри композиции, вызывая их методы и получая доступ к их атрибутам.

auto = Car("Sedan")
auto.start() # Завести автомобиль
auto.engine.start() # Запустить двигатель
auto.drive() # Двигаться

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

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

1. Лучшая модульность и изоляция: При использовании композиции классы остаются более изолированными и модульными. Они не зависят напрямую от реализации других классов и могут быть разрабатываны и тестированы независимо. Это способствует лучшей структурированности кода и уменьшает сложность.
2. Гибкость и легкая замена компонентов: В композиции классы могут быть легко заменены другими классами, реализующими тот же интерфейс. Это делает код более гибким и позволяет изменять поведение классов, не затрагивая другие части системы.
3. Избегание проблем дублирования кода: При использовании композиции нет риска наследования одного и того же кода от нескольких родительских классов. Это устраняет дублирование кода и упрощает его поддержку.
4. Меньшая связанность: Композиция позволяет избежать жесткой связанности между классами, что делает код более независимым и менее подверженным изменениям в других классах.
5. Безопасное расширение функциональности: При использовании композиции, добавление новой функциональности осуществляется путем создания новых компонентов или замены существующих, что обычно более безопасно и не нарушает существующее поведение.
6. Подходит для сложных иерархий: Композиция может быть предпочтительной, когда у вас есть сложная иерархия классов, и наследование может усложнить структуру кода.

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

Магические методы, также известные как "специальные методы" или "дандер-методы" (от double underscore, то есть "dunder" методы), представляют собой специальные методы в языке Python, которые имеют двойное подчеркивание с обеих сторон имени метода. Эти методы предназначены для определения и переопределения базовых операций и функциональности встроенных типов данных и пользовательских классов. Они позволяют классам взаимодействовать с операторами и стандартными функциями Python, такими как +, -, ==, str(), len(), и другими.

Магические методы начинаются с __ и завершаются __, и они позволяют вам определить, как объекты вашего класса должны вести себя в разных контекстах. Например, если вы хотите, чтобы ваш пользовательский класс поддерживал операцию сложения (+), вы можете определить метод __add__ для этого класса.

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

1.  __new__(cls, ...): Этот метод вызывается при создании нового экземпляра класса до метода __init__. Он может быть использован, чтобы настроить создание объекта или даже предотвратить его создание, вернув существующий объект.
2. __init__(self, ...): Магический метод __init__ используется для инициализации нового экземпляра класса после его создания. Этот метод вызывается автоматически при создании объекта.
3. __call__(self, ...): Этот метод позволяет вызывать экземпляр класса, как если бы он был функцией. Вы можете определить логику, которая будет выполняться при вызове объекта класса.
4. __enter__(self) и __exit__(self, exc_type, exc_value, traceback): Эти магические методы используются для создания контекстных менеджеров. __enter__ выполняется при входе в контекст, а __exit__ - при выходе из него. Они могут выполнять, например, настройку и очистку ресурсов.
5. __del__(self): Этот метод вызывается при уничтожении объекта, но он используется редко, так как работает неопределенно и не гарантирует, что объект будет уничтожен сразу.
6. __str__(self): Метод __str__ возвращает строковое представление объекта и вызывается, когда объект преобразуется в строку с помощью функции str() или оператора str().
7. __repr__(self): Метод __repr__ возвращает строковое представление объекта для внутреннего использования и вызывается, когда объект преобразуется в строку с помощью функции repr() или в интерактивной среде.
8. __len__(self): Магический метод __len__ позволяет определить, какой размер имеет объект. Этот метод вызывается при использовании функции len() для объекта.
9. __getitem__(self, key): Метод __getitem__ позволяет получать элементы объекта как по индексу (при использовании оператора []).

Простой класс, в котором опишем магические методы, для наглядности, используем только __new__, __init__, __call__, __enter__, __exit__, __str__, __repr__, и __len__. Вот пример:

class MyClass:
    def __new__(cls, *args, **kwargs):
        print("Вызван магический метод __new__")
        instance = super(MyClass, cls).__new__(cls)
        return instance

    def __init__(self, x):
        print("Вызван магический метод __init__")
        self.data = x

    def __call__(self, y):
        print(f"Вызван магический метод __call__, аргумент: {y}")
        return self.data + y

    def __enter__(self):
        print("Вход в контекст")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Выход из контекста")

    def __str__(self):
        return f"MyClass с данными: {self.data}"

    def __repr__(self):
        return f"MyClass({self.data})"

    def __len__(self):
        return len(self.data)


# Создаем объект класса
obj = MyClass('test')

# Вызываем объект как функцию
result = obj('obj test')
print(f"Результат вызова объекта: {result}")

# Используем контекстный менеджер
with obj as context:
    print("Внутри контекста")

print("Вне контекста")

# Преобразуем в строку с помощью str() и repr()
print(str(obj))
print(repr(obj))

# Проверяем длину объекта
print(len(obj))

Вызван магический метод __new__
Вызван магический метод __init__
Вызван магический метод __call__, аргумент: obj test
Результат вызова объекта: testobj test
Вход в контекст
Внутри контекста
Выход из контекста
Вне контекста
MyClass с данными: test
MyClass(test)
4

Эти магические методы позволяют вам определить поведение объектов вашего класса при выполнении различных операций и сравнениях:

1. __sub__(self, other): Магический метод для операции вычитания (-).
2. __add__(self, other): Метод __add__ определяет поведение объекта при операции сложения (+). Это позволяет объектам вашего класса быть сложными вместе.
3. __mul__(self, other): Магический метод для операции умножения (*).
4. __truediv__(self, other): Магический метод для операции деления (/).
5. __floordiv__(self, other): Магический метод для целочисленного деления (//).
6. __mod__(self, other): Магический метод для операции нахождения остатка от деления (%).
7. __pow__(self, other, modulo=None): Магический метод для возведения в степень (**).
8. __eq__(self, other): Магический метод для операции равенства (==).
9. __ne__(self, other): Магический метод для операции неравенства (!=).
10. __lt__(self, other): Магический метод для операции "меньше" (<).
11. __le__(self, other): Магический метод для операции "меньше или равно" (<=).
12. __gt__(self, other): Магический метод для операции "больше" (>).
13. __ge__(self, other): Магический метод для операции "больше или равно" (>=).
14. __contains__(self, item): Магический метод, позволяющий определить, содержится ли элемент в объекте. Этот метод используется, когда вы используете оператор in.

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

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

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

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

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