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

Первый столп — Инкапсуляция. Суть проще пареной репы, но её все игнорят, а потом охуевают. Это когда ты свои внутренние дела, блядь, не выставляешь на всеобщее обозрение. Не даёшь каждому распиздую прям в лоб переменную balance менять. А то прибежит какой-нибудь долбоёб и напишет account.balance = -1000000, и всё, пиздец, ты теперь должен банку. Поэтому ты делаешь сейф с кодовым замком — методы.

class BankAccount:
    def __init__(self, owner, balance=0):
        self._owner = owner          # Ну, типа, так принято, но не шибко приватно
        self.__balance = balance     # А вот это уже серьёзно, питон его спрячет (name mangling)

    def deposit(self, amount):
        if amount > 0:               # Проверочку, блядь, на дурака!
            self.__balance += amount

    def get_balance(self):           # И вот только через эту дверь можно посмотреть
            return self.__balance

Видишь? Не лезь, куда не просят. Всё через публичные методы. Хочешь положить деньги — ок, через deposit. Хочешь посмотреть — через get_balance. А напрямую в __balance не суйся, а то питон тебе имя такое подменит, что не найдёшь, хитрая жопа.

Второй — Наследование. Ну это вообще, ебушки-воробушки, чтобы не изобретать велосипед каждый раз. Есть у тебя общая сущность, от неё плодятся специализированные.

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model
    def start_engine(self):
        return "Дрын-дрын-дрын, завелось"

class ElectricCar(Vehicle):  # Смотри, сука, в скобках родитель!
    def __init__(self, make, model, battery_capacity):
        super().__init__(make, model)  # Эй, папа, инициализируй своё!
        self.battery_capacity = battery_capacity
    # А тут мы папин метод переписываем под себя
    def start_engine(self):
        return "Вжжжжж... (тишина и запах озона)"

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

Третий — Полиморфизм. Звучит страшно, а на деле — «одно название, разное поведение». Это когда ты можешь работать с разными объектами через один и тот же интерфейс, и тебе похуй, что у них внутри.

def start_vehicle(vehicle):  # Мне всё равно, что ты передашь!
    print(vehicle.start_engine()) # Лишь бы у тебя метод .start_engine() был!

car = Vehicle("Жигули", "девяносто девятка")
tesla = ElectricCar("Тесла", "Модель Эс", 100)

start_vehicle(car)   # Напечатает: "Дрын-дрын-дрын, завелось"
start_vehicle(tesla) # Напечатает: "Вжжжжж... (тишина и запах озона)"

Вот это и есть полиморфизм, блядь! Функция start_vehicle вызывает один и тот же метод, но результат разный, потому что объекты разные. Гибко, ёпта!

Четвёртый — Абстракция. Самый, блядь, философский. Это когда ты отсекаешь всё лишнее и оставляешь только суть для своей задачи. Не «дерево с корнями, листьями и фотосинтезом», а просто «объект, у которого есть цена и его можно срубить». На практике это часто интерфейсы или абстрактные классы — они говорят «ЧТО делать», но не говорят «КАК».

from abc import ABC, abstractmethod

class DataRepository(ABC):  # Абстрактный класс — чистый контракт!
    @abstractmethod
    def save(self, data):  # Дитё, ты ДОЛЖЕН уметь сохранять!
        pass
    @abstractmethod
    def load(self, id):    # И загружать!
        pass

class DatabaseRepository(DataRepository):  # А вот конкретная реализация
    def save(self, data):
        # Тут уже реальный код для INSERT INTO...
        print("Пишу в базу данных, не мешай...")
    def load(self, id):
        return "Данные из БД"

Если твой класс наследует DataRepository, ты ОБЯЗАН реализовать save и load. Иначе питон тебе ещё на этапе создания объекта скажет: «Мудак, ты контракт не выполнил!». Это чтобы архитектура не разваливалась, как карточный домик.

Вот и вся магия, если вкратце. Соблюдаешь эти принципы — код живёт долго и счастливо. Игнорируешь — получаешь спагетти, которое через полгода сам же и проклянёшь. Вывод простой, как три копейки: думай, блядь, головой, когда пишешь.