🤔 Что такое поведенческие паттерны?

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

🚩Зачем нужны поведенческие паттерны?

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

🚩 Примеры поведенческих паттернов

Стратегия (Strategy)
Позволяет выбирать алгоритм на основе контекста, без изменения класса, который его использует.

from abc import ABC, abstractmethod

class Strategy(ABC):
    @abstractmethod
    def execute(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def execute(self, data):
        return sorted(data)

class ConcreteStrategyB(Strategy):
    def execute(self, data):
        return sorted(data, reverse=True)

class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy

    def execute_strategy(self, data):
        return self._strategy.execute(data)

data = [5, 2, 9, 1]
context = Context(ConcreteStrategyA())
print(context.execute_strategy(data))  # [1, 2, 5, 9]

context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy(data))  # [9, 5, 2, 1]

Наблюдатель (Observer)
Определяет зависимость "один ко многим" между объектами таким образом, что при изменении состояния одного объекта все зависимые объекты оповещаются и обновляются автоматически.

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

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

    def remove_observer(self, observer):
        self._observers.remove(observer)

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

class Observer:
    def update(self, message):
        pass

class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Observer received: {message}")

subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()

subject.add_observer(observer1)
subject.add_observer(observer2)

subject.notify_observers("Hello Observers!")  # Observer received: Hello Observers!

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое Цепочка ответственности (Chain of responsobility)?

Цепочка ответственности (Chain of Responsibility) — это поведенческий паттерн проектирования, который позволяет передавать запрос по цепочке потенциальных обработчиков, пока один из них не обработает запрос. Этот паттерн избавляет отправителя запроса от необходимости знать, какой объект в цепочке обработает его запрос.

🚩Зачем нужен паттерн Цепочка ответственности?

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

🚩Пример использования

Рассмотрим пример, где запросы обрабатываются различными уровнями поддержки (например, базовая, средняя и расширенная поддержка).

from abc import ABC, abstractmethod

class Handler(ABC):
    def __init__(self, successor=None):
        self._successor = successor

    @abstractmethod
    def handle(self, request):
        if self._successor:
            return self._successor.handle(request)
        return None

class BasicSupportHandler(Handler):
    def handle(self, request):
        if request == 'basic':
            return "Basic support handled the request"
        return super().handle(request)

class IntermediateSupportHandler(Handler):
    def handle(self, request):
        if request == 'intermediate':
            return "Intermediate support handled the request"
        return super().handle(request)

class AdvancedSupportHandler(Handler):
    def handle(self, request):
        if request == 'advanced':
            return "Advanced support handled the request"
        return super().handle(request)

# Создаем цепочку обработчиков
handler_chain = BasicSupportHandler(
    IntermediateSupportHandler(
        AdvancedSupportHandler()
    )
)

# Тестируем цепочку
print(handler_chain.handle('basic'))        # Basic support handled the request
print(handler_chain.handle('intermediate')) # Intermediate support handled the request
print(handler_chain.handle('advanced'))     # Advanced support handled the request
print(handler_chain.handle('unknown'))      # None (запрос не обработан)

🚩Как это работает

🟠Создание абстрактного класса `Handler`:
Все конкретные обработчики наследуются от него и реализуют метод handle.
🟠Реализация конкретных обработчиков:
Каждый обработчик проверяет, может ли он обработать запрос. Если может, он обрабатывает его и возвращает результат. Если не может, он передает запрос следующему обработчику в цепочке.
🟠Создание цепочки обработчиков:
Обработчики связываются друг с другом, образуя цепочку.
🟠Передача запроса: Запрос передается по цепочке, пока один из обработчиков не обработает его или пока не будет достигнут конец цепочки.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое паттерн Команда (Command)?

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

🚩Зачем нужен паттерн Команда?

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

🚩Пример использования

Рассмотрим пример реализации паттерна Команда для управления светом (включение и выключение).

from abc import ABC, abstractmethod

# Интерфейс команды
class Command(ABC):
    @abstractmethod
    def execute(self):
        pass
    
    @abstractmethod
    def undo(self):
        pass

# Получатель команды
class Light:
    def on(self):
        print("Light is ON")
    
    def off(self):
        print("Light is OFF")

# Конкретная команда для включения света
class LightOnCommand(Command):
    def __init__(self, light: Light):
        self._light = light
    
    def execute(self):
        self._light.on()
    
    def undo(self):
        self._light.off()

# Конкретная команда для выключения света
class LightOffCommand(Command):
    def __init__(self, light: Light):
        self._light = light
    
    def execute(self):
        self._light.off()
    
    def undo(self):
        self._light.on()

# Инициатор команды
class RemoteControl:
    def __init__(self):
        self._command = None
    
    def set_command(self, command: Command):
        self._command = command
    
    def press_button(self):
        if self._command:
            self._command.execute()
    
    def press_undo(self):
        if self._command:
            self._command.undo()

# Использование паттерна Команда
light = Light()
light_on_command = LightOnCommand(light)
light_off_command = LightOffCommand(light)

remote = RemoteControl()

# Включаем свет
remote.set_command(light_on_command)
remote.press_button()  # Light is ON
remote.press_undo()    # Light is OFF

# Выключаем свет
remote.set_command(light_off_command)
remote.press_button()  # Light is OFF
remote.press_undo()    # Light is ON

🚩Как это работает

🟠Интерфейс `Command`:
Объявляет методы execute и undo, которые должны реализовать конкретные команды.
🟠Конкретные команды:
Реализуют интерфейс Command и определяют, как выполнять и отменять действия.
🟠Получатель (`Light`):
Объект, который выполняет действия (в данном случае, включение и выключение света).
🟠Инициатор (`RemoteControl`):
Объект, который вызывает команды. Он не знает, что именно делает команда, а просто вызывает её методы execute и undo.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое паттерн Интерпретатор (Interpreter)?

Паттерн Интерпретатор (Interpreter) — это поведенческий паттерн проектирования, который определяет грамматику для представления языка и интерпретатор, использующий эту грамматику для интерпретации предложений на этом языке. Паттерн используется для построения простых языков или для интерпретации конкретного типа выражений.

🚩Зачем нужен?

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

🚩Пример

from abc import ABC, abstractmethod

# Интерфейс выражения
class Expression(ABC):
    @abstractmethod
    def interpret(self):
        pass

# Конкретное выражение для чисел
class Number(Expression):
    def __init__(self, value):
        self.value = value
    
    def interpret(self):
        return self.value

# Конкретное выражение для сложения
class Add(Expression):
    def __init__(self, left: Expression, right: Expression):
        self.left = left
        self.right = right
    
    def interpret(self):
        return self.left.interpret() + self.right.interpret()

# Конкретное выражение для умножения
class Multiply(Expression):
    def __init__(self, left: Expression, right: Expression):
        self.left = left
        self.right = right
    
    def interpret(self):
        return self.left.interpret() * self.right.interpret()

# Клиентский код для использования паттерна Интерпретатор
def main():
    # Создаем выражение: (5 + 10) * 2
    expression = Multiply(
        Add(Number(5), Number(10)),
        Number(2)
    )
    
    result = expression.interpret()
    print(f"Result: {result}")  # Result: 30

if __name__ == "__main__":
    main()

1⃣Интерфейс `Expression`:
Объявляет метод interpret, который должен реализовать каждое конкретное выражение.
2⃣Конкретные выражения:
Классы Number, Add и Multiply, которые реализуют интерфейс Expression и определяют интерпретацию чисел, сложения и умножения соответственно.
3⃣Компоновка выражений:
Выражения могут быть составными, например, Add и Multiply могут принимать другие выражения в качестве аргументов.
4⃣Интерпретация:
Метод interpret вызывается для вычисления значения выражения.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое паттерн Мост (Bridge)?

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

🚩 Зачем нужен

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

🚩Как используется

🟠Абстракция (Abstraction):
Определяет интерфейс и хранит ссылку на объект Implementor.
🟠Расширенная абстракция (RefinedAbstraction):
Наследует Abstraction и расширяет интерфейс.
🟠Реализатор (Implementor):
Определяет интерфейс для всех реализаций.
🟠Конкретный реализатор (ConcreteImplementor):
Реализует интерфейс Implementor.

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

# Implementor
class Device:
    def is_enabled(self):
        pass

    def enable(self):
        pass

    def disable(self):
        pass

# ConcreteImplementor
class TV(Device):
    def __init__(self):
        self._on = False

    def is_enabled(self):
        return self._on

    def enable(self):
        self._on = True

    def disable(self):
        self._on = False

class Radio(Device):
    def __init__(self):
        self._on = False

    def is_enabled(self):
        return self._on

    def enable(self):
        self._on = True

    def disable(self):
        self._on = False

# Abstraction
class RemoteControl:
    def __init__(self, device):
        self._device = device

    def toggle_power(self):
        if self._device.is_enabled():
            self._device.disable()
        else:
            self._device.enable()

# RefinedAbstraction
class AdvancedRemoteControl(RemoteControl):
    def mute(self):
        print("Device is muted.")

# Клиентский код
tv = TV()
remote = RemoteControl(tv)
remote.toggle_power()  # Включает TV

radio = Radio()
advanced_remote = AdvancedRemoteControl(radio)
advanced_remote.toggle_power()  # Включает Radio
advanced_remote.mute()  # Заглушает Radio

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое паттерн Компоновщик (Composite)?

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

🚩Зачем нужен?

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

🚩Как используется паттерн Компоновщик?

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

from abc import ABC, abstractmethod

# Абстрактный компонент
class Graphic(ABC):
    @abstractmethod
    def draw(self):
        pass

# Лист
class Circle(Graphic):
    def draw(self):
        print("Drawing a Circle")

# Компоновщик
class CompositeGraphic(Graphic):
    def __init__(self):
        self.graphics = []

    def add(self, graphic):
        self.graphics.append(graphic)

    def remove(self, graphic):
        self.graphics.remove(graphic)

    def draw(self):
        for graphic in self.graphics:
            graphic.draw()

# Клиентский код
circle1 = Circle()
circle2 = Circle()
composite = CompositeGraphic()
composite.add(circle1)
composite.add(circle2)

# Рисуем все элементы
composite.draw()

🚩Плюсы

➕Упрощение работы с иерархиями:
Легко обрабатывать как простые, так и составные объекты.
➕Расширяемость:
Можно легко добавлять новые типы компонентов.
➖Сложность:
Могут возникнуть сложности при управлении более сложными структурами.

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница между итератором и генератором?

Итератор — это объект, который поддерживает метод `__iter__()` и `__next__()` и позволяет проходить по коллекции элементов. Генератор — это специальный вид итератора, который создается с помощью ключевого слова `yield` и позволяет лениво возвращать элементы по одному, сохраняя состояние между вызовами. Генераторы обычно используются для обработки больших данных, поскольку они не требуют загрузки всего набора данных в память. Итераторы, в свою очередь, могут быть созданы вручную с помощью классов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое паттерн Фасад (Facade)?

Паттерн Фасад (Facade) — это структурный паттерн проектирования, который предоставляет упрощённый интерфейс к сложной системе классов, библиотеке или фреймворку. Основная цель паттерна — уменьшить сложность взаимодействия с системой, скрывая её внутренние детали и предоставляя более простой интерфейс для клиента.

🚩Зачем нужен?

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

🚩Как используется?

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

# Подсистема 1
class CPU:
    def freeze(self):
        print("CPU freezing")

    def jump(self, position):
        print(f"CPU jumping to {position}")

    def execute(self):
        print("CPU executing")

# Подсистема 2
class Memory:
    def load(self, position, data):
        print(f"Memory loading {data} at {position}")

# Подсистема 3
class HardDrive:
    def read(self, lba, size):
        return f"Reading {size} bytes from LBA {lba}"

# Фасад
class ComputerFacade:
    def __init__(self):
        self.cpu = CPU()
        self.memory = Memory()
        self.hard_drive = HardDrive()

    def start(self):
        self.cpu.freeze()
        self.memory.load("0x00", self.hard_drive.read("100", "1024"))
        self.cpu.jump("0x00")
        self.cpu.execute()

# Клиентский код
computer = ComputerFacade()
computer.start()

🚩Плюсы

➕Упрощение интерфейса: Снижает количество методов, с которыми нужно взаимодействовать клиенту.
➕Изоляция клиентов от подсистем: Клиенты не зависят от деталей реализации подсистем, что упрощает их модификацию и замену.
➕Снижение связности: Уменьшает зависимость между клиентами и сложными подсистемами.

🚩Минусы

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое SOLID?

SOLID — это пять принципов объектно-ориентированного программирования, которые помогают проектировать гибкие, расширяемые и поддерживаемые системы. Они включают в себя: Single Responsibility (одна ответственность), Open/Closed (открытость для расширения, закрытость для изменений), Liskov Substitution (замена по Лисков), Interface Segregation (разделение интерфейсов) и Dependency Inversion (инверсия зависимостей). Эти принципы улучшают архитектуру программного обеспечения и делают код более надежным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое хранитель (Memento)?

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

🚩Зачем нужен?

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

class Memento:
    def __init__(self, state: str):
        self._state = state

    def get_state(self) -> str:
        return self._state

class TextEditor:
    def __init__(self):
        self._state = ""
        self._history = []

    def type(self, text: str):
        self._save_state()
        self._state += text

    def _save_state(self):
        self._history.append(Memento(self._state))

    def undo(self):
        if not self._history:
            return
        memento = self._history.pop()
        self._state = memento.get_state()

    def get_content(self) -> str:
        return self._state

# Клиентский код для использования паттерна Хранитель
def main():
    editor = TextEditor()

    editor.type("Hello, ")
    editor.type("world!")
    print(editor.get_content())  # Hello, world!

    editor.undo()
    print(editor.get_content())  # Hello, 

    editor.undo()
    print(editor.get_content())  # 

if __name__ == "__main__":
    main()

1⃣`Memento`:
Сохраняет состояние объекта. Он предоставляет методы для получения сохраненного состояния, но не предоставляет методов для изменения состояния, что обеспечивает неизменность.

2⃣`TextEditor`:
Создает и использует объекты Memento для сохранения и восстановления своего состояния. Методы type и undo позволяют редактировать текст и отменять изменения.

3⃣`_save_state`:
Сохраняет текущее состояние редактора в истории перед каждым изменением.

4⃣`undo`:
Восстанавливает предыдущее состояние редактора из истории.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое декораторы?

Декораторы в Python — это функции, которые принимают другую функцию или метод в качестве аргумента и изменяют или расширяют её поведение. Они позволяют легко добавлять функциональность без изменения исходного кода функции. Декораторы применяются с помощью символа `@` перед определением функции. Это мощный механизм для рефакторинга, добавления логгирования, проверки прав доступа и других задач.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое Наблюдатель (Observer)?

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

🚩Зачем нужен?

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

from abc import ABC, abstractmethod

class Observer(ABC):
    @abstractmethod
    def update(self, message: str):
        pass

class ConcreteObserver(Observer):
    def __init__(self, name: str):
        self._name = name
    
    def update(self, message: str):
        print(f"{self._name} received message: {message}")

class Subject:
    def __init__(self):
        self._observers = []
    
    def add_observer(self, observer: Observer):
        self._observers.append(observer)
    
    def remove_observer(self, observer: Observer):
        self._observers.remove(observer)
    
    def notify_observers(self, message: str):
        for observer in self._observers:
            observer.update(message)

# Клиентский код для использования паттерна Наблюдатель
def main():
    subject = Subject()
    
    observer1 = ConcreteObserver("Observer 1")
    observer2 = ConcreteObserver("Observer 2")
    
    subject.add_observer(observer1)
    subject.add_observer(observer2)
    
    subject.notify_observers("Event 1")  # Observer 1 received message: Event 1
                                        # Observer 2 received message: Event 1
    
    subject.remove_observer(observer1)
    
    subject.notify_observers("Event 2")  # Observer 2 received message: Event 2

if __name__ == "__main__":
    main()

1⃣`Observer`:
Объявляет метод update, который должны реализовать все конкретные наблюдатели.
2⃣`ConcreteObserver`:
Реализует интерфейс Observer и определяет, как наблюдатель должен реагировать на обновления.
3⃣`Subject`:
Содержит список наблюдателей и методы для добавления, удаления и уведомления наблюдателей.
4⃣`notify_observers`:
Вызывается при изменении состояния субъекта и уведомляет всех зарегистрированных наблюдателей.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое генератор?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое паттерн Состояние (State)?

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

🚩Зачем нужен

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

from abc import ABC, abstractmethod

# Интерфейс состояния
class State(ABC):
    @abstractmethod
    def insert_coin(self):
        pass
    
    @abstractmethod
    def eject_coin(self):
        pass
    
    @abstractmethod
    def dispense(self):
        pass

# Конкретные состояния
class NoCoinState(State):
    def __init__(self, machine):
        self.machine = machine

    def insert_coin(self):
        print("Coin inserted.")
        self.machine.set_state(self.machine.has_coin_state)
    
    def eject_coin(self):
        print("No coin to eject.")
    
    def dispense(self):
        print("Insert coin first.")

class HasCoinState(State):
    def __init__(self, machine):
        self.machine = machine
    
    def insert_coin(self):
        print("Coin already inserted.")
    
    def eject_coin(self):
        print("Coin ejected.")
        self.machine.set_state(self.machine.no_coin_state)
    
    def dispense(self):
        print("Dispensing product.")
        self.machine.set_state(self.machine.no_coin_state)

# Контекст
class VendingMachine:
    def __init__(self):
        self.no_coin_state = NoCoinState(self)
        self.has_coin_state = HasCoinState(self)
        self.state = self.no_coin_state
    
    def set_state(self, state: State):
        self.state = state
    
    def insert_coin(self):
        self.state.insert_coin()
    
    def eject_coin(self):
        self.state.eject_coin()
    
    def dispense(self):
        self.state.dispense()

# Клиентский код
def main():
    machine = VendingMachine()
    
    machine.insert_coin()  # Coin inserted.
    machine.dispense()     # Dispensing product.
    machine.eject_coin()   # No coin to eject.
    
    machine.insert_coin()  # Coin inserted.
    machine.eject_coin()   # Coin ejected.
    machine.dispense()     # Insert coin first.

if __name__ == "__main__":
    main()

🚩Как это работает

🟠Интерфейс `State`
Определяет методы, которые должны реализовать все конкретные состояния.
🟠Конкретные состояния (`NoCoinState`, `HasCoinState`)
Реализуют интерфейс State и определяют поведение для каждого состояния.
🟠Класс `VendingMachine`
Содержит ссылки на все возможные состояния и метод для изменения текущего состояния. Делегирует вызовы методов текущему состоянию.
🟠Методы `insert_coin`, `eject_coin`, `dispense`
Вызываются клиентом и делегируются текущему состоянию.

Ставь 👍 и забирай 📚 Базу знаний