📌 Что такое паттерн Стратегия (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 - это способ управления ресурсами в блоке кода, обеспечивающий автоматическое выделение и освобождение ресурсов.

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

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

📌 Что такое декоратор??

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

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

🤔 Основные особенности декораторов:

1️⃣ Преобразование функций:

Декораторы могут изменять поведение функции, не изменяя её кода.

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

Они позволяют использовать общий код в нескольких функциях, уменьшая дублирование.

3️⃣ Синтаксическое удобство:

В Python декораторы могут быть применены к функции с использованием символа @, что делает код более читабельным и элегантным.


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

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

📌 Чем init() отличается от new() ?

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

Различие между init() и new() заключается в их роли при создании экземпляров классов.

➕ __init__() – это инициализатор класса. Он вызывается, когда экземпляр класса уже создан, чтобы инициализировать его начальное состояние. Метод init() не возвращает ничего и используется для установки значений атрибутов объекта.

➕__new__() – это конструктор класса. Он фактически создаёт экземпляр класса и вызывается перед __init__(). Это статический метод, который должен возвращать новый созданный объект, и он используется в особых случаях, например, при создании экземпляров синглтонов или при наследовании от неизменяемых типов данных, как tuple.

➕ Пример с init()

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

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

# Создание экземпляра класса Person
person1 = Person("Алексей", 30)

print(f"Имя: {person1.name}, Возраст: {person1.age}")

В этом примере init() используется для установки имени и возраста для каждого объекта Person. Это самый распространенный способ инициализации атрибутов в объектно-ориентированном программировании.

➕ Пример с new()

new() используется реже, но его можно применять в специфических сценариях, например, для создания синглтонов (одиночек).

class Singleton:
    _instance = None

    def new(cls):
        if cls._instance is None:
            print("Создание экземпляра")
            cls._instance = super(Singleton, cls).new(cls)
        return cls._instance

# Создание экземпляров Singleton
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # Вернет True, так как оба объекта являются одним и тем же экземпляром

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

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

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