🔹 Через 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

🧰 Code Cleanup — 25
Тема: двойной проход там, где можно за один

Иногда код выглядит аккуратно…
Но делает лишнюю работу.

❌ Плохо:

def get_active_users(users):
    active = [u for u in users if u.is_active]
    return len(active)

Работает? Да.
Оптимально? Не совсем.

Ты создаёшь целый список,
хотя тебе нужно только количество.

✅ Code Cleanup:

def get_active_users(users):
    return sum(1 for u in users if u.is_active)

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

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

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

Static method — метод класса, который не получает self и cls.
Он логически относится к классу, но не зависит от его состояния.

Зачем нужен

🔹 Группировка утилитарной логики внутри класса
🔹 Семантическая связь функции с доменом класса
🔹 Избежание создания экземпляра

Пример

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

MathUtils.add(2, 3)

Метод не использует атрибуты класса или объекта

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

⏱️ Big O Breakdown

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

def has_divisor(n):
    i = 1
    while i * i <= n:
        if n % i == 0:
            return True
        i += 1
    return False

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

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

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

🧠 Разбираем:

Цикл работает, пока i * i <= n.

Это значит:
i растёт до √n.

Если n = 1 000 000
то i дойдёт примерно до 1000.

Не до n.
Не до n/2.
А именно до √n.

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

🧰 Code Cleanup — выпуск 26
Тема: лишний флаг в логике

Иногда код усложняют переменной-флагом, без которой можно обойтись.

❌ Плохо:

def has_negative(nums):
    found = False
    for n in nums:
        if n < 0:
            found = True
    return found

Работает? Да.
Но читается тяжелее, чем должен.

✅ Code Cleanup:

def has_negative(nums):
    for n in nums:
        if n < 0:
            return True
    return False

Или ещё чище:

def has_negative(nums):
    return any(n < 0 for n in nums)

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

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

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

❌ Rookie Mistakes
Тема: путаница с изменяемыми объектами при умножении списка

Перед тобой такой код:

matrix = [[0] * 3] * 3

matrix[0][0] = 1

print(matrix)

Большинство ожидает:

[[1, 0, 0],
 [0, 0, 0],
 [0, 0, 0]]

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

[[1, 0, 0],
 [1, 0, 0],
 [1, 0, 0]]

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

[[0] * 3] * 3
не создаёт три независимых списка.

Он создаёт один список
и три ссылки на него.

Ты меняешь один элемент
и изменения отражаются во всех строках.

✅ Правильный способ:

matrix = [[0] * 3 for _ in range(3)]
matrix[0][0] = 1
print(matrix)

Теперь каждая строка — отдельный объект

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

Новая рубрика — 🧠 Interview Thinking

Здесь мы разбираем не просто задачи, а ход мыслей на собеседовании.
Как начинает рассуждать junior.
Как усиливает решение strong middle.
И какие сигналы интервьюер считывает во время ответа.

Код можно выучить.
А вот умение мыслить вслух, анализировать и улучшать своё решение — это уже уровень.

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

Хочется, чтобы ты выходил на собес спокойным и уверенным в себе 🐍

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

🧠 Interview Thinking — выпуск 1

Тема: «Как найти цикл в связном списке?»

💬 Задача с собеса:
Дан head односвязного списка. Нужно определить, есть ли в нём цикл.

👶 Junior думает так:

«Буду сохранять все посещённые узлы в set.
Если узел уже встречался — значит цикл».

Работает? Да.
Сложность O(n).
Память O(n).

Нормально. Но не максимум.

🧑‍💻 Strong Middle думает глубже:

«Если есть цикл, можно использовать два указателя.
Один двигается на 1 шаг, второй на 2.
Если они встретятся — цикл есть».

Без дополнительной памяти.
Сложность O(n).
Память O(1).

🧠 Что реально хочет услышать интервьюер:

🔹Ты сначала предлагаешь рабочее решение

🔹Потом сам улучшаешь его

🔹Объясняешь trade-off по памяти

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

CRUD — базовые операции над данными:

🔹 Create — создание новой записи в системе
🔹 Read — получение одной или нескольких записей
🔹 Update — изменение существующей записи
🔹 Delete — удаление записи

CRUD лежит в основе:
🔹 REST API
🔹 SQL-запросов
🔹 большинства backend-приложений

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

Новая рубрика — 📈 From O(n²) to O(n) — выпуск 1

Здесь мы берём рабочий, но неоптимальный код — и делаем его быстрее.

Цель простая: научиться видеть, где алгоритм «тормозит», и прокачать алгоритмическое мышление.

💬 Задача:
Проверить, есть ли в списке дубликаты.

❌ Наивное решение:

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

Работает? Да.
Сложность? O(n²).

Два вложенных цикла.
На больших данных будет больно.

✅ Улучшаем до O(n):

def has_duplicates(nums):
    seen = set()
    for num in nums:
        if num in seen:
            return True
        seen.add(num)
    return False

Теперь:
Проверка в set — O(1)
Один проход — O(n)

Итого O(n).

🧠 Что прокачиваем в этой рубрике:

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

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

⏱️ Big O Breakdown

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

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

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

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

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

Да, не O(n log n). И вот почему 👇

🧠 Разбираем пошагово:

Первая итерация:
цикл на n операций

Вторая:
n/2

Третья:
n/4

Потом:
n/8
и так далее…

Суммарно получаем:

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

Это убывающая геометрическая прогрессия.
Её сумма стремится к 2n.

А значит итоговая сложность — O(n).

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