Оконные функции — функции SQL, которые выполняют вычисления по группе строк (окну), при этом не объединяют строки в одну, как это делает GROUP BY.

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

Как задаётся окно

🔹 PARTITION BY — разбивает данные на группы
🔹 ORDER BY — задаёт порядок внутри группы

Частые функции

🔹 ROW_NUMBER() — нумерация строк
🔹 RANK() — ранжирование
🔹 SUM() / AVG() — агрегаты по окну
🔹 LAG() / LEAD() — доступ к соседним строкам

🐍Вопросы с собесов -> ProstoPython

📈 From O(n²) to O(n)
Задача: проверить, есть ли в строке повторяющиеся символы

Очень частая задача на собеседованиях.

❌ Наивное решение — O(n²)

def has_duplicates(s):
    for i in range(len(s)):
        for j in range(i + 1, len(s)):
            if s[i] == s[j]:
                return True
    return False

Логика простая:
каждый символ сравниваем со всеми остальными.

Работает.
Но это два вложенных цикла —> O(n²).

На длинных строках будет медленно.

✅ Оптимальное решение — O(n)

def has_duplicates(s):
    seen = set()

    for char in s:
        if char in seen:
            return True
        seen.add(char)

    return False

🧠 Что изменилось

🔹 строку проходим один раз
🔹 используем set для хранения символов
🔹 проверка in set работает за O(1)

В итоге вся функция работает за O(n).

🐍Вопросы с собесов -> ProstoPython

⏱️ Big O Breakdown

Посмотри на код:

def process(n):
    i = 1
    while i < n:
        for j in range(i):
            print(j)
        i *= 2

❓ Какая сложность?

A) O(n)
B) O(n log n)
C) O(log n)
D) O(n²)

✅ Правильный ответ: A) O(n)

🧠 Разбираем

Значение i растёт так:

1
2
4
8
16
...


То есть цикл выполняется log n раз.

Но внутренний цикл каждый раз работает:

1
2
4
8
16
...

Если сложить все итерации:

1 + 2 + 4 + 8 + ... + n

Это геометрическая прогрессия.

Её сумма примерно 2n

📌 Итог

Общее количество операций примерно 2n

А значит итоговая сложность:

O(n)

🐍Вопросы с собесов -> ProstoPython

Попробуйте ответить без запуска, что выведет код, разбор будет через 2 часа

🐍Вопросы с собесов -> ProstoPython

Разбор по шагам:

1️⃣ Список изначально

[1, 2, 3]

2️⃣ Первая итерация
i = 1
ничего не происходит.

3️⃣ Вторая итерация
i = 2
выполняется:

x.remove(2)

Список становится:

[1, 3]

4️⃣ Итератор пытается перейти к следующему индексу,
но список уже сократился, поэтому цикл завершается.

Итог:

[1, 3]

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 27
Тема: лишний else после return

Иногда код работает нормально, но читается тяжелее, чем должен.

❌ Плохо:

def check_age(age):
    if age >= 18:
        return "adult"
    else:
        return "minor"

Функция работает.
Но else здесь вообще не нужен.

✅ Code Cleanup:

def check_age(age):
    if age >= 18:
        return "adult"
    return "minor"

🧠 Почему так лучше

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

После return выполнение функции и так заканчивается,
поэтому else становится лишним.

🐍Вопросы с собесов -> ProstoPython

REST (Representational State Transfer) — архитектурный стиль построения веб-сервисов, использующий возможности HTTP.

Основные принципы

🔹 HTTP-методы по назначению
GET — получение
POST — создание
PUT / PATCH — обновление
DELETE — удаление

🔹 Stateless — сервер не хранит состояние клиента между запросами

🔹 Единый интерфейс — предсказуемая структура URL и ответов

Итог: REST — это способ проектирования API, где операции выполняются над ресурсами через стандартные HTTP-методы.

🐍Вопросы с собесов -> ProstoPython

⏱️ Big O Breakdown

Посмотри на код:

def example(n):
    for i in range(n):
        j = 1
        while j < n:
            print(i, j)
            j *= 2

❓ Какая здесь сложность?

A) O(n)
B) O(n log n)
C) O(n²)
D) O(log n)

✅ Правильный ответ: B) O(n log n)

🧠 Разбор

Внешний цикл:

for i in range(n)


выполняется n раз → O(n)

Внутренний цикл:

j *= 2


значение растёт так:

1 —> 2 —> 4 —> 8 —> 16 —> ...


Количество шагов примерно log₂(n) —> O(log n)

Теперь объединяем:

O(n) * O(log n) = O(n log n)

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 28
Тема: лишний вызов len()

Иногда код делает одну и ту же работу несколько раз.

❌ Плохо:

def get_last(nums):
    if len(nums) > 0:
        return nums[len(nums) - 1]
    return None

Работает.
Но выглядит тяжелее, чем должен.

✅ Code Cleanup:

def get_last(nums):
    if nums:
        return nums[-1]
    return None

🧠 Почему так лучше

🔹 if nums — питоничный способ проверить пустоту
🔹 nums[-1] сразу берёт последний элемент
🔹 код короче и читается быстрее
🔹 не вызываем len() лишний раз

🐍Вопросы с собесов -> ProstoPython

📈 From O(n log n) to O(n)

Задача: проверить, является ли строка анаграммой другой строки.
(то есть состоят ли строки из одинаковых символов)

Например:

"listen" и "silent" → True

❌ Популярное решение — O(n log n)

def is_anagram(s, t):
    return sorted(s) == sorted(t)

Почему O(n log n)?

Потому что sorted() использует сортировку,
а сортировка имеет сложность O(n log n).

Работает нормально…
но можно сделать быстрее.

✅ Оптимальное решение — O(n)

from collections import Counter

def is_anagram(s, t):
    return Counter(s) == Counter(t)

🧠 Почему теперь O(n)

Мы просто считаем,
сколько раз встречается каждый символ.

Например:

listen —> {l:1, i:1, s:1, t:1, e:1, n:1}
silent —> {s:1, i:1, l:1, e:1, n:1, t:1}


И сравниваем два словаря.

Один проход по строке —> O(n).

🐍Вопросы с собесов -> ProstoPython

HTTP/1.1 — самая распространённая версия, долгое время была стандартом интернета.
Особенности:

🔹 постоянные соединения (keep-alive)
🔹 текстовый протокол
🔹 один запрос за раз в одном соединении

HTTP/2 — современная версия, используемая большинством браузеров и серверов.

🔹 бинарный протокол
🔹 мультиплексирование (несколько запросов в одном соединении)
🔹 сжатие заголовков
🔹 уменьшение задержек

HTTP/3 — новейшая версия.

🔹 работает поверх QUIC (UDP)
🔹 быстрее устанавливает соединение
🔹 лучше работает при потере пакетов

🐍Вопросы с собесов -> ProstoPython

⏱️ Big O Breakdown

Посмотри на код:

def example(arr):
    arr.sort()

    for i in range(len(arr)):
        print(arr[i])

❓ Какая итоговая сложность?

A) O(n)
B) O(n log n)
C) O(n²)
D) O(log n)

✅ Правильный ответ: B) O(n log n)

🧠 Разбор

Здесь две операции:

1️⃣ Сортировка массива

arr.sort()

Сложность сортировки в Python (Timsort):

O(n log n)

2️⃣ Проход по массиву

for i in range(len(arr))

Это:

O(n)

Теперь объединяем:

O(n log n) + O(n)

В Big O оставляем самый медленный рост.

🐍Вопросы с собесов -> ProstoPython

❌ Rookie Mistakes
Тема: dict.keys() там, где это не нужно

Иногда можно встретить такой код:

❌ Плохо:

d = {"a": 1, "b": 2}

if "a" in d.keys():
    print("Found")

Работает? Да.
Но выглядит странно для Python.

✅ Правильно:

if "a" in d:
    print("Found")

🧠 Почему так лучше

🔹 in dict по умолчанию проверяет ключи
🔹 код короче и читается быстрее
🔹 не создаётся лишнее представление keys()

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 29
Тема: лишняя проверка перед append

Иногда код выглядит так:

❌ Плохо:

result = []

for x in nums:
    if x % 2 == 0:
        result.append(x)

Работает.
Но в Python есть способ сделать это чище.

✅ Code Cleanup:

result = [x for x in nums if x % 2 == 0]

🧠 Почему так лучше

🔹 короче
🔹 читается быстрее
🔹 сразу видно условие и результат

🐍Вопросы с собесов -> ProstoPython

Quick Sort — алгоритм сортировки с разделением массива относительно опорного элемента.

Сложность:

🔹 Средняя — O(n log n)
🔹 Лучшая — O(n log n)
🔹 Худшая — O(n²) (если опорный элемент выбирается неудачно)

Сортировка в Python

В Python (list.sort() и sorted()) используется Timsort.

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

🔹 гибрид Merge Sort + Insertion Sort
🔹 оптимизирован для частично отсортированных данных
🔹 стабильная сортировка

Сложность:

🔹 O(n log n) в среднем и худшем случае
🔹 O(n) если данные почти отсортированы

Итог:
Quick Sort — O(n log n) в среднем, O(n²) в худшем.
В Python по умолчанию используется Timsort.

🐍Вопросы с собесов -> ProstoPython

⏱️ Big O Breakdown

Посмотри на код:

def example(n):
    i = n
    while i > 0:
        for j in range(i):
            print(j)
        i //= 2

❓ Какая сложность?

A) O(n)
B) O(n log n)
C) O(n²)
D) O(log n)

✅ Правильный ответ: A) O(n)

🧠 Разбор

Первая итерация:

n операций

Вторая:

n/2

Третья:

n/4

Дальше:

n/8

И так далее.

Если сложить:

n + n/2 + n/4 + n/8 + ...

Получаем примерно:

2n

📌 Итог

Общее количество операций примерно 2n

А значит итоговая сложность:

O(n)

💡 Ловушка на собеседованиях

Многие видят:

🔹цикл внутри цикла

🔹деление на 2

и автоматически отвечают O(n log n).

🐍Вопросы с собесов -> ProstoPython

🧰 Code Cleanup — выпуск 30
Тема: лишняя переменная в цикле

Иногда код создаёт переменную, которая используется всего один раз.

❌ Плохо:

squares = []

for x in nums:
    square = x * x
    squares.append(square)

Переменная square здесь ничего не объясняет и живёт всего одну строку.

✅ Code Cleanup:

squares = []

for x in nums:
    squares.append(x * x)

Или ещё чище:

squares = [x * x for x in nums]

🧠 Почему так лучше

🔹 меньше лишних переменных
🔹 код короче
🔹 логика читается быстрее
🔹 меньше «шума»

🐍Вопросы с собесов -> ProstoPython

❌ Rookie Mistakes
Тема: путаница между append() и extend()

Иногда можно увидеть такой код:

nums = [1, 2, 3]
nums.append([4, 5])

print(nums)

Многие ожидают получить:

[1, 2, 3, 4, 5]

Но реальный вывод будет:

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

🧠 В чём ошибка

Метод append() добавляет объект целиком.

То есть список [4, 5] добавляется как один элемент.

✅ Если нужно добавить элементы списка

Используй extend():

nums = [1, 2, 3]
nums.extend([4, 5])

print(nums)

Теперь результат будет:

[1, 2, 3, 4, 5]

🐍Вопросы с собесов -> ProstoPython

⏱️ Big O Breakdown

Посмотри на код:

def example(n):
    for i in range(n):
        for j in range(n):
            for k in range(n):
                print(i, j, k)

❓ Какая сложность?

A) O(n)
B) O(n²)
C) O(n³)
D) O(n log n)

✅ Правильный ответ: C) O(n³)

🧠 Разбор

Первый цикл:

n

Второй цикл:

n

Третий цикл:

n

Общее количество операций:

n × n × n = n³

📌 Итог

Сложность алгоритма:

O(n³)

🐍Вопросы с собесов -> ProstoPython

📈 From O(n²) to O(n)

Задача: найти максимальную сумму подмассива.
(классическая задача, которую любят на собеседованиях)

Например:

nums = [-2,1,-3,4,-1,2,1,-5,4]

Ответ:

6

Потому что лучший подмассив:

[4, -1, 2, 1]

❌ Наивное решение — O(n²)

def max_subarray(nums):
    max_sum = float('-inf')

    for i in range(len(nums)):
        current = 0
        for j in range(i, len(nums)):
            current += nums[j]
            max_sum = max(max_sum, current)

    return max_sum

Что происходит:

🔷выбираем начало подмассива

🔷перебираем все возможные продолжения

🔷Два цикла —> O(n²).

✅ Оптимизация — O(n)
Алгоритм Кадане.

def max_subarray(nums):
    current = max_sum = nums[0]

    for num in nums[1:]:
        current = max(num, current + num)
        max_sum = max(max_sum, current)

    return max_sum

🧠 Идея

Если текущая сумма становится хуже, чем просто новый элемент — начинаем новый подмассив.

То есть на каждом шаге решаем:

🔷продолжать текущий массив
🔷или начать новый

🐍Вопросы с собесов -> ProstoPython