Подготовка к собеседованию — Дата-инженер

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

Подробно:

• Конкурентность (concurrency) — задачи переключаются и продвигаются «по очереди», создавая иллюзию одновременности. Один повар готовит 3 блюда, переключаясь между ними. Может быть и на одном ядре.
• Параллелизм (parallelism) — задачи реально выполняются в одну и ту же физическую секунду. Три повара, каждый готовит своё блюдо. Требует нескольких ядер/процессоров.

Конкурентность (1 ядро):   Параллелизм (2 ядра):
CPU: A B A B A B            CPU0: A A A A
                           CPU1: B B B B

В Python:

• asyncio и threading (из-за GIL) дают конкурентность, но не настоящий параллелизм для CPU-кода.
• multiprocessing даёт настоящий параллелизм.

💡 «Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once.» — Rob Pike.

⚠️ Ловушка: многие путают и говорят «потоки в Python работают параллельно». Для CPU-bound кода это не так из-за GIL.

Короткий ответ: Аннотации типов не проверяются интерпретатором в рантайме — они нужны для статического анализа (mypy, pyright), автодополнения в IDE, документации и раннего обнаружения ошибок до запуска кода. Python остаётся динамическим, hints — это «контракт», который проверяют внешние инструменты.

Подробно:

Type hints (PEP 484) не влияют на выполнение программы. Интерпретатор их игнорирует — можно передать строку туда, где ожидается int, и код не упадёт сам по себе.

def add(a: int, b: int) -> int:
    return a + b

# Python НЕ проверяет типы — это выполнится без ошибок:
print(add("a", "b"))  # "ab" — конкатенация строк!

# Но mypy выдаст ошибку ДО запуска:
# error: Argument 1 to "add" has incompatible type "str"; expected "int"

Зачем тогда нужны:

1. Раннее обнаружение ошибок — mypy/pyright ловят несовпадения типов до прода.
2. Автодополнение и навигация в IDE (PyCharm, VS Code).
3. Документация — сигнатура def f(x: list[int]) -> dict[str, int] понятнее комментария.
4. Рефакторинг — при изменении типа инструмент покажет все места, где он используется.
5. Контракты в больших командах — снижают «неявные» договорённости.

# Без hints — непонятно, что ожидается:
def process(data, config): ...

# С hints — самодокументируемо:
def process(data: list[dict[str, int]], config: "Config") -> bool: ...

⚠️ Ловушка: Аннотации — не валидация: def f(x: int) не запретит передать строку в рантайме. Для проверки входных данных нужны pydantic или явные проверки с raise — не assert, который при запуске с python -O удаляется.

Короткий ответ: Big O описывает, как растёт время работы или потребление памяти алгоритма при увеличении размера входных данных n, отбрасывая константы и младшие члены. Это верхняя оценка скорости роста.

Подробно:

Big O отвечает на вопрос «что произойдёт, когда n станет очень большим?». Нас не интересует точное число операций, а только характер роста. Поэтому O(2n + 100) упрощается до O(n), а O(3n² + n) — до O(n²).

Основные классы роста (от лучшего к худшему):

# O(1) — константа: не зависит от n
def first(arr):
    return arr[0] if arr else None

# O(log n) — логарифм: каждый шаг делит задачу пополам (бинарный поиск)
def binary_search(arr, target):
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = (lo + hi) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

# O(n) — линейная: один проход
def total(arr):
    s = 0
    for x in arr:        # n итераций
        s += x
    return s

# O(n log n) — эффективные сортировки (merge, quick в среднем, Timsort)
def sort_it(arr):
    return sorted(arr)

# O(n^2) — квадрат: вложенный цикл
def has_dup_naive(arr):
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
                return True
    return False

# O(2^n) — экспонента: наивный Фибоначчи, перебор подмножеств
def fib_naive(n):
    if n < 2:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

Как оценивать код: последовательные шаги складываются, и остаётся старший член (O(n) + O(n log n) = O(n log n)); вложенные циклы перемножаются (O(n·m), при m = n — O(n²)); отбрасывание половины задачи с постоянной работой на шаге даёт O(log n). Если входов два, сохраняйте обе переменные: O(n + m) нельзя сокращать до O(n), пока не известно, что m ≤ n.

⚠️ Ловушка: Big O — это про асимптотику (поведение при больших n), а не про реальное время. O(n) алгоритм может быть медленнее O(n²) на маленьких данных из-за больших констант. Также путают: Big O (верхняя граница, Ω — нижняя, Θ — точная), в собесах под «O» обычно подразумевают Θ.

Короткий ответ: SELECT извлекает строки из таблиц. Логический порядок выполнения НЕ совпадает с порядком написания: сначала FROM, затем WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY, LIMIT.

Подробно:

Порядок написания (синтаксический):

SELECT   DISTINCT col1, agg(col2)
FROM     t
WHERE    cond
GROUP BY col1
HAVING   agg_cond
ORDER BY col1
LIMIT    10 OFFSET 20;

Логический порядок исполнения:

1. FROM / JOIN      -- какие таблицы, как соединить
2. WHERE            -- фильтр строк ДО группировки
3. GROUP BY         -- группировка
4. HAVING           -- фильтр групп ПОСЛЕ агрегации
5. SELECT           -- выражения, алиасы, оконные функции
6. DISTINCT         -- удаление дублей
7. ORDER BY         -- сортировка
8. LIMIT / OFFSET   -- срез

⚠️ Ловушка: алиас из SELECT нельзя использовать в WHERE (т.к. WHERE выполняется раньше SELECT), но можно в ORDER BY и часто в GROUP BY (зависит от СУБД). Пример ошибки:

SELECT salary * 12 AS annual FROM emp WHERE annual > 100000; -- ОШИБКА
SELECT salary * 12 AS annual FROM emp ORDER BY annual;        -- ОК

Короткий ответ: Индекс — это отдельная структура данных, которая хранит значения одной или нескольких колонок в упорядоченном/организованном виде вместе с указателями на физическое расположение строк (TID — tuple identifier), чтобы база могла находить строки без полного сканирования таблицы.

Подробно: Без индекса PostgreSQL вынужден читать всю таблицу (Sequential Scan) и проверять каждую строку. Индекс позволяет за O(log n) (для B-tree) найти нужные TID и потом сходить за самими строками в heap (основную область хранения таблицы).

CREATE INDEX idx_users_email ON users (email);

-- Теперь запрос ищет по дереву, а не по всей таблице
SELECT * FROM users WHERE email = 'a@b.com';

Физически таблица в Postgres хранится в виде heap — неупорядоченного набора страниц по 8 КБ. Индекс — это «оглавление» к этому heap. У одной таблицы может быть много индексов.

⚠️ Ловушка: Индекс ускоряет чтение, но замедляет запись (каждый INSERT/UPDATE/DELETE должен поддерживать индекс актуальным). Индекс на каждую колонку «на всякий случай» — антипаттерн.