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

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

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

🤔 Зачем нужен данный паттерн?

1️⃣ Отмена и повтор операций: Позволяет легко отменять изменения и возвращаться к предыдущим состояниям.

2️⃣ Сохранение состояния: Позволяет сохранять состояния объектов в определённые моменты времени.

3️⃣ Инкапсуляция состояния: Хранит внутреннее состояние объекта, не нарушая его инкапсуляции.

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

➕ Хранитель (Memento): Объект, который сохраняет состояние другого объекта.

➕ Создатель (Originator): Объект, чьё состояние сохраняется и восстанавливается.

➕ Опекун (Caretaker): Объект, который отвечает за хранение хранителей и, при необходимости, предоставляет их создателю для восстановления состояния.

# Хранитель
class Memento:
    def __init__(self, state):
        self._state = state

    def get_state(self):
        return self._state

# Создатель
class TextEditor:
    def __init__(self):
        self._state = ""

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

    def save(self):
        return Memento(self._state)

    def restore(self, memento):
        self._state = memento.get_state()

    def get_state(self):
        return self._state

# Опекун
class History:
    def __init__(self):
        self._mementos = []

    def save(self, memento):
        self._mementos.append(memento)

    def undo(self):
        if not self._mementos:
            return None
        return self._mementos.pop()

# Клиентский код
editor = TextEditor()
history = History()

# Пользователь вводит текст
editor.type("Hello, ")
editor.type("world!")
print(editor.get_state())  # Hello, world!

# Сохранение состояния
history.save(editor.save())

# Продолжение ввода текста
editor.type(" How are you?")
print(editor.get_state())  # Hello, world! How are you?

# Восстановление состояния
editor.restore(history.undo())
print(editor.get_state())  # Hello, world!

🤔 Преимущества:

1️⃣ Отмена и восстановление: Легко реализовать функции отмены и восстановления.

2️⃣ Инкапсуляция состояния: Состояние сохраняется и восстанавливается без нарушения инкапсуляции.

3️⃣ Упрощение управления состоянием: Позволяет создавать контрольные точки состояния объекта.

🤔 Недостатки:

1️⃣ Увеличение использования памяти: Сохранение состояния может потребовать значительных ресурсов, особенно для больших объектов.

2️⃣ Сложность управления: В сложных системах может быть трудно управлять множеством состояний и хранителей.

🤔 Когда использовать данный паттерн?

➕ Когда необходимо реализовать функции отмены и восстановления.

➕ Когда нужно сохранять состояние объекта в определённые моменты времени.

➕ Когда важно сохранять состояние объекта, не нарушая его инкапсуляции.

Паттерн "Хранитель" является мощным инструментом для управления состоянием объектов, предоставляя возможность сохранять и восстанавливать состояния без раскрытия внутренней структуры объекта.

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

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

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

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

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

🤔 Зачем нужен данный паттерн?

1️⃣ Обновление состояния: Автоматически оповещает зависимые объекты о изменениях в объекте-наблюдаемом.

2️⃣ Разделение обязанностей: Позволяет разделить логику оповещения и обновления состояния между объектами.

3️⃣ Гибкость и расширяемость: Упрощает добавление новых наблюдателей и изменение их поведения без изменения кода объекта-наблюдаемого.

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

➕ Субъект (Subject): Интерфейс или абстрактный класс, определяющий методы для добавления, удаления и оповещения наблюдателей.

➕ Конкретный субъект (ConcreteSubject): Реализация субъекта, хранящая состояние и оповещающая наблюдателей об изменениях.

➕ Наблюдатель (Observer): Интерфейс или абстрактный класс, определяющий метод для обновления состояния в ответ на оповещения.

➕ Конкретный наблюдатель (ConcreteObserver): Реализация наблюдателя, обновляющая своё состояние в ответ на изменения субъекта.

from abc import ABC, abstractmethod

# Интерфейс наблюдателя
class Observer(ABC):
    @abstractmethod
    def update(self, temperature):
        pass

# Конкретный наблюдатель
class TemperatureDisplay(Observer):
    def update(self, temperature):
        print(f"Temperature Display: Temperature updated to {temperature}°C")

class TemperatureAlert(Observer):
    def update(self, temperature):
        if temperature > 30:
            print("Temperature Alert: Temperature is too high!")

# Субъект
class WeatherStation:
    def __init__(self):
        self._observers = []
        self._temperature = None

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

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

    def set_temperature(self, temperature):
        self._temperature = temperature
        self.notify_observers()

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

# Клиентский код
weather_station = WeatherStation()
display = TemperatureDisplay()
alert = TemperatureAlert()

weather_station.add_observer(display)
weather_station.add_observer(alert)

weather_station.set_temperature(25)  # Temperature Display: Temperature updated to 25°C
weather_station.set_temperature(35)  # Temperature Display: Temperature updated to 35°C
                                     # Temperature Alert: Temperature is too high!

🤔 Преимущества:

1️⃣ Автоматическое оповещение: Автоматически обновляет наблюдателей при изменении состояния субъекта.

2️⃣ Разделение обязанностей: Субъект не знает о конкретных наблюдателях и их логике.

3️⃣ Гибкость и расширяемость: Легко добавлять новых наблюдателей и изменять их поведение.

🤔 Недостатки:

1️⃣ Порядок уведомления: Порядок оповещения наблюдателей может быть важен и требует управления.

2️⃣ Потенциальные утечки памяти: Неудаленные наблюдатели могут привести к утечкам памяти.

🤔 Когда использовать данный паттерн?

➕ Когда изменение состояния одного объекта должно приводить к изменению других объектов.

➕ Когда необходимо централизованное оповещение об изменениях состояния.

➕ Когда нужно минимизировать связи между субъектом и наблюдателями.

Паттерн "Наблюдатель" является мощным инструментом для управления зависимостями и оповещением в системе, упрощая взаимодействие между объектами и улучшая модульность кода.

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

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

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

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

Паттерн "Состояние" (State) — это поведенческий паттерн проектирования, который позволяет объекту изменять свое поведение в зависимости от его внутреннего состояния. Внешне это выглядит так, как будто объект изменил свой класс. Этот паттерн особенно полезен, когда объект может находиться в нескольких состояниях, каждое из которых определяет его поведение.

🤔 Зачем нужен данный паттерн?

1️⃣ Управление состояниями: Позволяет управлять сложными состояниями объекта, организуя код более структурировано.

2️⃣ Изолирование состояний: Разделяет код, относящийся к разным состояниям, что упрощает его поддержку и модификацию.

3️⃣ Изменение поведения во время выполнения: Объект может динамически изменять своё поведение в зависимости от текущего состояния.

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

➕ Контекст (Context): Объект, который содержит ссылку на текущий объект состояния и делегирует ему выполнение поведения.

➕ Состояние (State): Интерфейс или абстрактный класс, определяющий общие методы для всех конкретных состояний.

➕ Конкретные состояния (ConcreteState): Классы, реализующие конкретное поведение в зависимости от состояния.

from abc import ABC, abstractmethod

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

    @abstractmethod
    def press_button(self, context):
        pass

    @abstractmethod
    def dispense(self, context):
        pass

# Конкретные состояния
class NoCoinState(State):
    def insert_coin(self, context):
        print("Coin inserted.")
        context.state = context.has_coin_state

    def press_button(self, context):
        print("Insert coin first.")

    def dispense(self, context):
        print("Insert coin first.")

class HasCoinState(State):
    def insert_coin(self, context):
        print("Coin already inserted.")

    def press_button(self, context):
        print("Button pressed.")
        context.state = context.sold_state

    def dispense(self, context):
        print("Press button to dispense.")

class SoldState(State):
    def insert_coin(self, context):
        print("Wait! Dispensing in progress.")

    def press_button(self, context):
        print("Wait! Dispensing in progress.")

    def dispense(self, context):
        print("Ticket dispensed.")
        context.state = context.no_coin_state

# Контекст
class TicketMachine:
    def __init__(self):
        self.no_coin_state = NoCoinState()
        self.has_coin_state = HasCoinState()
        self.sold_state = SoldState()
        self.state = self.no_coin_state

    def insert_coin(self):
        self.state.insert_coin(self)

    def press_button(self):
        self.state.press_button(self)

    def dispense(self):
        self.state.dispense(self)

# Клиентский код
machine = TicketMachine()

machine.insert_coin()  # Coin inserted.
machine.press_button() # Button pressed.
machine.dispense()     # Ticket dispensed.

machine.press_button() # Insert coin first.
machine.insert_coin()  # Coin inserted.
machine.dispense()     # Press button to dispense.
machine.press_button() # Button pressed.
machine.dispense()     # Ticket dispensed.

🤔 Преимущества:

1️⃣ Управление состояниями: Упрощает управление сложными состояниями объекта.

2️⃣ Изолирование состояний: Позволяет разделить код, относящийся к разным состояниям.

3️⃣ Динамическое изменение поведения: Объект может динамически изменять своё поведение.

🤔 Недостатки:

1️⃣ Усложнение кода: Добавление большого количества классов состояний может усложнить код.

2️⃣ Повышенные накладные
расходы: Частые изменения состояния могут привести к дополнительным накладным расходам.

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

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

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

📌 Что такое паттерн Стратегия (Strategy) ?

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

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

🤔 Зачем нужен данный паттерн?

1️⃣ Изоляция алгоритмов: Позволяет инкапсулировать различные алгоритмы и использовать их независимо.

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

3️⃣ Гибкость и расширяемость: Легко добавлять новые алгоритмы или изменять существующие без изменения клиентского кода.

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

➕ Стратегия (Strategy): Интерфейс, определяющий общий метод, который должны реализовать все алгоритмы.

➕ Конкретные стратегии (ConcreteStrategy): Реализации различных алгоритмов, которые реализуют интерфейс стратегии.

➕ Контекст (Context): Класс, использующий стратегию для выполнения задачи.

from abc import ABC, abstractmethod

# Интерфейс стратегии
class Strategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

# Конкретные стратегии
class BubbleSortStrategy(Strategy):
    def sort(self, data):
        print("Sorting using Bubble Sort")
        for i in range(len(data)):
            for j in range(0, len(data)-i-1):
                if data[j] > data[j+1]:
                    data[j], data[j+1] = data[j+1], data[j]

class QuickSortStrategy(Strategy):
    def sort(self, data):
        print("Sorting using Quick Sort")
        self.quick_sort(data, 0, len(data) - 1)

    def quick_sort(self, data, low, high):
        if low < high:
            pi = self.partition(data, low, high)
            self.quick_sort(data, low, pi - 1)
            self.quick_sort(data, pi + 1, high)

    def partition(self, data, low, high):
        pivot = data[high]
        i = low - 1
        for j in range(low, high):
            if data[j] <= pivot:
                i = i + 1
                data[i], data[j] = data[j], data[i]
        data[i + 1], data[high] = data[high], data[i + 1]
        return i + 1

# Контекст
class SortingContext:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy

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

    def sort(self, data):
        self._strategy.sort(data)

# Клиентский код
data = [5, 2, 9, 1, 5, 6]

context = SortingContext(BubbleSortStrategy())
context.sort(data)
print(data)  # [1, 2, 5, 5, 6, 9]

context.set_strategy(QuickSortStrategy())
data = [3, 7, 8, 5, 2, 1, 9, 5, 4]
context.sort(data)
print(data)  # [1, 2, 3, 4, 5, 5, 7, 8, 9]

🤔 Преимущества:

1️⃣ Изоляция алгоритмов: Алгоритмы инкапсулируются в отдельные классы, что упрощает их замену и добавление.

2️⃣ Упрощение кода: Контекст использует стратегии, избегая громоздких условных операторов.

3️⃣ Гибкость и расширяемость: Легко добавлять новые стратегии без изменения существующего кода.

Недостатки:

1️⃣ Усложнение структуры кода: Добавление множества классов стратегий может усложнить проект.

2️⃣ Контекст знает о стратегиях: Контекст должен знать о всех возможных стратегиях, чтобы иметь возможность их переключать.

🤔 Когда использовать данный паттерн?

➕ Когда есть несколько вариантов алгоритмов для выполнения задачи.

➕ Когда нужно динамически выбирать алгоритм во время выполнения.

➕ Когда необходимо избежать множества условных операторов для выбора алгоритма.

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

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

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

📌 Что такое шаблонный метод (Template method) ?

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

Паттерн "Шаблонный метод" (Template Method) — это поведенческий паттерн проектирования, который определяет скелет алгоритма в методе, оставляя некоторые шаги подклассам. Подклассы могут переопределять эти шаги, не изменяя структуру алгоритма.

🤔 Зачем нужен данный паттерн?

1️⃣ Повторное использование кода: Позволяет повторно использовать общий алгоритм, избегая дублирования кода.

2️⃣ Контроль над структурой алгоритма: Обеспечивает контроль над основной структурой алгоритма, позволяя изменять только определённые его шаги.

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

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

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

➕ Конкретные подклассы: Реализуют абстрактные методы для конкретных шагов алгоритма.

from abc import ABC, abstractmethod

# Абстрактный класс с шаблонным методом
class Beverage(ABC):
    def prepare_recipe(self):
        self.boil_water()
        self.brew()
        self.pour_in_cup()
        self.add_condiments()

    def boil_water(self):
        print("Boiling water")

    def pour_in_cup(self):
        print("Pouring into cup")

    @abstractmethod
    def brew(self):
        pass

    @abstractmethod
    def add_condiments(self):
        pass

# Конкретный подкласс для кофе
class Coffee(Beverage):
    def brew(self):
        print("Dripping Coffee through filter")

    def add_condiments(self):
        print("Adding Sugar and Milk")

# Конкретный подкласс для чая
class Tea(Beverage):
    def brew(self):
        print("Steeping the tea")

    def add_condiments(self):
        print("Adding Lemon")

# Клиентский код
def prepare_beverage(beverage: Beverage):
    beverage.prepare_recipe()

coffee = Coffee()
tea = Tea()

print("Making coffee:")
prepare_beverage(coffee)

print("\nMaking tea:")
prepare_beverage(tea)

🤔 Преимущества:

1️⃣ Повторное использование кода: Избегает дублирования кода, предоставляя общий алгоритм с изменяемыми шагами.

2️⃣ Инкапсуляция изменений: Изолирует изменяемые части алгоритма в подклассы.

3️⃣ Контроль структуры алгоритма: Обеспечивает строгий контроль над основной структурой алгоритма.

🤔 Недостатки:

1️⃣ Ограниченная гибкость: Если шаблонный метод требует изменения, все подклассы могут нуждаться в изменении.

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

🤔 Когда использовать данный паттерн?

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

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

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

Паттерн "Шаблонный метод" является мощным инструментом для организации кода и управления алгоритмами, предоставляя возможность изменять отдельные шаги алгоритма без изменения его основной структуры.

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

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

📌 Что такое паттерн Посетитель (Visitor) ?

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

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

🤔 Зачем нужен данный паттерн?

1️⃣ Разделение алгоритмов и структуры объектов: Позволяет вынести операции, выполняемые над объектами, в отдельный класс, что упрощает добавление новых операций.

2️⃣ Добавление новых операций: Упрощает добавление новых операций без изменения классов объектов.

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

🤔 Как работает данный паттерн?

Паттерн включает следующие компоненты:

➕ Элемент (Element): Интерфейс или абстрактный класс для объектов, которые могут быть приняты посетителем.

➕ Конкретный элемент (ConcreteElement): Класс, реализующий элемент, который может быть принят посетителем.

➕ Посетитель (Visitor): Интерфейс или абстрактный класс для объектов, выполняющих операции над элементами.

➕ Конкретный посетитель (ConcreteVisitor): Класс, реализующий операции, выполняемые над элементами.

from abc import ABC, abstractmethod

# Интерфейс элемента
class Element(ABC):
    @abstractmethod
    def accept(self, visitor):
        pass

# Конкретные элементы
class TextElement(Element):
    def accept(self, visitor):
        visitor.visit_text_element(self)

    def get_text(self):
        return "This is a text element."

class ImageElement(Element):
    def accept(self, visitor):
        visitor.visit_image_element(self)

    def get_image(self):
        return "This is an image element."

# Интерфейс посетителя
class Visitor(ABC):
    @abstractmethod
    def visit_text_element(self, element):
        pass

    @abstractmethod
    def visit_image_element(self, element):
        pass

# Конкретный посетитель
class PrintVisitor(Visitor):
    def visit_text_element(self, element):
        print(f"Printing: {element.get_text()}")

    def visit_image_element(self, element):
        print(f"Printing: {element.get_image()}")

class SaveVisitor(Visitor):
    def visit_text_element(self, element):
        print(f"Saving: {element.get_text()}")

    def visit_image_element(self, element):
        print(f"Saving: {element.get_image()}")

# Клиентский код
elements = [TextElement(), ImageElement()]
print_visitor = PrintVisitor()
save_visitor = SaveVisitor()

for element in elements:
    element.accept(print_visitor)

for element in elements:
    element.accept(save_visitor)

🤔 Преимущества:

1️⃣ Добавление новых операций: Легко добавлять новые операции без изменения классов элементов.

2️⃣ Разделение кода: Разделяет алгоритмы и структуру объектов, упрощая их понимание и поддержку.

3️⃣ Поддержка сложных структур данных: Упрощает работу с составными объектами или деревьями.

🤔 Недостатки:

1️⃣ Изменение классов элементов: При добавлении новых типов элементов требуется изменение всех классов посетителей.

2️⃣ Нарушение инкапсуляции: Посетитель может требовать доступа к закрытым полям и методам элементов, что может нарушить инкапсуляцию.

🤔 Когда использовать данный паттерн?

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

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

➕ Когда изменение алгоритмов чаще, чем изменение структуры объектов.

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

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

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

📌 Что такое lru cache ?

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

LRU (Least Recently Used) cache — это алгоритм кэширования, который удаляет наименее недавно использованные элементы для освобождения места для новых. В этом алгоритме кэш запоминает, когда каждый элемент был использован в последний раз, и при необходимости удаления элемента удаляет тот, который использовался наиболее давно.

🤔 Зачем он нужен?

1️⃣ Улучшение производительности: Кэширование позволяет уменьшить время доступа к часто используемым данным.

2️⃣ Эффективное использование памяти: Помогает эффективно использовать ограниченную память, удаляя устаревшие данные.

3️⃣ Простота реализации: Алгоритм LRU относительно прост для реализации и часто используется в системах с ограниченными ресурсами.

🤔 Как он работает?

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

1️⃣ Хэш-таблица: Для быстрого доступа к кэшированным данным.

2️⃣ Двусвязный список: Для отслеживания порядка использования элементов. Наиболее недавно использованные элементы находятся в начале списка, а наименее недавно использованные — в конце.

Модуль functools предоставляет встроенную реализацию LRU cache через декоратор lru_cache. Вот пример использования этого декоратора:

from functools import lru_cache

@lru_cache(maxsize=3)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Использование
print(fibonacci(10))  # 55
print(fibonacci.cache_info())  # CacheInfo(hits=8, misses=11, maxsize=3, currsize=3)

# Вывод значений из кэша
print(fibonacci(8))   # 21
print(fibonacci.cache_info())  # CacheInfo(hits=9, misses=11, maxsize=3, currsize=3)

🤔 Преимущества:

1️⃣ Улучшение производительности: Часто используемые данные остаются в кэше, что снижает время доступа.

2️⃣ Эффективное использование памяти: Кэш автоматически удаляет устаревшие данные, освобождая место для новых.

3️⃣ Простота реализации: Встроенные библиотеки и декораторы, такие как lru_cache в Python, упрощают внедрение.

🤔 Недостатки:

1️⃣ Неопределенность удаления: В определённых сценариях LRU может не быть оптимальным выбором для удаления элементов.

2️⃣ Дополнительные накладные расходы: Управление порядком использования элементов требует дополнительных ресурсов.

🤔 Когда его использовать?

➕ Когда нужно кэшировать результаты дорогостоящих вычислений.

➕ Когда доступ к данным является частым и повторяющимся.

➕ Когда размер кэша ограничен, и необходимо автоматически удалять устаревшие данные для освобождения места.

LRU cache является эффективным и простым способом улучшения производительности и управления памятью в системах с ограниченными ресурсами.

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

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

📌 Какие готовые реализации MQ есть ?

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

Существует множество готовых реализаций систем очередей сообщений (Message Queue, MQ), каждая из которых предназначена для различных потребностей и сценариев использования. Вот некоторые из самых популярных и широко используемых реализаций MQ:

1️⃣ RabbitMQ
Это высокопроизводительная система очередей сообщений, построенная на протоколе AMQP (Advanced Message Queuing Protocol). Поддерживает различные паттерны маршрутизации, такие как очереди, маршрутизация по ключам и топологии обмена.

🤔 Особенности:

➕ Поддержка различных протоколов (AMQP, MQTT, STOMP).

➕ Поддержка кластеризации и федерации.

➕ Встроенные механизмы безопасности и управления доступом.

➕ Плагины для мониторинга и управления.

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

import pika

# Установка соединения с RabbitMQ
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

# Создание очереди
channel.queue_declare(queue='hello')

# Отправка сообщения
channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!')
print(" [x] Sent 'Hello World!'")

# Закрытие соединения
connection.close()

2️⃣ Apache Kafka
Это распределённая потоковая платформа, ориентированная на высокую пропускную способность и низкую задержку. Используется для построения систем обработки потоков данных в реальном времени.

🤔 Особенности:

➕ Высокая производительность и масштабируемость.

➕ Поддержка репликации и отказоустойчивости.

➕ Поддержка хранения и обработки больших объемов данных.

➕ Интеграция с системами потоковой обработки данных, такими как Apache Storm и Apache Flink.

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

from kafka import KafkaProducer

# Создание продюсера
producer = KafkaProducer(bootstrap_servers='localhost:9092')

# Отправка сообщения
producer.send('test-topic', b'Hello, Kafka!')
producer.flush()

# Закрытие продюсера
producer.close()

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

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

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

📌 Что такое RPC ?

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

RPC (Remote Procedure Call) — это протокол, который позволяет программам вызывать функции или процедуры, выполняющиеся на удалённом компьютере так, как если бы они выполнялись локально. RPC абстрагирует детали сетевого взаимодействия, предоставляя простой и знакомый способ выполнения распределённых вычислений.

🤔 Особенности:

1️⃣ Прозрачность: Разработчики могут вызывать удалённые функции так же, как и локальные, не заботясь о деталях сетевой коммуникации.

2️⃣ Синхронные вызовы: Вызов удалённой процедуры выглядит как обычный вызов функции, что упрощает понимание и использование.

3️⃣ Гетерогенные системы: RPC позволяет взаимодействовать системам с разной архитектурой и операционными системами.

🤔 Как он работает:

1️⃣ Клиент вызывает удалённую процедуру: Клиентская программа вызывает удалённую процедуру, как если бы она была локальной.

2️⃣ Запрос формируется и отправляется: Система RPC формирует запрос и отправляет его по сети на удалённый сервер.

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

4️⃣ Ответ формируется и отправляется обратно: После выполнения процедуры сервер формирует ответ и отправляет его обратно клиенту.

5️⃣ Клиент получает ответ: Клиентская программа получает ответ и продолжает выполнение, как если бы процедура выполнялась локально.

➕ Серверная часть:

import grpc
from concurrent import futures
import time
import calculator_pb2
import calculator_pb2_grpc

class CalculatorServicer(calculator_pb2_grpc.CalculatorServicer):
    def Add(self, request, context):
        response = calculator_pb2.AddReply()
        response.result = request.a + request.b
        return response

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    calculator_pb2_grpc.add_CalculatorServicer_to_server(CalculatorServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    try:
        while True:
            time.sleep(86400)
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Клиентская часть:
import grpc
import calculator_pb2
import calculator_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = calculator_pb2_grpc.CalculatorStub(channel)
        response = stub.Add(calculator_pb2.AddRequest(a=1, b=2))
    print(f"1 + 2 = {response.result}")

if name == '__main__':
    run()

➕ Определение протокола (calculator.proto):

syntax = "proto3";

service Calculator {
  rpc Add (AddRequest) returns (AddReply) {}
}

message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

message AddReply {
  int32 result = 1;
}

🤔 Преимущества:

1️⃣ Простота использования: Легко интегрируется в существующие приложения, предоставляя простой способ вызова удалённых процедур.

2️⃣ Прозрачность: Абстрагирует сетевые взаимодействия, делая вызовы процедур более интуитивно понятными.

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

🤔 Недостатки:

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

2️⃣ Отказоустойчивость: Требует дополнительных механизмов для обработки ошибок и обеспечения надёжности.

3️⃣ Безопасность: Необходимо обеспечить безопасность данных, передаваемых по сети, что может потребовать дополнительных усилий.

RPC является мощным инструментом для построения распределённых систем, предоставляя простой и интуитивно понятный способ вызова удалённых процедур и улучшая взаимодействие между различными компонентами системы.

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

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

📌 Что такое gPRC ?

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

gRPC (Google Remote Procedure Call) — это современный высокопроизводительный фреймворк для реализации удалённых вызовов процедур (RPC). Он был разработан Google и использует протокол HTTP/2 для передачи данных, а также Protocol Buffers (protobuf) для сериализации и десериализации сообщений. gRPC поддерживает множество языков программирования и предназначен для создания распределённых систем и микросервисной архитектуры.

🤔 Особенности:

1️⃣ Высокая производительность: Использует HTTP/2 для мультиплексирования, сжатия заголовков и улучшенной производительности.

2️⃣ Поддержка нескольких языков: Клиенты и серверы могут быть написаны на разных языках программирования.

3️⃣ Сериализация данных: Использует Protocol Buffers (protobuf) для компактной и эффективной сериализации данных.

4️⃣ Разнообразие типов вызовов: Поддерживает несколько типов RPC, включая односторонние и двусторонние потоковые вызовы.

5️⃣ Интерфейс описания сервиса: Интерфейсы и сообщения описываются в файлах .proto, что упрощает генерацию кода для различных языков.

🤔 Типы RPC в gRPC:

1️⃣ Unary RPC: Клиент отправляет один запрос серверу и получает один ответ.

2️⃣ Server streaming RPC: Клиент отправляет один запрос серверу и получает поток ответов.

3️⃣ Client streaming RPC: Клиент отправляет поток запросов серверу и получает один ответ.

4️⃣ Bidirectional streaming RPC: Клиент и сервер обмениваются потоками запросов и ответов.

🤔 Определение сервиса в файле .proto:

syntax = "proto3";

service Calculator {
  rpc Add (AddRequest) returns (AddReply) {}
}

message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

message AddReply {
  int32 result = 1;
}

🤔 Генерация кода из файла .proto:

Для этого используется утилита protoc:

protoc --python_out=. --grpc_python_out=. calculator.proto

Реализация сервера:

import grpc
from concurrent import futures
import time
import calculator_pb2
import calculator_pb2_grpc

class CalculatorServicer(calculator_pb2_grpc.CalculatorServicer):
    def Add(self, request, context):
        response = calculator_pb2.AddReply()
        response.result = request.a + request.b
        return response

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    calculator_pb2_grpc.add_CalculatorServicer_to_server(CalculatorServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    try:
        while True:
            time.sleep(86400)
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Реализация клиента:
import grpc
import calculator_pb2
import calculator_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = calculator_pb2_grpc.CalculatorStub(channel)
        response = stub.Add(calculator_pb2.AddRequest(a=1, b=2))
    print(f"1 + 2 = {response.result}")

if name == '__main__':
    run()

🤔 Преимущества:

1️⃣ Высокая производительность: Благодаря использованию HTTP/2 и protobuf.

2️⃣ Поддержка нескольких языков: Возможность работы с разными языками программирования.

3️⃣ Типы RPC: Поддержка различных типов взаимодействия между клиентом и сервером.

4️⃣ Масштабируемость: Подходит для построения микросервисной архитектуры.

🤔 Недостатки:

1️⃣ Крутая кривая обучения: Требует знания HTTP/2 и Protocol Buffers.

2️⃣ Совместимость с старыми системами: Не все системы и языки программирования имеют поддержку HTTP/2 и protobuf.

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

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

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

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

📌 Зачем нужен ОПП ?

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

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

🤔 Основные концепции:

1️⃣ Классы и объекты:

➕ Класс: Шаблон или чертеж для создания объектов. Класс определяет атрибуты и методы, которые будут общими для всех объектов этого класса.

➕ Объект: Конкретный экземпляр класса, содержащий реальные значения атрибутов.

2️⃣ Наследование:

➕ Позволяет создавать новый класс на основе существующего. Новый класс (подкласс) наследует атрибуты и методы родительского класса (суперкласса), что способствует повторному использованию кода.

3️⃣ Инкапсуляция:

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

4️⃣ Полиморфизм:

➕ Способность использовать объекты различных классов через единый интерфейс. Это позволяет применять один и тот же метод к объектам разных классов и обеспечивать их различное поведение.

5️⃣ Абстракция:

➕ Скрывает сложность системы, предоставляя упрощённый интерфейс. Абстракция помогает фокусироваться на важных аспектах объекта и игнорировать незначительные детали.

🤔 Преимущества:

1️⃣ Повторное использование кода:

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

2️⃣ Модульность:

➕ Программы разбиваются на модули (классы и объекты), которые можно разрабатывать, тестировать и отлаживать независимо друг от друга.

3️⃣ Расширяемость:

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

4️⃣ Поддержка и отладка:

➕ Благодаря инкапсуляции и абстракции, код становится более понятным и упорядоченным, что облегчает его сопровождение и отладку.

5️⃣ Гибкость и полиморфизм:

➕ Полиморфизм позволяет писать гибкий и расширяемый код, который может работать с объектами различных классов через единый интерфейс.

🤔 Пример:

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

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

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# Использование
animals = [Dog("Buddy"), Cat("Whiskers")]

for animal in animals:
    print(animal.speak())

🤔 В этом примере:

➕ Класс Animal является суперклассом, содержащим абстрактный метод speak.

➕ Классы Dog и Cat являются подклассами, которые наследуют от Animal и реализуют метод speak.

➕ Список animals содержит объекты различных классов, и полиморфизм позволяет вызывать метод speak для каждого из них, не зная их конкретного класса.

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

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

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

📌 Какие есть типы данных в Python?

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

Типы данных делят на 2 группы: изменяемые и не изменяемые.

🤔 Изменяемые (mutable)

➕ Списки (list):

Упорядоченные коллекции, которые могут содержать элементы разных типов. Пример: [1, "apple", 3.14]. Списки часто используются для хранения и последовательного доступа к элементам.

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

➕ Словари (dict):

Коллекции пар ключ-значение. Пример: {"name": "Alice", "age": 25}. Словари удобны для представления объектов с атрибутами. Ключом в словаре может быть значение с не изменяемым типом данных (int, float, str, tuple, bool, frozenset и т.д.)

g = {"name": "Alice", "age": 25}

➕ Множества (set):

Неупорядоченные коллекции уникальных элементов. Пример: {1, 2, 3}. Используются для удаления дубликатов и выполнения операций над множествами, таких как объединение, пересечение.

h = {1, 2, 3, 4, 5}

➕ Байтовые массивы (bytearray):

Это изменяемая последовательность целых чисел в диапазоне от 0 до 255. Они используются для работы с двоичными данными, например, при чтении файлов или сетевого взаимодействия. bytearray полезен, когда вам нужно изменять данные на уровне байтов.

ba = bytearray([50, 100, 150, 200])

🤔 Не изменяемые (immutable)

➕ Целые числа (int):

Как положительные, так и отрицательные. Например, 1, 100, -20.

a = 5

➕ Вещественные числа (float):

Числа с плавающей точкой (то есть с дробной частью). Примеры: 3.14, -0.001

b = 2.5

➕ Комплексные числа (complex):

Этот тип данных используется для представления комплексных чисел, которые включают в себя действительную и мнимую части. В Python комплексные числа могут быть созданы с помощью литерала j для мнимой части. Например, комплексное число 3 + 4j. Комплексные числа используются в научных и инженерных расчетах, где необходимо работать с числами, имеющими мнимую составляющую.

z = 3 + 4j

➕ Длинные целые числа (long):

В старых версиях Python (2.x и ранее) существовал отдельный тип данных long для представления очень больших целых чисел. Однако в Python 3 и выше этот тип был упразднен, и теперь все целые числа (int) могут быть любой длины. Таким образом, в современном Python отдельного типа данных long не существует — все большие целые числа автоматически становятся int.

a = 12345678901234567890L # Python 2.x
a = 12345678901234567890 # Python 3

➕ Строки (str):

Текст, заключенный в одинарные, двойные или тройные кавычки. Например: "hello", 'world'.

c = "Hello, Python!"

➕ Булевы значения (bool):

Имеют всего два значения: True и False. Они часто используются в условиях и логических выражениях.

d = True

➕ Кортежи (tuple):

Похожи на списки, но являются неизменяемыми. Пример: (1, "apple", 3.14). Используются, когда данные не должны изменяться после их создания. Если кортеж содержит изменяемые данные, то он становится изменяемым

f = (1, 2, 3)

➕ Диапазон (range):

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

for i in range(0, 10):
    print(i)

➕ NoneType:

Этот тип данных имеет только одно возможное значение: None. Оно используется для обозначения отсутствия значения. Часто используется в логических операциях например if a is None:

a = None

➕ Frozenset:

Это неизменяемый аналог set. Так как frozenset неизменяем, он может использоваться в качестве ключа в словарях.

fs = frozenset([1, 2, 3])

➕ Байты (bytes):

Похожи на bytearray, но являются неизменяемыми. Они также представляют собой последовательности целых чисел от 0 до 255 и используются для работы с двоичными данными.

b = bytes([50, 100, 150, 200])

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

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

📌 Что такое контекстный менеджер в Python?

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

Контекстный менеджер в Python - это специальный тип объекта, который предназначен для управления контекстом в блоке кода. Основная цель контекстного менеджера - обеспечить корректное управление ресурсами, такими как файлы, сетевые соединения или блокировки в многопоточных программах. Это помогает предотвратить ошибки, такие как утечки ресурсов, и делает код более читаемым и безопасным.Чтобы понять, как работает контекстный менеджер, рассмотрим два ключевых метода, которые он должен реализовывать:

🤔 enter и exit.

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

➕ Метод exit вызывается после окончания блока кода и обычно занимается очисткой ресурсов.

🤔 Пример контекстного менеджера, который управляет файлом:

class FileHandler:
    def init(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def enter(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def exit(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()

# Использование контекстного менеджера
with FileHandler('example.txt', 'w') as f:
    f.write('Привет, мир!')

# После выхода из блока with файл автоматически закрывается

В этом примере FileHandler - это контекстный менеджер для работы с файлами. Когда начинается блок with, вызывается метод enter, который открывает файл. После завершения работы в блоке with автоматически вызывается метод exit, который закрывает файл. Это предотвращает ошибки, связанные с забытым закрытием файла, и делает код более надежным и читаемым.

Контекстные менеджеры широко используются в Python для управления ресурсами, их можно встретить в стандартной библиотеке (например, open для файлов), а также во многих сторонних библиотеках.

🤔 Кратко:

Контекстный менеджер в Python - это способ управления ресурсами в блоке кода, обеспечивающий автоматическое выделение и освобождение ресурсов.

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

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