Какие паттерны программирования вам известны?

Известны порождающие, структурные и поведенческие паттерны.

Порождающие паттерны:

• Фабричный метод (Factory Method): Предоставляет интерфейс для создания объектов в суперклассе, позволяя подклассам изменять тип создаваемых объектов.

  # Пример Фабричного метода
  class Creator:
      def factory_method(self):
          raise NotImplementedError()
  
      def some_operation(self):
          product = self.factory_method()
          return f"Creator: The same creator's code has just worked with {product.operation()}"
  
  class ConcreteCreator1(Creator):
      def factory_method(self):
          return ConcreteProduct1()
  
  class ConcreteProduct1:
      def operation(self):
          return "{Result of the ConcreteProduct1}"
  

• Абстрактная фабрика (Abstract Factory): Предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов, не специфицируя их конкретных классов.
• Одиночка (Singleton): Гарантирует, что у класса есть только один экземпляр, и предоставляет глобальную точку доступа к нему.

  # Пример Одиночки
  class SingletonMeta(type):
      _instances = {}
  
      def __call__(cls, *args, **kwargs):
          if cls not in cls._instances:
              instance = super().__call__(*args, **kwargs)
              cls._instances[cls] = instance
          return cls._instances[cls]
  
  class Singleton(metaclass=SingletonMeta):
      pass
  

• Строитель (Builder): Позволяет пошагово создавать сложные объекты, отделяя процесс конструирования от представления.
• Прототип (Prototype): Позволяет создавать копии существующих объектов, не вдаваясь в подробности их реализации.

Структурные паттерны:

• Адаптер (Adapter): Позволяет объектам с несовместимыми интерфейсами работать вместе.

  # Пример Адаптера
  class Target:
      def request(self):
          return "Target: The default target's behavior."
  
  class Adaptee:
      def specific_request(self):
          return ".eetpadA eht fo roivaheb laicepS"
  
  class Adapter(Target, Adaptee):
      def request(self):
          return f"Adapter: (TRANSLATED) {self.specific_request()[::-1]}"
  

• Мост (Bridge): Разделяет абстракцию и реализацию так, чтобы они могли изменяться независимо друг от друга.
• Компоновщик (Composite): Позволяет компоновать объекты в древовидные структуры для представления иерархий от частного к целому.
• Декоратор (Decorator): Динамически добавляет объектам новые обязанности.
• Фасад (Facade): Предоставляет унифицированный интерфейс к группе подсистем.
• Приспособленец (Flyweight): Позволяет использовать множество мелких объектов, эффективно их разделяя.
• Заместитель (Proxy): Предоставляет суррогат или заполнитель для другого объекта, чтобы контролировать доступ к нему.

Поведенческие паттерны:

• Цепочка обязанностей (Chain of Responsibility): Позволяет передавать запросы последовательно по цепочке обработчиков.
• Команда (Command): Превращает запрос в объект, позволяя параметризовать клиенты с различными запросами, ставить запросы в очередь или логировать их, а также поддерживать отмену операций.

  # Пример Команды
  class Command:
      def execute(self):
          pass
  
  class SimpleCommand(Command):
      def __init__(self, payload):
          self._payload = payload
  
      def execute(self):
          print(f"SimpleCommand: See, I can do simple things like printing ({self._payload})")
  
  class Invoker:
      _on_start = None
      _on_finish = None
  
      def set_on_start(self, command):
          self._on_start = command
  
      def set_on_finish(self, command):
          self._on_finish = command
  
      def do_something_important(self):
          if isinstance(self._on_start, Command):
              self._on_start.execute()
  
          print("Invoker: Doing something really important.")
  
          if isinstance(self._on_finish, Command):
              self._on_finish.execute()
  

• Итератор (Iterator): Предоставляет способ последовательного доступа ко всем элементам составного объекта, не раскрывая его внутреннего представления.
• Посредник (Mediator): Определяет объект, который инкапсулирует способ взаимодействия набора объектов.
• Хранитель (Memento): Позволяет сохранять и восстанавливать внутреннее состояние объекта без нарушения инкапсуляции.
• Наблюдатель (Observer): Определяет зависимость один ко многим между объектами, так что при изменении состояния одного объекта все зависящие от него оповещаются и автоматически обновляются.
• Состояние (State): Позволяет объекту изменять свое поведение в зависимости от внутреннего состояния.
• Стратегия (Strategy): Определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми.

  # Пример Стратегии
  class Strategy:
      def do_algorithm(self, data):
          pass
  
  class ConcreteStrategyA(Strategy):
      def do_algorithm(self, data):
          return sorted(data)
  
  class Context:
      def __init__(self, strategy):
          self._strategy = strategy
  
      def set_strategy(self, strategy):
          self._strategy = strategy
  
      def do_some_business_logic(self):
          data = ["a", "b", "c", "d", "e"]
          result = self._strategy.do_algorithm(data)
          print(",".join(result))
  

• Шаблонный метод (Template Method): Определяет скелет алгоритма в суперклассе, оставляя подклассам возможность переопределять некоторые шаги алгоритма без изменения его структуры.
• Посетитель (Visitor): Позволяет добавлять новые операции к набору объектов без изменения кода этих объектов.

Также известны более специфичные паттерны, такие как Model-View-Controller (MVC), Model-View-Presenter (MVP), Model-View-ViewModel (MVVM) и другие архитектурные паттерны.