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

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

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

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

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

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

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

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

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

counter = count_up_to(5)
for num in counter:
    print(num)

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

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

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

➕ Пример асинхронной функции:

import asyncio

async def fetch_data():
    print('Start fetching')
    await asyncio.sleep(2)  # Имитация асинхронной задачи, например, запроса к серверу
    print('Done fetching')
    return {'data': 1}

async def main():
    print('Before fetching')
    result = await fetch_data()
    print('Result:', result)
    print('After fetching')

asyncio.run(main())

Здесь fetch_data является асинхронной функцией. Когда она достигает строки await asyncio.sleep(2), управление возвращается в main, позволяя выполнять другие операции, в то время как fetch_data находится в ожидании.

Таким образом, генераторы и асинхронные функции позволяют Python более эффективно использовать однопоточную модель исполнения, предоставляя механизм для конкурентного выполнения задач, особенно в ситуациях, когда много времени уходит на ожидание ввода/вывода.

🤔 Итог:

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

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

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

📌 Что такое индексы и как они работают?

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

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

🤔 Зачем нужны

Индексы существенно ускоряют поиск и выборку данных, особенно в больших таблицах. Без индексов база данных должна была бы осуществлять "полное сканирование таблицы" (full table scan), что очень ресурсоемко и медленно, особенно для больших объемов данных. Однако стоит учитывать, что создание и поддержание индексов также требует дополнительных ресурсов, включая место на диске и время на обновление индекса при изменении данных в таблице.

🤔 Как работают индексы

Существуют различные типы индексов, и они могут быть реализованы по-разному в зависимости от системы управления базами данных (СУБД), но обычно они используют структуры данных, такие как B-деревья или хеш-таблицы, для эффективного хранения и поиска данных.

Например, если вы создаете индекс для столбца "Фамилия" в таблице с записями сотрудников, СУБД создаст структуру данных (например, B-дерево), которая позволит быстро находить записи по значению фамилии, не перебирая каждую запись в таблице.

CREATE INDEX idx_lastname ON employees (lastname);

Эта SQL-команда создает индекс idx_lastname для столбца lastname в таблице employees. После создания этого индекса запросы, которые ищут сотрудников по фамилии, будут выполняться значительно быстрее.

🤔 Итог:

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


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

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