🔹 Любые позиционные аргументы (*args).
Они сохраняются в exception.args (tuple).

e = Exception("error", 400)
print(e.args)  # ('error', 400)

🔹 Обычно передают строку сообщения.

🔹 В кастомных исключениях можно определить свои параметры через __init__.

Итог: можно передать любые данные, по умолчанию они попадут в .args.

⏱️ Big O Breakdown — выпуск 5

Смотри внимательно 👀

def example(nums):
    n = len(nums)
    i = 0

    while i < n:
        j = 0
        while j < n:
            print(i, j)
            j += 1
        i += n

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

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

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

🧠 Почему так:

🔷Внешний цикл увеличивает i на n

🔷Значит он выполняется всего один раз

🔷Внутренний цикл проходит n раз

Итого: n операций —> O(n)

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

Docker Volume

🔹 Volume — механизм хранения данных вне контейнера.

🔹 Зачем нужен

🔹 Данные сохраняются при удалении контейнера
🔹 Можно шарить данные между контейнерами
🔹 Подходит для БД, логов, загрузок

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

Десериализация — процесс преобразования данных из внешнего формата (JSON, XML, bytes) в объекты программы.

🔹 Где используется

🔹 HTTP-запросы (body —> объект)
🔹 Работа с файлами
🔹 Очереди сообщений
🔹 Кэш

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

💬 Вопрос на собесе:
Что произойдёт, если изменить список во время итерирования по нему?

👶 Junior:
— Ну… наверное просто добавится элемент?

🧑‍💻 Middle:
— Если менять список во время обхода, можно пропустить элементы или получить странное поведение.

🧙‍♂️ Senior:
— Важно понимать механизм.

Python итерируется по индексам.
Если ты удаляешь элементы, индексы сдвигаются.
Цикл продолжает увеличивать индекс, и часть элементов может быть пропущена.

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

DELETE

🔹 DML-операция
🔹 Удаляет строки с возможностью WHERE
🔹 Логирует удаление каждой строки
🔹 Можно откатить (в транзакции)
🔹 Триггеры срабатывают

TRUNCATE

🔹 DDL-операция
🔹 Удаляет все строки (без WHERE)
🔹 Быстро — очищает страницы таблицы
🔹 Обычно сбрасывает автоинкремент
🔹 В большинстве СУБД можно откатить (например, в PostgreSQL)
🔹 Триггеры не срабатывают (кроме специальных)

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

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

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

✅ Правильный ответ: [1] [1, 2]

🧠 Почему так:

🔷 lst=[] создаётся один раз при объявлении функции

🔷 += для списка изменяет объект на месте

🔷 Первый вызов —> [1]

🔷 Второй вызов использует тот же список —> [1, 2]

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

⏱️ Big O Breakdown — выпуск 5

Смотри на код 👀

def has_duplicates(nums):
    for num in nums:
        if num in nums:
            return True
    return False

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

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

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

🧠 Почему так:

🔷Внешний цикл проходит n раз

🔷Оператор in для списка работает за O(n)

🔷Внутри каждого прохода выполняется линейный поиск

Итого: n * n = n²

Даже если функция вернёт результат рано,
в худшем случае это всё равно O(n²).

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

🔹 Через super()

class Base:
    def greet(self):
        print("Hello")

class Child(Base):
    def greet(self):
        super().greet()
        print("World")

🔹 super() возвращает прокси к родительскому классу
🔹 Корректно работает при множественном наследовании

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

💬 Вопрос на собесе:
В чём разница между shallow copy и deep copy?

👶 Junior:
— Ну… shallow это обычная копия, а deep типа полная? 🤔

🧑‍💻 Middle:
Shallow copy копирует только внешний объект.
Вложенные объекты остаются теми же самыми в памяти.

Deep copy копирует всё рекурсивно, включая вложенные структуры.

🧙‍♂️ Senior:
— Главное в ссылках и памяти.

🔹 Shallow copy создаёт новый контейнер, но элементы внутри него — те же объекты.

🔹 Если внутри есть изменяемые структуры, их изменение затронет обе копии.

🔹 Deep copy создаёт полностью независимую структуру.

Пример:

import copy

a = [[1, 2], [3, 4]]
b = copy.copy(a)
c = copy.deepcopy(a)

a[0].append(99)

print(b)  # изменится
print(c)  # останется прежним

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

RESTful — API, спроектированное по принципам REST (архитектурный стиль для HTTP).

🔹 Базовые принципы

🔹 Ресурсы вместо действий
/users/1 — ресурс, а не getUser

🔹 HTTP-методы по назначению

GET — получить

POST — создать

PUT / PATCH — обновить

DELETE — удалить

🔹 Stateless — сервер не хранит состояние клиента

🔹 Корректные HTTP-статусы (200, 201, 404, 400)

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

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

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

Правильный ответ: [2, 2, 2]

💡 Почему так:

🔹Лямбда-функции захватывают переменную, а не её текущее значение.

🔹К моменту вызова f(), цикл уже завершился, и i = 2.

🔹Все три лямбды возвращают одно и то же текущее значение i.

Как сделать правильно:

funcs = []

for i in range(3):
    funcs.append(lambda i=i: i)  # фиксируем текущее значение

print([f() for f in funcs])  # [0, 1, 2] ✅

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

❌ Rookie Mistakes
Тема: except: без указания ошибки

❌ Плохо:

try:
    result = 10 / x
except:
    print("Ошибка")

Работает? Да.
Правильно? Нет.

Ты перехватываешь вообще всё — даже KeyboardInterrupt и системные ошибки.

✅ Правильно:

try:
    result = 10 / x
except ZeroDivisionError:
    print("Деление на ноль")

или если нужно шире:

except Exception as e:
    print(f"Ошибка: {e}")

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

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

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

⏱️ Big O Breakdown

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

def find_power(n):
    count = 0
    while n > 1:
        n //= 2
        count += 1
    return count

❓ Какая асимптотическая сложность?

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

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

🧠 Почему так:

На каждой итерации n делится на 2.

Если n = 1024:

1024 —> 512 —> 256 —> 128 —> 64 —> 32 —> 16 —> 8 —> 4 —> 2 —> 1

Сколько шагов?
Ровно столько, сколько раз можно делить число на 2.

Это и есть логарифм по основанию 2.

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

Celery — инструмент для выполнения фоновых и распределённых задач в Python.

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

🔹 Отправка email
🔹 Обработка файлов (PDF, изображения, видео)
🔹 Долгие вычисления (отчёты, агрегации)
🔹 Интеграции с внешними API
🔹 Отложенные задачи (countdown, eta)
🔹 Периодические задачи (через Celery Beat)

Архитектурные задачи

🔹 Разгрузка HTTP-сервера
🔹 Горизонтальное масштабирование
🔹 Асинхронная обработка событий
🔹 Построение event-driven архитектуры

Когда использовать

🔹 Если задача выполняется долго
🔹 Если её не нужно выполнять синхронно в запросе
🔹 Если важна повторная попытка (retry) при ошибке

Итог:
Celery используется для фоновой, асинхронной и распределённой обработки задач вне HTTP-запроса.

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

⏱️ Big O Breakdown

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

def check_keys(d, keys):
    for key in keys:
        if key in d:
            print("Found")

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

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

(где n — количество элементов в keys)

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

🧠 Разбираем:

Проверка key in d для словаря в среднем — O(1)
Потому что dict основан на хеш-таблице.

Цикл проходит по keys —> n раз.

Итого:
n × O(1) = O(n)

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

❌ Rookie Mistakes
Тема: += и неожиданная мутация

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

def add_item(item, items=[]):
    items += [item]
    return items

print(add_item(1))
print(add_item(2))

Многие думают, что += создаёт новый список.
Но результат будет:

[1]
[1, 2]

🧠 В чём ошибка?

items += [item] для списка — это in-place изменение.
Объект не создаётся заново.
И аргумент по умолчанию items=[] создаётся один раз при определении функции.

То есть список сохраняется между вызовами.

Новички думают:
+= это почти как items = items + [item]

Но это разные операции.

items = items + [item]   # создаёт новый объект
items += [item]          # изменяет существующий

✅ Правильный вариант:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

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