📌 Как создать итератор из коллекции?

💬 Спрашивают в 3% собеседований

В Python можно создать итератор из коллекции, используя встроенную функцию iter(). Итераторы – это объекты, которые реализуют метод __iter__() и метод __next__(). Давайте рассмотрим, как это работает на примере.

🤔 Пример создания итератора

Рассмотрим список, который является одной из стандартных коллекций в Python:

my_list = [1, 2, 3, 4, 5]

Чтобы создать итератор из этого списка, используем функцию iter():

my_iterator = iter(my_list)

Теперь my_iterator – это итератор, который можно использовать для поочередного доступа к элементам списка.

🤔 Использование итератора

Мы можем использовать функцию next() для получения следующего элемента итератора:

print(next(my_iterator))  # Выводит: 1
print(next(my_iterator))  # Выводит: 2
print(next(my_iterator))  # Выводит: 3

Когда элементы коллекции заканчиваются, next() вызовет исключение StopIteration.

🤔 Итераторы и циклы

Обычно итераторы используются в сочетании с циклами for, что упрощает работу с ними:

for item in my_iterator:
    print(item)

Если попытаться использовать итератор повторно после его исчерпания, он больше не будет выдавать элементы:

my_iterator = iter(my_list)
for item in my_iterator:
    print(item)

# Повторное использование того же итератора:
for item in my_iterator:
    print(item)  # Ничего не выведет, так как итератор уже исчерпан

🤔 Создание собственного итератора

Можно создать собственный итератор, определив класс с методами __iter__() и __next__().

Пример:

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

my_iterable = MyIterator([10, 20, 30])
for item in my_iterable:
    print(item)

В этом примере мы создали собственный итератор, который перебирает элементы списка [10, 20, 30].

🤔 Краткий итог:
1️⃣ Итератор можно создать из коллекции с помощью функции iter().
2️⃣ Итераторы используют методы __iter__() и __next__() для поочередного доступа к элементам.
3️⃣ Итераторы обычно применяются в циклах for для удобства перебора элементов коллекции.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Как создать класс, который поддерживает протокол итератора?

💬 Спрашивают в 3% собеседований

Для того чтобы создать класс, который поддерживает протокол итератора в Python, нужно определить два метода: __iter__() и __next__(). Давайте рассмотрим пошагово, как это сделать.

1️⃣ Определение класса

Начнем с создания класса, который будет содержать коллекцию данных. В данном примере это будет список.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

2️⃣: Метод `__iter__()`

Метод __iter__() должен возвращать сам итератор. В данном случае наш класс сам будет являться итератором, поэтому метод __iter__() будет возвращать self.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

3️⃣ Метод `__next__()`

Метод __next__() должен возвращать следующий элемент последовательности. Если элементы закончились, метод должен вызывать исключение StopIteration.

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

🤔 Полный пример

class MyIterable:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# Создаем объект нашего класса
my_iterable = MyIterable([10, 20, 30, 40, 50])

# Используем его в цикле for
for item in my_iterable:
    print(item)

🤔 Объяснение

1️⃣Инициализация (`__init__`): Мы создаем объект класса и передаем ему список данных. self.data хранит данные, а self.index отслеживает текущую позицию в последовательности.
2️⃣ Итерация (`__iter__`): Метод __iter__() возвращает сам объект, так как наш класс будет сам итератором.
3️⃣ Следующий элемент (`__next__`): Метод __next__() возвращает следующий элемент в последовательности и увеличивает индекс. Если элементов больше нет, вызывается исключение StopIteration.

🤔 Краткий итог:
1️⃣Определите методы __iter__() и __next__() в вашем классе.
2️⃣ __iter__() должен возвращать объект итератора (обычно self).
3️⃣ __next__() должен возвращать следующий элемент или вызывать StopIteration, если элементов больше нет.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны static method?

💬 Спрашивают в 3% собеседований

Статические методы (static methods) в Python используются для создания методов, которые связаны с классом, но не требуют доступа к экземпляру этого класса или к самим данным класса. Это методы, которые выполняют функции, связанные с классом, но не изменяют и не используют состояние экземпляра (атрибуты объекта) или состояние самого класса (атрибуты класса). Они могут быть вызваны на уровне класса, а не на уровне экземпляра класса.

🤔 Как создать статический метод

Для создания статического метода в Python используется декоратор @staticmethod. Давайте рассмотрим пример:

class MyClass:
    @staticmethod
    def static_method(arg1, arg2):
        return arg1 + arg2

🤔 Пример использования статического метода

Вы можете вызывать статический метод как через сам класс, так и через его экземпляр:

result = MyClass.static_method(5, 10)
print(result)  # Вывод: 15

my_instance = MyClass()
result = my_instance.static_method(3, 7)
print(result)  # Вывод: 10

🤔 Зачем нужны статические методы

1️⃣ Логическая группировка: Статические методы позволяют логически группировать функции, которые связаны с классом, но не зависят от состояния конкретного экземпляра. Это помогает организовать код и делает его более читабельным.

2️⃣ Удобство вызова: Иногда полезно вызывать метод, не создавая экземпляр класса. Например, если метод выполняет какую-то утилитарную функцию или обрабатывает данные, не связанные с объектом.

3️⃣ Избежание изменений состояния: Поскольку статические методы не могут изменять состояние экземпляра или класса, их использование может способствовать созданию безопасного и предсказуемого кода.

🤔 Сравнение с методами класса и экземпляра

➕ Методы экземпляра: Методы экземпляра (instance methods) принимают первым аргументом self, что позволяет им изменять состояние конкретного экземпляра класса.

  class MyClass:
      def instance_method(self, value):
          self.value = value
  

➕ Методы класса: Методы класса (class methods) принимают первым аргументом cls, что позволяет им изменять состояние самого класса.

  class MyClass:
      class_variable = 0

      @classmethod
      def class_method(cls, value):
          cls.class_variable = value
  

➕ Статические методы: Статические методы не принимают self или cls в качестве первого аргумента и не могут изменять состояние экземпляра или класса.

  class MyClass:
      @staticmethod
      def static_method(arg1, arg2):
          return arg1 + arg2
  

🤔 Краткий итог:
1️⃣Статические методы используются для функций, которые не зависят от состояния экземпляра или класса.
2️⃣ Они создаются с помощью декоратора @staticmethod.
3️⃣ Такие методы удобны для логической группировки и вызова функций без создания экземпляра класса.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Для чего нужны class method?

💬 Спрашивают в 3% собеседований
Методы класса (class methods) в Python используются для методов, которые работают с самим классом, а не с его экземплярами. Они позволяют изменять состояние класса или выполнять операции, которые относятся ко всему классу в целом, а не к отдельным его экземплярам.

🤔 Как создать метод класса

Для создания метода класса в Python используется декоратор @classmethod. Такие методы принимают первым аргументом не self (как в методах экземпляра), а cls, что указывает на сам класс.

Пример:

class MyClass:
    class_variable = 0

    @classmethod
    def class_method(cls, value):
        cls.class_variable = value

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

Метод класса можно вызывать как на уровне класса, так и через экземпляры класса:

# Вызов метода класса через сам класс
MyClass.class_method(10)
print(MyClass.class_variable)  # Вывод: 10

# Вызов метода класса через экземпляр класса
instance = MyClass()
instance.class_method(20)
print(MyClass.class_variable)  # Вывод: 20

🤔 Зачем нужны методы класса

1️⃣ Работа с атрибутами класса: Методы класса позволяют изменять атрибуты класса, а не отдельного экземпляра. Это полезно, когда нужно поддерживать общее состояние для всех экземпляров класса.

2️⃣ Фабричные методы: Методы класса часто используются для создания экземпляров класса с определенными параметрами или для реализации альтернативных конструкторов.

3️⃣ Логическая группировка: Они позволяют логически группировать функции, связанные с классом, делая код более организованным и понятным.

🤔 Пример фабричного метода

Фабричный метод — это метод класса, который возвращает новый экземпляр класса. Рассмотрим пример, где метод класса используется для создания объекта с предустановленными значениями.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2024 - birth_year
        return cls(name, age)

# Создание экземпляра через основной конструктор
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Вывод: Alice 30

# Создание экземпляра через фабричный метод
person2 = Person.from_birth_year("Bob", 1990)
print(person2.name, person2.age)  # Вывод: Bob 34

🤔 Сравнение с методами экземпляра и статическими методами

➕ Методы экземпляра: Методы, которые работают с конкретным экземпляром класса и могут изменять его состояние (принимают self).

  class MyClass:
      def instance_method(self, value):
          self.value = value
  

➕ Статические методы: Методы, которые не зависят от состояния экземпляра или класса и не могут его изменять (используют декоратор @staticmethod).

  class MyClass:
      @staticmethod
      def static_method(arg1, arg2):
          return arg1 + arg2
  

➕ Методы класса: Методы, которые работают с самим классом и могут изменять его состояние (используют декоратор @classmethod).

  class MyClass:
      class_variable = 0

      @classmethod
      def class_method(cls, value):
          cls.class_variable = value
  

🤔 Краткий итог:
1️⃣ Методы класса используются для работы с атрибутами и состоянием самого класса.
2️⃣ Они создаются с помощью декоратора @classmethod и принимают cls в качестве первого аргумента.
3️⃣ Часто применяются для реализации фабричных методов и логической группировки функций, связанных с классом.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

🤔 Чем обычный метод отличается от class method?

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

🚩Обычные методы (Instance Methods)

Привязка к экземпляру:
🟠Обычные методы работают с конкретными экземплярами класса.
🟠Они принимают первым аргументом self, который указывает на текущий экземпляр класса.

Использование атрибутов: Могут изменять состояние экземпляра, то есть работать с его атрибутами.

Определение:

   class MyClass:
       def instance_method(self, value):
           self.value = value

Вызов:

   instance = MyClass()
   instance.instance_method(10)

Пример:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(f"{self.name} говорит: Гав-гав!")

dog = Dog("Бобик")
dog.bark()  # Вывод: Бобик говорит: Гав-гав!

🚩Методы класса (Class Methods)

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

Использование атрибутов: Могут изменять состояние класса, то есть работать с атрибутами класса.

Определение:

   class MyClass:
       class_variable = 0

       @classmethod
       def class_method(cls, value):
           cls.class_variable = value

Вызов: Могут вызываться как через сам класс, так и через его экземпляры.

   MyClass.class_method(10)
   instance = MyClass()
   instance.class_method(20)
   

Пример:

class Dog:
    total_dogs = 0

    def __init__(self, name):
        self.name = name
        Dog.total_dogs += 1

    @classmethod
    def get_total_dogs(cls):
        return cls.total_dogs

dog1 = Dog("Бобик")
dog2 = Dog("Шарик")
print(Dog.get_total_dogs())  # Вывод: 2

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

🤔 Что такое dependency injection?

Внедрение зависимостей (Dependency Injection, DI) — это дизайн-паттерн, используемый в объектно-ориентированном программировании для управления зависимостями между объектами. Внедрение зависимостей позволяет сделать код более гибким, тестируемым и поддерживаемым, отделяя создание объектов от их использования.

🚩Основные концепции

🟠Зависимости: Это объекты, от которых зависит класс. Например, если класс Car использует объект Engine, то Engine является зависимостью для Car.
🟠Внедрение: Процесс передачи зависимостей классу. Вместо того чтобы создавать зависимости внутри класса, они передаются извне.

🚩Преимущества внедрения зависимостей

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

🚩Типы внедрения зависимостей

🟠Внедрение через конструктор: Зависимости передаются через параметры конструктора.
🟠Внедрение через методы (или сеттеры): Зависимости передаются через специальные методы.
🟠Внедрение через свойства: Зависимости назначаются через свойства объекта.

Рассмотрим пример, где класс Car зависит от класса Engine.

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self, engine):
        self.engine = engine

    def start(self):
        self.engine.start()
        print("Car started")

# Создание объекта Engine
engine = Engine()

# Внедрение зависимости Engine в объект Car через конструктор
car = Car(engine)
car.start()

Внедрения через методы (сеттеры)

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = None

    def set_engine(self, engine):
        self.engine = engine

    def start(self):
        if self.engine is not None:
            self.engine.start()
            print("Car started")
        else:
            print("No engine to start")

# Создание объекта Engine
engine = Engine()

# Создание объекта Car
car = Car()

# Внедрение зависимости Engine в объект Car через метод
car.set_engine(engine)
car.start()

Внедрения через свойства

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self._engine = None

    @property
    def engine(self):
        return self._engine

    @engine.setter
    def engine(self, engine):
        self._engine = engine

    def start(self):
        if self._engine is not None:
            self._engine.start()
            print("Car started")
        else:
            print("No engine to start")

# Создание объекта Engine
engine = Engine()

# Создание объекта Car
car = Car()

# Внедрение зависимости Engine в объект Car через свойство
car.engine = engine
car.start()

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

🤔 Что будет, если в родительских классах есть функции с одинаковым названием?

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

🚩Множественное наследование и порядок разрешения методов (MRO)

Если у вас есть множественное наследование, то порядок разрешения методов (MRO, Method Resolution Order) определяет, какой метод будет вызван. Python использует алгоритм C3-линеаризации для вычисления MRO.

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    pass

c = C()
c.say_hello()

🚩Порядок разрешения методов (MRO)

В примере выше класс C наследует от классов A и B. Метод say_hello есть в обоих родительских классах. Порядок разрешения методов в классе C будет таким: C -> A -> B. Чтобы увидеть MRO, можно использовать метод __mro__ или функцию mro():

print(C.__mro__)
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

print(C.mro())
# [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

Таким образом, при вызове c.say_hello() будет вызван метод say_hello класса A, так как он идет первым в MRO.

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

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

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        print("Hello from C")

c = C()
c.say_hello()
# Вывод: Hello from C

🚩Вызов методов родительских классов с использованием super()

Иногда необходимо явно вызвать метод одного из родительских классов. Для этого используется функция super(), которая возвращает объект, через который можно вызывать методы родительского класса.

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        super().say_hello()
        print("Hello from C")

c = C()
c.say_hello()
# Вывод:
# Hello from A
# Hello from C

🚩Вызов методов конкретных родительских классов

Можно вызвать его напрямую через имя класса:

class A:
    def say_hello(self):
        print("Hello from A")

class B:
    def say_hello(self):
        print("Hello from B")

class C(A, B):
    def say_hello(self):
        A.say_hello(self)
        B.say_hello(self)
        print("Hello from C")

c = C()
c.say_hello()
# Вывод:
# Hello from A
# Hello from B
# Hello from C

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

🤔 Что такое code cohesion & code coupling?

Когезия (cohesion) и связность (coupling) — это два важных концепта в программировании, которые влияют на качество и структуру кода.

🚩Когезия (Cohesion)

Когезия относится к степени, в которой элементы внутри модуля (например, класса или функции) связаны друг с другом и работают вместе для выполнения одной задачи. Высокая когезия означает, что элементы модуля сильно связаны и направлены на выполнение одной функции, что делает модуль более понятным и легким для сопровождения.

Класс, выполняющий одну задачу:

class FileHandler:
    def read_file(self, filename):
        with open(filename, 'r') as file:
            return file.read()

    def write_file(self, filename, data):
        with open(filename, 'w') as file:
            file.write(data)

Функция, выполняющая одну конкретную задачу:

def calculate_sum(numbers):
    return sum(numbers)

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

🚩Связность (Coupling)

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

Использование интерфейсов или абстракций:

class Database:
    def connect(self):
        pass

class MySQLDatabase(Database):
    def connect(self):
        print("Connecting to MySQL database")

class PostgreSQLDatabase(Database):
    def connect(self):
        print("Connecting to PostgreSQL database")

def initialize_db(db: Database):
    db.connect()

db = MySQLDatabase()
initialize_db(db)

Внедрение зависимостей:

class Service:
    def __init__(self, repository):
        self.repository = repository

    def perform_action(self):
        self.repository.save("Some data")

class Repository:
    def save(self, data):
        print(f"Saving {data}")

repository = Repository()
service = Service(repository)
service.perform_action()

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

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

🤔 Что такое порождающий паттерн?

Порождающие паттерны (creational patterns) — это шаблоны проектирования в объектно-ориентированном программировании, которые предназначены для управления процессом создания объектов.

🚩Основные порождающие паттерны

🟠Одиночка (Singleton)
🟠Фабричный метод (Factory Method)
🟠Абстрактная фабрика (Abstract Factory)
🟠Строитель (Builder)
🟠Прототип (Prototype)

Одиночка (Singleton): Паттерн Одиночка гарантирует, что у класса будет только один экземпляр, и предоставляет глобальную точку доступа к нему.

class Singleton:
    _instance = None

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

singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # True

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

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            return None

dog = AnimalFactory.get_animal("dog")
cat = AnimalFactory.get_animal("cat")
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

Абстрактная фабрика (Abstract Factory): Абстрактная фабрика предоставляет интерфейс для создания семейств связанных или зависимых объектов без указания их конкретных классов.

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class PetFactory:
    def create_dog(self):
        return Dog()

    def create_cat(self):
        return Cat()

factory = PetFactory()
dog = factory.create_dog()
cat = factory.create_cat()
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

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

class House:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None

    def __str__(self):
        return f"House with {self.walls} walls, {self.roof} roof, and {self.windows} windows."

class HouseBuilder:
    def __init__(self):
        self.house = House()

    def build_walls(self, walls):
        self.house.walls = walls
        return self

    def build_roof(self, roof):
        self.house.roof = roof
        return self

    def build_windows(self, windows):
        self.house.windows = windows
        return self

    def build(self):
        return self.house

builder = HouseBuilder()
house = builder.build_walls("brick").build_roof("tile").build_windows("double-glazed").build()
print(house)
# House with brick walls, tile roof, and double-glazed windows.

Прототип (Prototype): Паттерн Прототип создает новые объекты путем копирования существующих экземпляров (прототипов).

import copy

class Prototype:
    def __init__(self, value):
        self.value = value

    def clone(self):
        return copy.deepcopy(self)

original = Prototype(10)
clone = original.clone()
print(original.value)  # 10
print(clone.value)     # 10
clone.value = 20
print(original.value)  # 10
print(clone.value)     # 20

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

🤔 Что такое абстрактная фабрика?

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

🚩Основные концепции

🟠Абстрактная фабрика (Abstract Factory): Интерфейс или базовый класс с методами для создания различных продуктов (объектов).
🟠Конкретные фабрики (Concrete Factories): Реализации абстрактной фабрики, создающие конкретные продукты.
🟠Абстрактные продукты (Abstract Products): Интерфейсы или базовые классы для продуктов, которые создаются фабриками.
🟠Конкретные продукты (Concrete Products): Реализации абстрактных продуктов.

Создание абстрактных продуктов: Рассмотрим пример, в котором абстрактная фабрика создает различные виды кнопок и чекбоксов для двух разных операционных систем: Windows и MacOS.

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def click(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def check(self):
        pass

Создание конкретных продуктов

class WindowsButton(Button):
    def click(self):
        print("Windows button clicked")

class MacOSButton(Button):
    def click(self):
        print("MacOS button clicked")

class WindowsCheckbox(Checkbox):
    def check(self):
        print("Windows checkbox checked")

class MacOSCheckbox(Checkbox):
    def check(self):
        print("MacOS checkbox checked")

Создание абстрактной фабрики

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

Создание конкретных фабрик

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

    def create_checkbox(self) -> Checkbox:
        return MacOSCheckbox()

Использование абстрактной фабрики

def client_code(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    button.click()
    checkbox.check()

# Клиентский код может работать с любыми фабриками и продуктами
windows_factory = WindowsFactory()
macos_factory = MacOSFactory()

print("Client: Testing client code with Windows factory:")
client_code(windows_factory)

print("\nClient: Testing client code with MacOS factory:")
client_code(macos_factory)

🚩Преимущества абстрактной фабрики

🟠Изоляция конкретных классов: Клиентский код работает только с интерфейсами или абстрактными классами.
🟠Легкость замены семейств продуктов: Можно легко менять фабрики, чтобы использовать другие семейства продуктов.
🟠Согласованность продуктов: Абстрактная фабрика гарантирует, что продукты одного семейства будут совместимы между собой.

🚩Недостатки абстрактной фабрики

🟠Усложнение кода: Добавление новых классов и интерфейсов может усложнить структуру кода.
🟠Трудности расширения: При добавлении нового типа продукта может потребоваться изменение интерфейсов и всех конкретных фабрик.

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