📺 База 1000+ реальных собеседований

На программиста, тестировщика, аналитика, проджекта и другие IT профы.

Есть собесы от ведущих компаний: Сбер, Яндекс, ВТБ, Тинькофф, Озон, Wildberries и т.д.

🎯 Переходи по ссылке и присоединяйся к базе, чтобы прокачать свои шансы на успешное трудоустройство!

🤔 В чём преимущество NoSQL перед SQL?

- Гибкость схемы — можно хранить разные поля в разных документах;
- Горизонтальное масштабирование;
- Лучше подходит для больших объёмов неструктурированных данных;
- Идеален для высокой скорости записи и чтения, например, в логировании, кэшировании.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие нюансы есть в использовании чисел как ключей?

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

🚩Хешируемость чисел

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

d = {1: "один", 2: "два"}
print(d[1])  # "один"

🚩Взаимодействие `int` и `float`

Python не делает различий между int и float, если их значения равны. Это связано с тем, что у них одинаковое хеш-значение при равенстве.

d = {1: "один", 1.0: "float один", 2: "два"}
print(d)  # {1: 'float один', 2: 'два'}

🚩Непредсказуемое поведение при работе с `float`

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

d = {0.1 + 0.2: "значение"}  # 0.1 + 0.2 не равно точно 0.3 из-за округления
print(d.get(0.3))  # None, ключ не найден!

🚩Производительность

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

🚩Проблемы при преобразованиях

Если ключами словаря являются числа, то при обработке данных (например, чтении из файла или API) можно случайно преобразовать их в строки, что приведёт к созданию новых ключей вместо использования существующих.

d = {1: "один", 2: "два"}
print(d.get("1"))  # None, строка "1" и число 1 – это разные ключи!

🚩Пользовательские объекты с числовыми свойствами

Если вы используете пользовательские объекты как ключи и они ведут себя как числа (например, реализуют методы __hash__ и __eq__), то их поведение должно быть совместимо с ожидаемым использованием.

class MyNumber:
    def __init__(self, value):
        self.value = value
    
    def __hash__(self):
        return hash(self.value)
    
    def __eq__(self, other):
        return self.value == other.value

d = {MyNumber(1): "один"}
print(d[MyNumber(1)])  # "один"

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

🤔 Какие в asyncio есть три вида табл объекта?

В asyncio "табл-объекты" напрямую не существуют как термин, но в контексте часто имеются в виду:
- Future — объект, представляющий будущий результат;
- Task — обёртка над корутиной, запускающая её в event loop;
- Coroutine — функция, определённая через async def, которую можно "ожидать". Все три участвуют в управлении асинхронными операциями.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Почему вычислять большие значения в асинхронной функции плохо?

Асинхронность (asyncio) в Python не выполняет код параллельно, а переключается между задачами во время ожидания (I/O-bound).
Если в async-функции делать тяжёлые вычисления (CPU-bound), это блокирует asyncio, потому что в Python есть GIL (Global Interpreter Lock).

🚩Асинхронность в Python подходит для ввода-вывода (I/O-bound)

Асинхронность позволяет выполнять задачи без блокировки, но только если они ждут чего-то (файлы, сеть, БД).

import asyncio
import aiohttp

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ["https://example.com"] * 5
    results = await asyncio.gather(*(fetch(url) for url in urls))

asyncio.run(main())

🚩Проблема с `async` и тяжёлыми вычислениями (CPU-bound)

Если в async-функции делать тяжёлые вычисления, Python не сможет переключаться между задачами.

import asyncio

async def heavy_task(n):
    print(f"Вычисляю {n}...")
    total = sum(i**2 for i in range(n))  # Долгий процесс
    return total

async def main():
    await asyncio.gather(heavy_task(10**7), heavy_task(10**7))

asyncio.run(main())

🚩Как правильно выполнять вычисления в `async`?

🟠Использовать `asyncio.to_thread()` (делегирование в потоки)
В Python 3.9+ можно выполнять CPU-задачи в отдельных потоках, не блокируя asyncio.

import asyncio

def heavy_computation(n):
    return sum(i**2 for i in range(n))

async def main():
    result = await asyncio.to_thread(heavy_computation, 10**7)
    print(result)

asyncio.run(main())

🟠Использовать `multiprocessing` (запуск на нескольких ядрах)
Так как Python использует GIL, единственный способ выполнять настоящий параллелизм — это multiprocessing.

import asyncio
import multiprocessing

def heavy_computation(n):
    return sum(i**2 for i in range(n))

async def main():
    loop = asyncio.get_running_loop()
    with multiprocessing.Pool() as pool:
        result = await loop.run_in_executor(pool, heavy_computation, 10**7)
        print(result)

asyncio.run(main())

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

🤔 Какие ещё есть основные методы, кроме магических?

Кроме магических (init, str, len и др.), часто используются обычные методы объектов:
- Для строк: .lower(), .upper(), .replace(), .split(), .join().
- Для списков: .append(), .extend(), .remove(), .pop(), .sort().
- Для словарей: .get(), .items(), .keys(), .values(), .update().
- Для множеств: .add(), .discard(), .union(), .intersection().
Эти методы составляют ядро повседневной работы с типами Python и не являются "магическими", но критически важны.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как понять, какие виды тестов нужны именно сейчас?

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

Что тестируем? (код, API, UI, производительность и т. д.)
Какие риски? (где может сломаться, критичность ошибки)
Какой этап разработки? (новый код, рефакторинг, релиз)

🚩Как определить нужные тесты прямо сейчас?

🟠Только написали новый код
Нужны: Юнит-тесты
Тестируем функции и классы отдельно.

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5  # ✅ Юнит-тест

🟠Соединяем модули или работаем с API
Нужны: Интеграционные тесты
Проверяем работу всей системы вместе.

def test_api():
    response = requests.get("https://api.example.com/data")
    assert response.status_code == 200

🟠Перед релизом или деплоем
Нужны: Функциональные и регрессионные тесты
Проверяем ключевые сценарии и старый функционал.

def test_login():
    assert login("user", "password") == "Success"

🟠Изменили UI (например, фронтенд на React)
Нужны: UI-тесты (Selenium, Playwright)
Проверяем нажатие кнопок, формы и отображение страниц.

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
assert "Example" in driver.title

🟠Если проект должен выдерживать большую нагрузку
Нужны: Нагрузочные тесты (Load Testing)
Используем locust, JMeter, k6, чтобы проверить сколько пользователей выдержит сервер.

from locust import HttpUser, task

class MyUser(HttpUser):
    @task
    def test_homepage(self):
        self.client.get("/")

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

🤔 Можно ли через GET отправить файл?

Технически — нет.
GET не имеет тела запроса, а файл — это большой объём данных, требующий формата и тела передачи, что характерно для POST или PUT.
Передача файла всегда должна идти через POST (или PUT), с корректным Content-Type.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое моржовый оператор?

Моржовый оператор (:=) – это новый оператор, появившийся в Python 3.8, который позволяет присваивать значение переменной прямо внутри выражения.

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

Обычно мы записываем код так:

value = len(my_list)  # Сначала присваиваем
if value > 10:  # Потом используем
    print("Список большой")

С := можно совместить оба действия

if (value := len(my_list)) > 10:
    print("Список большой")

🚩Где использовать?

В циклах (избегаем лишних вычислений). Вместо:

data = input("Введите строку: ")
while data != "exit":
    print("Вы ввели:", data)
    data = input("Введите строку: ")

С := можно записать короче:

while (data := input("Введите строку: ")) != "exit":
    print("Вы ввели:", data)

В if и while (проверяем и присваиваем одновременно)
Без :=

text = input("Введите слово: ")
if len(text) > 5:
    print(f"Слово длинное ({len(text)} символов)")

С :=:

if (length := len(text)) > 5:
    print(f"Слово длинное ({length} символов)")

В списковых включениях (list comprehensions)
Без :=:

numbers = [random.randint(1, 100) for _ in range(10)]
filtered = [num for num in numbers if num % 2 == 0]

С :=:

filtered = [num for _ in range(10) if (num := random.randint(1, 100)) % 2 == 0]

🚩Когда не стоит использовать `:=`?

Если код становится сложнее для чтения

if (a := func()) and (b := another_func(a)) > 10:
    ...

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

🤔 Что такое Apache Airflow?

Apache Airflow — это платформа для оркестрации рабочих процессов (workflow), особенно в задачах обработки данных. Она позволяет описывать пайплайны в виде DAG (направленного графа задач), управлять зависимостями, планировать и отслеживать выполнение.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Объясни как происходит обработка HTTP запросов на Django

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

🚩Подробный разбор обработки HTTP-запроса в Django

🟠Запрос приходит в WSGI/ASGI сервер
Когда клиент (браузер, API) отправляет запрос, его принимает WSGI/ASGI-сервер (Gunicorn, Daphne).
Если проект синхронный → работает через WSGI (wsgi.py).
Если проект асинхронный → через ASGI (asgi.py).

GET /hello/ HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0

🟠Django создаёт `HttpRequest` объект
Django превращает HTTP-запрос в объект HttpRequest, который передаётся в view.

def my_view(request):
    print(request.iss.onethod)  # 'GET'
    print(request.path)  # '/hello/'
    print(request.GET)  # {'name': 'Alice'}

🟠Middleware (промежуточная обработка)
Прежде чем запрос дойдёт до view, Django проходит через мидлвари, которые могут:
Проверять авторизацию (AuthenticationMiddleware).
Защищать от CSRF (CsrfViewMiddleware).
Перенаправлять запросы (CommonMiddleware).

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
]

🟠Поиск `view` в `urls.py`
Django ищет, какая функция (view) должна обработать этот URL.

from django.urls import path
from myapp.views import hello_view

urlpatterns = [
    path("hello/", hello_view),  # Запрос "/hello/" попадёт в hello_view
]

🟠Выполнение `view` (контроллера)
Когда Django находит подходящее представление (view), оно вызывается.

from django.http import HttpResponse

def hello_view(request):
    return HttpResponse("Привет, мир!")

🟠Формирование и обработка ответа
Django берёт HttpResponse и передаёт его обратно через middleware (например, сжатие, защита, заголовки безопасности).

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 12

Привет, мир!

🟠WSGI/ASGI сервер отправляет ответ клиенту
На последнем этапе WSGI/ASGI-сервер отправляет ответ обратно браузеру или API-клиенту.


🚩Краткая схема обработки запроса

Клиент (браузер) → WSGI/ASGI → Django Middleware → URL Dispatcher → View → Response → Клиент

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

🤔 Что может находиться в заголовке (headers)?

HTTP-заголовки содержат метаинформацию о запросе или ответе. Примеры:
- Информация о клиенте: User-Agent, Referer
- Тип содержимого: Content-Type, Accept
- Аутентификация: Authorization
- Кэширование: Cache-Control, ETag
- Безопасность: Strict-Transport-Security, CSP
- Куки: Cookie, Set-Cookie
Заголовки используются для управления поведением запроса и обработки данных на стороне сервера и клиента.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что за функция sleep()?

Функция sleep() из модуля time приостанавливает выполнение программы на заданное количество секунд.

🚩Как использовать `sleep()` в Python?

Функция sleep() принимает один аргумент** — число секунд (может быть дробным).

import time

print("Программа началась...")
time.sleep(3)  # Ожидание 3 секунды
print("3 секунды прошло!")

🚩Где используется `sleep()`?

Ожидание в цикле (имитация загрузки)

for i in range(5, 0, -1):
    print(i)
    time.sleep(1)  # Задержка 1 секунда между выводами
print("Старт!")

Запросы к серверу с паузами (чтобы не забанили)

import time
import requests

for i in range(3):
    response = requests.get("https://example.com")
    print(f"Запрос {i+1}: статус {response.status_code}")
    time.sleep(2)  # Ждём 2 секунды перед следующим запросом

Искусственная задержка перед повторной попыткой

for attempt in range(3):
    print(f"Попытка {attempt + 1}...")
    time.sleep(2)  # Ожидание 2 секунды перед новой попыткой

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

🤔 Что такое шардирование?

Это метод горизонтального разделения базы данных, при котором данные распределяются между несколькими серверами (шардами).
• Каждый шард содержит уникальный подмножество данных, обеспечивая масштабируемость и повышение производительности.
• Используется для работы с большими объёмами данных и снижения нагрузки на один сервер.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Можно ли при вызове метода save указать какие поля изменять?

Да, в Django ORM можно указать конкретные поля для сохранения, используя параметр update_fields в методе .save().

🚩Как использовать `update_fields`

Пример модели

from django.db import models

class UserProfile(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    age = models.IntegerField()

Обновляем только поле name, не трогая email и age

user = UserProfile.objects.get(id=1)
user.name = "Новый пользователь"
user.save(update_fields=["name"])  # Обновит только поле `name`

🚩Что делает `update_fields`?

Генерирует SQL-запрос только для указанных полей, например:

  UPDATE user_profile SET name = 'Новый пользователь' WHERE id = 1;
  

🚩Когда `update_fields` полезен?
Уменьшает нагрузку на БД, так как обновляет только нужные поля.
Полезен, если нужно изменить одно поле, а не всю запись.
Избегает ненужных изменений в auto_now и auto_now_add полях (DateTimeField).

🚩Ограничения `update_fields`

Нельзя использовать при создании объекта (save() с update_fields не работает для .create()).

user = UserProfile(name="Alice", email="[email protected]")
user.save(update_fields=["name"])  # ❌ Ошибка, объект ещё не в базе!

Не обновляет auto_now-поля (DateTimeField) автоматически!

updated_at = models.DateTimeField(auto_now=True)  # Не обновится с `update_fields`

Решение: обновить вручную:

user.updated_at = timezone.now()
user.save(update_fields=["name", "updated_at"])

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

🤔 Как обеспечить беспрерывную работу сервиса CI/CD?

- Использовать отказоустойчивую инфраструктуру (например, k8s, балансировщики).
- Настроить мониторинг и оповещения.
- Применять горизонтальное масштабирование.
- Использовать инфраструктуру как код для восстановления при сбоях.
- Делать регулярные бэкапы и тестировать восстановление.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть минусы у Monkey Patch если использовать не в тесте?

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

🚩Ломает предсказуемость кода

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

import datetime

# Меняем поведение метода now()
def fake_now():
    return datetime.datetime(2000, 1, 1)

datetime.datetime.now = fake_now  # Monkey Patch

print(datetime.datetime.now())  # Выведет 2000-01-01 00:00:00

🚩Может вызвать неожиданные ошибки после обновления библиотек

Если библиотека обновится, и её внутренняя логика изменится, Monkey Patch может перестать работать или, что ещё хуже, привести к багам.
Ты сделал Monkey Patch метода json.dumps, а потом библиотека json обновилась и поменяла его сигнатуру. Теперь твой патч сломается или будет работать некорректно.

🚩Трудно отлаживать и поддерживать

Monkey Patching меняет поведение кода в скрытом режиме, поэтому сложно понять, почему что-то работает не так. Если баг возник из-за патча, отладка может занять часы или даже дни.
Ты исправил баг с str.split(), заменив его через Monkey Patch, но через 6 месяцев разработчик обновил код, забыл про патч, и всё сломалось.

🚩Может затронуть весь код проекта (глобальное изменение)

Monkey Patching меняет поведение для всей программы, а не только в одном модуле или файле. Это делает код хрупким и непредсказуемым.
Если ты изменишь метод dict.get(), он будет вести себя по-другому во всех модулях программы. Это может привести к критическим ошибкам.

original_get = dict.get

def patched_get(self, key, default=None):
    print(f"Запрашивается ключ: {key}")
    return original_get(self, key, default)

dict.get = patched_get  # Monkey Patch

d = {"a": 10}
print(d.get("a"))  # Работает, но теперь с побочным эффектом

🚩Нет гарантии, что это сработает во всех окружениях
Monkey Patch может работать на одной версии Python или библиотеки, но сломаться на другой. В продакшене, где есть разные серверы и окружения, это может вызвать непредсказуемые ошибки.

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

🤔 Чем отличается task от shared_task?

- task в контексте asyncio — это объект, запускающий корутину в event loop.
- shared_task — термин из Celery, означает, что задача может быть вызвана без явного указания имени приложения.
То есть task — про асинхронность, shared_task — про очереди задач.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Для чего нужен счетчик ссылок Python?

В Python счетчик ссылок (reference count) используется для управления памятью. Он показывает, сколько раз объект используется в программе. Когда счетчик ссылок падает до нуля, Python автоматически удаляет объект, освобождая память.

🚩Как работает счетчик ссылок?

Python использует автоматическое управление памятью, основанное на подсчёте ссылок. Когда создаётся объект, Python хранит специальное число — количество ссылок на этот объект. Это число увеличивается, когда мы создаём новую ссылку на объект, и уменьшается, когда удаляем или перезаписываем переменную.

import sys

a = [1, 2, 3]  # Создаём список
print(sys.getrefcount(a))  # Выведет 2 (одна ссылка 'a' + вызов getrefcount)

b = a  # Новая ссылка на тот же объект
print(sys.getrefcount(a))  # Теперь 3 (a, b и сам getrefcount)

del a  # Удаляем одну ссылку
print(sys.getrefcount(b))  # Теперь 2

del b  # Удаляем последнюю ссылку, объект будет удалён из памяти

🚩Почему это важно?

🟠Эффективное управление памятью
Python сам удаляет ненужные объекты, не давая памяти переполняться.
🟠Понимание утечек памяти
Если объект имеет циклические ссылки (например, список ссылается сам на себя), Python не может освободить его сразу, поэтому дополнительно используется сборщик мусора (Garbage Collector, GC).

import gc

class Node:
    def __init__(self):
        self.ref = self  # Циклическая ссылка!

n = Node()
del n  # Обычный подсчёт ссылок не сработает, объект останется в памяти
gc.collect()  # Явный вызов сборщика мусора удалит его

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

🤔 Можно ли декорировать классы?

Да, можно. Декоратор может изменить или вернуть новый класс, обёрнутый в дополнительную логику.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое хешируемые типы данных?

Это такие типы данных, которые имеют постоянное (неизменяемое) хеш-значение на протяжении всего времени их существования. Это означает, что их можно использовать в качестве ключей в словарях (dict) и элементов в множествах (set), так как они поддерживают вычисление хеша с помощью функции hash().

🚩Как понять, что объект хешируемый?

🟠Объект должен быть неизменяемым
если объект можно изменить после создания, его хеш тоже изменится, что нарушает работу структур данных (словари, множества).
🟠Должен реализовывать метод `__hash__()`
который возвращает уникальный идентификатор объекта.

🚩Какие типы данных хешируемые?

Числа (int, float, complex)

  print(hash(42))       # 42
  print(hash(3.14))     # 322818021289917443
  print(hash(1 + 2j))   # 8389048192121911274

Строки (str)

print(hash("hello"))  # Например, 5320385861927423548

Кортежи (tuple), если все их элементы тоже хешируемые:

print(hash((1, 2, 3)))  # 529344067295497451

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

  print(hash(True))   # 1
  print(hash(False))  # 0

🚩Какие типы НЕ хешируемые?

Списки (list)

hash([1, 2, 3])  # TypeError: unhashable type: 'list'

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

hash({1, 2, 3})  # TypeError: unhashable type: 'set'

Словари (dict)

hash({"a": 1})  # TypeError: unhashable type: 'dict'

🚩Почему это важно?

Хешируемые типы используются в словари (dict) и множества (set), так как они используют хеш-функцию для быстрого поиска данных.

my_dict = { (1, 2, 3): "tuple_key" }  # Работает, потому что кортеж неизменяемый
my_set = { 42, "hello", (1, 2) }      # Все элементы хешируемые

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