Какие основные паттерны проектирования ООП применяются в Python

Да ты посмотри, какие эти ваши паттерны проектирования, блядь, выдумали! Сидят, блядь, умники, лбы в потолок упирают, и думают, как бы нам всем жизнь усложнить, но красиво, ёпта. А на деле-то всё просто, как этот Герасим, который только «Муму» сказать может.

Вот, например, Singleton (Одиночка). Суть в чём? Чтобы этот ваш класс, как последняя бутылка водки на троих, был один, блядь, на весь проект. Не дай бог второй экземпляр создашь — сразу пиздец, конфигурация пополам разорвётся или к базе данных два подключения полезет, а ей, сука, и одного-то дохуя.

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

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

Дальше, Factory Method (Фабричный метод). Это когда ты, сука, не знаешь, какую конкретно хуйню тебе создавать, но знаешь, что она должна из определённой семьи быть. Типа, «мам, купи собаку!». А какая — не важно, хоть чихуахуа, хоть овчарка, лишь бы лаяла. Вот фабрика и решает, какую именно псину тебе подсунуть.

from abc import ABC, abstractmethod

class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

class ConcreteCreator(Creator):
    def factory_method(self):
        return ConcreteProduct()

Абстрактный создатель говорит: «Слушай сюда, потомок, ты уж сам решай, что там производить будешь, но метод factory_method у тебя быть обязан, а то я тебя в сраку!». И ты такой: «Ладно, ладно, ща наклепаю ConcreteProduct».

А теперь Decorator (Декоратор) — это вообще песня, блядь! В Питоне его так в язык впилили, что красота, ёпта. Хочешь добавить функциональность функции, но не хочешь лезть в её кишки и всё там переписывать? Оберни её, как тот мудак Герасим Муму в мешок, только не для утопления, а для улучшения!

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Что-то происходит перед вызовом функции.")
        result = func(*args, **kwargs)
        print("Что-то происходит после вызова функции.")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Привет!")

Вот ты написал функцию say_hello, а потом думаешь: «А не залогировать ли мне её вызов, нахуй?». И вместо того чтобы в неё лезть, просто сверху @my_decorator накидываешь. И она теперь не просто «Привет!» кричит, а ещё и отчитывается, что, мол, щас буду говорить, сказал, всё. Красота, блядь, в рот меня чих-пых!

Ну и Observer (Наблюдатель). Это когда один объект — такая важная шишка, субъект — орет на всю деревню, что у него что-то случилось. А другие объекты — наблюдатели — как те бабки у подъезда, уши на макушке, всё слушают. Как только субъект крикнул — они все сразу в реакцию вступают.

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def notify(self, message):
        for observer in self._observers:
            observer.update(message)

Представь: субъект — это типа колокол на площади. Наблюдатели — это все, кто договорился: «Как колокол зазвонит — все бежим на площадь!». attach — это ты бабульку новую к скамейке подсаживаешь. notify — это ты в колокол дубасишь, и все бабки срываются с места. Каждой своё update вызывается.

Вот и вся магия, блядь. Не надо тут изобретать велосипед с квадратными колёсами. Бери паттерн, который под задачу подходит, и впердоливай. Главное — понимать, зачем он, а не просто потому, что в книжке умной прочитал. А то будет как с Муму — вроде всё правильно сделал по инструкции «как утопить собаку», а потом совесть ебёт до конца жизни.