Q: Что такое список (list)? Как добавить и удалить элемент?

Список (list) — один из самых часто используемых типов в Python. Это упорядоченная коллекция элементов, которая поддерживает изменение «на месте».Создание спискаnums = [1, 2, 3] empty = []Добавление элементовДобавить элемент в конец списка можно с помощью append():nums = [1, 2, 3] nums.append(4) # [1, 2, 3, 4]Добавить элемент по конкретному индексу помогает insert():nums = [1, 3, 4] nums.insert(1, 2) # вставить 2 на позицию с индексом 1 # [1, 2, 3, 4]Можно также «слить» в список элементы из другого итерируемого с помощью extend():nums = [1, 2] nums.extend([3, 4]) # [1, 2, 3, 4]Удаление элементовpop() удаляет элемент по индексу (по умолчанию последний) и возвращает его:nums = [1, 2, 3] last = nums.pop() # last == 3, nums == [1, 2] first = nums.pop(0) # first == 1, nums == [2]remove() удаляет первое вхождение элемента по значению:nums = [1, 2, 2, 3] nums.remove(2) # [1, 2, 3] — удалили первое 2Оператор del может удалить элемент по индексу или срез:nums = [1, 2, 3, 4] del nums[1] # [1, 3, 4] del nums[1:3] # удалит элементы с индексами 1 и 2Фраза для собеседованияСписок — это изменяемая упорядоченная последовательность. Элементы можно добавлять через append() и insert(), а удалять через pop(), remove() или del по индексу.

Q: Что такое кортеж (tuple)? Чем он отличается от списка?

Кортеж (tuple) — это последовательность элементов, очень похожая на список, но с важным отличием: он неизменяемый.Создание кортежаpoint = (10, 20) colors = ("red", "green", "blue") empty = ()Можно создать кортеж и без круглых скобок, используя запятые:pair = 1, 2 # это тоже tupleНеизменяемостьПосле создания кортежа его нельзя менять: нельзя добавить элементы, удалить или изменить по индексу.point = (10, 20) # point[0] = 30 # так сделать нельзя, будет TypeErrorПри этом кортежи поддерживают индексирование, срезы и перебор, как списки:point = (10, 20, 30) point[0] # 10 point[-1] # 30 for value in point: print(value)Чем кортеж отличается от спискаИзменяемость. list можно изменять (добавлять, удалять элементы), tuple — нет.Назначение. Кортежи часто используют для фиксированных наборов значений (координаты, параметры конфигурации), а списки — для коллекций, которые меняются.Как ответить на собеседованииКортеж — это упорядоченная последовательность, как список, но неизменяемая. Списки используют, когда нужно менять коллекцию, а кортежи — когда набор данных фиксирован и должен оставаться постоянным.

Q: Как работают условные операторы if, elif, else?

Условные операторы в Python позволяют принимать решения в коде: выполнять один блок инструкций или другой, в зависимости от того, истинно условие или нет.Базовый синтаксисx = 5 if x > 0: print("x положительное") elif x == 0: print("x равно нулю") else: print("x отрицательное")Работает это так:если условие после if истинно, выполняется блок if, остальные блоки пропускаются;если нет, по очереди проверяются условия в elif;если ни одно условие не выполнилось, выполняется блок else (если он есть).Истинность значенийВ условии можно использовать не только явные True/False, но и любые выражения. В Python у многих объектов есть «логическое значение»:пустые коллекции ([], {}, (), set()) и пустые строки считаются ложными;0, 0.0, None — тоже ложь;всё остальное обычно считается истиной.items = [] if items: print("список не пустой") else: print("список пустой")Как ответить на собеседованииУсловный оператор в Python записывается через if, опциональные elif и else. if condition проверяет условие, при необходимости можно добавить несколько elif с другими условиями и один else на случай, когда ни одно из условий не подошло.

Question 1

Что такое Python? Чем он отличается от компилируемых языков?

Accepted Answer

Что такое Python и почему его так любят?Python — один из самых популярных языков для веб‑разработки, анализа данных, автоматизации, машинного обучения и DevOps. Он относится к высокоуровневым языкам: разработчик работает с понятными сущностями (файлы, строки, объекты, запросы), а детали работы процессора и памяти скрыты под абстракциями.Ключевые свойства Python, которые часто отмечают на собеседованиях:Читаемый, лаконичный синтаксис, который снижает порог входа.Богатая стандартная библиотека и огромная экосистема сторонних пакетов.Автоматическое управление памятью (garbage collector, счётчик ссылок), что снимает с разработчика часть рутинных задач.Интерпретируемый язык с шагом компиляцииВ источниках по подготовке к собеседованиям вопрос формулируют по‑разному: «Python — интерпретируемый или компилируемый язык?» Корректно отвечать так, чтобы показать понимание внутреннего устройства: в реализации CPython (эталонный вариант виртуальной машины Python) Python компилируется в байткод, а затем этот байткод интерпретируется виртуальной машиной Python.Когда ты запускаешь файл script.py, интерпретатор сначала создаёт байткод (обычно сохраняется как .pyc в __pycache__), а потом пошагово выполняет его. Именно поэтому в большинстве учебных материалов Python относят к интерпретируемым языкам — основной способ работы с ним через интерпретатор, а не через отдельный бинарный файл.Чем Python отличается от компилируемых языков?Если сравнить с типичными компилируемыми языками (C, C++, Rust), то разница в следующем:Где происходит перевод кода. В компилируемых языках код заранее переводится компилятором в машинный код, и результатом является исполняемый файл или библиотека. В Python же основная работа происходит во время запуска: интерпретатор сам компилирует исходный код в байткод и тут же интерпретирует его, без явного шага «сборки» для разработчика.Скорость выполнения. Машинный код, полученный компилятором C/C++, как правило, выполняется быстрее, чем байткод, который обрабатывает виртуальная машина. Поэтому на собеседованиях могут спрашивать, как ты компенсируешь это в backend‑разработке на Python: за счёт архитектуры, вынесения тяжёлых вычислений в нативные библиотеки, кэширования и горизонтального масштабирования.Скорость разработки и отладки. В Python проще цикл «написал → запустил → изменил»: нет отдельного явного этапа линковки и сборки, быстро видны ошибки и результат. Это ценят работодатели, Python часто выбирают там, где важна скорость вывода продукта на рынок.Портируемость. В компилируемых языках исполняемый бинарный файл обычно собирается под конкретную платформу. В Python тот же исходный код запускается на разных ОС при наличии нужной версии интерпретатора, что удобно для кроссплатформенных backend‑систем.На собеседованиях, как правило, именно эти акценты и ожидают услышать: понимание не только того, что «Python интерпретируемый», но и как именно он исполняется и чем это отличается от классической модели компиляции.

Question 2

В чём разница между list и tuple?

Accepted Answer

Главное различие: изменяемость. И list, и tuple — это последовательности: они хранят элементы по порядку, поддерживают индексацию, срезы и перебор в цикле. Но принципиальное отличие одно:Список (list) изменяемый (mutable).Можно менять существующие элементы, добавлять новые, удалять старые (методы append, extend, insert, remove, pop);Присвоение по индексу items[0] = ...;Изменение части списка срезом items[1:3] = [...].Кортеж (tuple) неизменяемый (immutable).После создания кортеж нельзя изменить;нельзя присвоить t[0] = ...;нельзя удалить элемент del t[0];Любые «изменения» на самом деле создают новый кортеж. Именно этот аспект — изменяемость — чаще всего ожидают услышать первым в ответе на собеседовании.Есть и другие отличия, которые стоит упомянуть. Когда рекрутер уточняет: «А кроме изменяемости что-то ещё?», полезно назвать ещё несколько моментов.Сценарии использованияlist логично использовать для коллекций, которые меняются, фильтруются, сортируются — например, список пользователей, задачи в очереди, результаты выборки из базы. tuple хорошо подходит для фиксированных структур: координата (x, y), дата (год, месяц, день), результат функции, возвращающей сразу несколько значений.Методы и операцииУ списков больше методов для изменения содержимого (append, sort, reverse и т.п.). У кортежей набор методов минимален, так как их изменять нельзя.Производительность и памятьКортежи, как правило, занимают немного меньше памяти и могут итерироваться чуть быстрее за счёт своей неизменяемости. На уровне собеседования достаточно упомянуть, что tuple — более «лёгкая» структура для постоянных данных, а list — более гибкая, но эта гибкость дается немного большей ценой в виде затрат памяти и скорости работы.Сильный ответ может звучать так:Оба типа — упорядоченные последовательности, но список — изменяемый, а кортеж — нет. Список используют там, где данные нужно добавлять, удалять или обновлять, кортеж — для фиксированных наборов, например, возврат нескольких значений из функции. Кортежи обычно немного легче по памяти и безопаснее, потому что их нельзя случайно поменять.

Question 3

Что такое PEP 8?

Accepted Answer

PEP 8 — это документ из серии PEP (Python Enhancement Proposal), в котором описано, как правильно оформлять код на Python: какие отступы использовать, как называть переменные, где ставить пробелы, как разбивать длинные строки и как писать импорты. Он не меняет поведение языка, а задаёт «правила хорошего тона» — что‑то вроде орфографии и пунктуации, только для Python‑кода. Следование PEP 8 повышает читаемость, упрощает совместную разработку и часто является негласным требованием к коду в командах.На собеседовании обычно ожидают, что кандидат назовёт несколько ключевых принципов:Отступы: 4 пробела на уровень вложенности, табы не используются.Длина строки: рекомендуется не более 79 символов для кода и около 72–79 для комментариев и docstring’ов.Именование:переменные и функции — snake_case (строчные буквы с подчёркиваниями);классы — CamelCase;константы — UPPER_SNAKE_CASE.Пробелы: нет пробелов вокруг скобок вызова функции, нет лишних пробелов перед запятыми и двоеточиями, по одному пробелу вокруг бинарных операторов (=, +, == и т.д.).Пустые строки: две пустых строки между верхнеуровневыми функциями и классами, одна пустая строка между методами внутри класса.Импорты: сначала стандартная библиотека, затем сторонние пакеты, затем локальные модули; внутри группы — по алфавиту; каждый импорт — отдельной строкой.Всё это проверяют и автоматически: flake8, black, isort и другие инструменты форматирования ориентируются на PEP 8.Как об этом рассказать на собеседованииPEP 8 — это официальный стиль‑гайд Python, набор рекомендаций по оформлению кода. Он определяет отступы, максимальную длину строки, правила именования переменных, функций и классов, использование пробелов и порядок импортов. Соблюдение PEP 8 делает код единообразным и читаемым, а большинство линтеров и форматтеров ориентируются именно на него.

Question 4

Как писать комментарии и docstrings?

Accepted Answer

Комментарии в Python начинаются с символа # и продолжаются до конца строки. Интерпретатор их игнорирует, они нужны только людям, читающим код.Основные принципы написания комментариев:Комментарий должен объяснять зачем написан данный код, а не повторять то, что и так видно из кода.\Строка комментария начинается с # и пробела, написана как связное предложение с заглавной буквы.Длина строки комментария — до ~72 символов, чтобы текст удобно читался в редакторах и терминалах.Примеры:# Пересчитываем баланс с учетом отменённых транзакций
balance = calculate_balance(transactions)
x = x + 1  # Компенсируем погрешность округленияНе стоит писать очевидное:i = 0  # устанавливаем i в ноль  # лишний комментарийТакие практики мы сразу внедряем в учебных проектах TeoBrain: студенты учатся писать комментарии там, где они реально помогают следующему разработчику.Docstrings: документация прямо в кодеDocstring — это строковый литерал в тройных кавычках """...""" (или '''...'''), который находится сразу после объявления модуля, функции, класса или метода.Пример для функции:def send_email(to, subject, body):
   """Send email message to specified recipient.
   Parameters:
       to (str): Recipient email address.
       subject (str): Email subject line.
       body (str): Plain text message body.
   """
   ...Docstring отвечает на вопрос что в целом делает объект, а не как это пошагово реализовано. Его можно увидеть при вызове функции интерактивной помощи (help(send_email)) или через атрибут __doc__, поэтому он является частью публичного интерфейса. PEP 8 рекомендует писать docstring’и для всех публичных модулей, классов, функций и методов. PEP 257 описывает структуру:Однострочный docstring — краткая фраза, заканчивающаяся точкой.Многострочный — первая строка‑резюме, затем пустая строка и более подробное описание, включая параметры, возвращаемые значения, возможные исключения.Это критически важно для больших backend‑проектов: docstring’и используются генераторами документации, IDE и коллегами, которые читают ваш код.Комментарии и docstring’и: когда что использовать?Docstring описывает интерфейс: модуль, функцию, класс, метод — что делает, какие аргументы принимает, что возвращает, какие есть ограничения и побочные эффекты. Комментарий поясняет конкретный участок реализации, если из кода это неочевидно: почему выбран такой алгоритм, какие есть особенности, временные обходные решения. Публичные функции и классы обязательно снабжаются docstring, сложная логика внутри — при необходимости дополняется комментариями.

Question 5

Что такое with (контекстный менеджер)?

Accepted Answer

Контекстный менеджер — это объект, который умеет настраивать некоторый контекст перед выполнением блока кода и гарантированно его «убирать» после, независимо от того, завершился блок успешно или с исключением. Конструкция with как раз и используется для работы с такими объектами:with open("data.txt") as f:
   contents = f.read()
# здесь файл уже закрытВ этом примере при входе в блок with у объекта файла вызывается __enter__, возвращаемое значение попадает в переменную f; при выходе (даже если read() бросит исключение) будет вызван __exit__, который закроет файл. with — это «синтаксический сахар» над типичной конструкцией try/finally, упрощающий правильную работу с ресурсами.Как это выглядит внутри? Любой объект можно сделать контекстным менеджером, реализовав два метода:class MyContext:
   def __enter__(self):
       # код при входе в контекст (настройка ресурса)
       return self  # то, что попадёт в переменную после as
   def __exit__(self, exc_type, exc_val, exc_tb):
       # код при выходе (освобождение ресурса, логирование и т.п.)
       # вернуть True, чтобы «поглотить» исключение, или False/None, чтобы пробросить
       ...Использование:with MyContext() as ctx:
   # код внутри контекста
   ...На собеседовании обычно достаточно сказать, что контекстный менеджер — это объект с методами __enter__ и __exit__, а with гарантирует вызов __exit__ при выходе из блока.Практические примеры использования withТипичные сценарии использования контекстного менеджера, о которых полезно упомянуть:Работа с файлами:with open("log.txt", "a") as log_file:
   log_file.write("New event
")
# файл закрыт автоматическиБлокировки и потоки:from threading import Lock
lock = Lock()
with lock:
   # критическая секция
   ...Временное изменение окружения, таймеры и т.п.import time
class Timer:
   def __enter__(self):
       self.start = time.time()
       return self
   def __exit__(self, exc_type, exc_val, exc_tb):
       self.end = time.time()
       print(f"Elapsed: {self.end - self.start:.3f}s")
with Timer():
   do_something()Такие примеры часто спрашивают на интервью, чтобы проверить, понимаете ли вы идею «автоматической уборки».

Question 6

Что такое исключения? Как работает try / except / finally?

Accepted Answer

Во время работы программы могут происходить ситуации, при которых обычное выполнение кода невозможно (деление на ноль, неверный индекс, ошибки ввода‑вывода и т.д.). Вместо немедленного «падения» Python создаёт объект‑исключение и поднимает его (raise). Если исключение не перехватить, программа завершится с ошибкой (трассировкой стека). Если перехватить — можно аккуратно обработать ошибку: вывести сообщение, вернуть заглушку, записать лог и продолжить выполнение.Как работает try / except?Блок try / except позволяет перехватывать и обрабатывать исключения:try:
   result = 10 / x
except ZeroDivisionError:
   result = None
   print("Деление на ноль недопустимо")Сначала выполняется код внутри try. Если ошибки нет — блок except пропускается. Если внутри try выброшено исключение соответствующего типа, выполнение try прерывается, и управление переходит в подходящий except. Если подходящего except нет — исключение «поднимается» дальше вверх по стеку; при отсутствии обработчика программа падает. Можно указать несколько except под разные типы ошибок или перехватывать несколько типов в одном except (Type1, Type2):.Зачем нужен finally?finally — это блок, который всегда выполняется после try/except: и когда всё прошло успешно, и когда произошло исключение, даже если внутри был return. Типичный пример — гарантированное освобождение ресурсов:file = open("data.txt")
try:
   data = file.read()
except OSError:
   print("Ошибка чтения файла")
finally:
   file.close()  # выполняется всегдаСхема здесь такова:try — «пробуем выполнить код, который может упасть»;except — «если упал именно так — обработаем»;finally — «в любом случае сделаем уборку: закроем файл, соединение с БД, освободим блокировку».В современном коде освобождение ресурсов часто делегируют контекстным менеджерам (with), но понимание try / except / finally всё равно проверяют на собеседованиях.Как ответить на собеседовании?Исключения — это механизм обработки ошибок в Python: при проблеме поднимается объект‑исключение. Блок try определяет код, где ошибка может возникнуть, в except мы перехватываем и обрабатываем конкретные типы исключений, а finally выполняется всегда и обычно используется для очистки ресурсов — закрытия файлов, соединений и т.п.

Question 7

Какие встроенные типы данных есть в Python (int, str, list, tuple, dict, set)?

Accepted Answer

В Python всё — объект, и у каждого объекта есть тип. На уровне trainee от тебя ждут, что ты уверенно назовёшь и различишь базовые встроенные типы данных.int — целые числаИспользуется для представления целых значений: счётчики, идентификаторы, количества.count = 10
user_id = 123str — строкиПоследовательность символов в одинарных или двойных кавычках, часто используется для текстов, логов, идентификаторов.name = "TeoBrain"
message = 'Hello'list — список (изменяемая последовательность)Упорядоченная коллекция элементов любого типа. Можно изменять «на месте»: добавлять, удалять, менять элементы по индексу.nums = [1, 2, 3]
nums.append(4)      # [1, 2, 3, 4]
nums[0] = 10        # [10, 2, 3, 4]tuple — кортеж (неизменяемая последовательность)Очень похож на список, но после создания изменить его нельзя. Часто используют, когда набор значений фиксирован: координаты, настройки.point = (10, 20)
user = ("id123", "Ann")dict — словарь (ключ–значение)Коллекция пар «ключ–значение», где ключи обычно строки или числа. Это один из самых используемых типов в Python, особенно в backend‑разработке (JSON‑подобные структуры).user = {"id": 1, "name": "Ann"}
user["name"]      # "Ann"
user["age"] = 30  # добавили новый ключset — множествоНеупорядоченная коллекция уникальных элементов. Удобно для удаления дублей и быстрых проверок принадлежности.nums = {1, 2, 2, 3}
# {1, 2, 3}

values = ["a", "b", "a"]
unique = set(values)  # {'a', 'b'}Как кратко ответить на собеседованииВ Python есть встроенные типы: int для целых чисел, str для строк, list — изменяемый список, tuple — неизменяемая последовательность, dict — словарь «ключ–значение», set — множество уникальных элементов. Как trainee важно не только перечислить, но и кратко пояснить, чем они отличаются и когда что использовать.

Question 8

Как работает индексирование и отрицательные индексы в Python?

Accepted Answer

Индексирование — это обращение к элементу последовательности по его позиции: obj[index]. На уровне trainee важно уверенно пользоваться индексами и понимать, как работают отрицательные индексы.Положительные индексыПервый элемент имеет индекс 0, затем 1, 2 и так далее.nums = [10, 20, 30, 40]
nums[0]  # 10
nums[1]  # 20Если обратиться к индексу за пределами диапазона, будет IndexError:nums[10]  # IndexErrorОтрицательные индексыОтрицательный индекс отсчитывается от конца последовательности.-1 — последний элемент.-2 — предпоследний.nums = [10, 20, 30, 40]
nums[-1]  # 40
nums[-2]  # 30То же работает и для строк и кортежей:text = "hello"
text[0]   # 'h'
text[-1]  # 'o'Что важно уметь сказать на собеседованииВ Python последовательности индексируются с нуля: 0 — первый элемент. Отрицательные индексы идут с конца: -1 — последний, -2 — предпоследний. Обращение к индексу вне диапазона приводит к IndexError. Умение работать с отрицательными индексами часто проверяют на простых задачках: взять последний элемент, предпоследний, «хвост» списка и т.д.

Question 9

Как работают операторы in, not in, is, is not?

Accepted Answer

Операторы in и not in — проверка принадлежностиОператоры in и not in используются, чтобы узнать, содержится ли значение внутри другой сущности: списка, кортежа, строки, множества, словаря и т.п.x in s возвращает True, если x является элементом s (или ключом для словаря).x not in s возвращает True, если x не содержится в s.Примеры:numbers = [1, 2, 3]
3 in numbers       # True
5 in numbers       # False
5 not in numbers   # True

text = "hello"
"h" in text        # True
"x" not in text    # True

data = {"id": 1, "name": "TeoBrain"}
"id" in data       # True  (проверяются ключи словаря)
"TeoBrain" in data # FalseВажно: для словаря in проверяет именно ключи, а не значения. В реальном backend‑коде это постоянно используется при проверке наличия полей в данных запроса, конфиге или JSON‑объекте.Операторы is и is not — проверка тождестваis и is not — это операторы тождественности (identity). Они отвечают на вопрос: «Эти две переменные указывают на один и тот же объект в памяти или нет?»x is y — True, если x и y ссылаются на один и тот же объект.x is not y — True, если это разные объекты.Пример:a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b   # True  (значения равны)
a is b   # False (разные объекты)
a is c   # True  (это один и тот же объект)
a is not b  # TrueНа практике is чаще всего используют для сравнения с None (рекомендация стиля):value = None
if value is None:
    ...Именно это ожидают услышать интервьюеры, когда спрашивают про разницу == и is.Как не перепутать операторы на собеседованииКраткое правило, которое уместно проговорить: для проверки принадлежности в коллекции — in/not in. Для проверки тождества (один и тот же объект) — is/is not. Для проверки равенства значений — ==, а не is. Типичная ошибка: использование is вместо == для чисел и строк — это может «случайно» сработать из‑за внутренних оптимизаций, но считается неправильной практикой.

Question 10

Что такое функция? Как объявить функцию с параметрами по умолчанию?

Accepted Answer

Что такое функция в PythonФункция — это переиспользуемый блок кода, у которого есть имя, список параметров и тело. Ты определяешь функцию один раз с помощью def, а вызывать можешь сколько угодно раз с разными аргументами.def greet(name):
    print(f"Hello, {name}!")

greet("Ann")
greet("Max")Функции помогают не дублировать код, упрощают тестирование и делают программу понятнее.Параметры по умолчаниюВ Python ты можешь задать значения по умолчанию для параметров прямо в объявлении функции. Тогда при вызове эти аргументы можно не передавать — будет использовано значение по умолчанию.def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Ann")                 # Hello, Ann!
greet("Max", greeting="Hi")  # Hi, Max!Значения по умолчанию вычисляются один раз — в момент определения функции. На trainee‑уровне достаточно понимать, как ими пользоваться и не использовать изменяемые объекты (list, dict) в качестве дефолтов.Как ответить на собеседованииФункция в Python объявляется через def и представляет собой именованный блок кода, который можно вызывать многократно. Параметры по умолчанию задаются прямо в сигнатуре с помощью =, например def func(x, y=10): .... Если при вызове не передать y, будет использовано значение 10.

Question 11

Что такое lambda‑функция?

Accepted Answer

Lambda‑функция (или анонимная функция) — это функция без имени, определяемая выражением вида:lambda параметры: выражениеТакое выражение создаёт объект функции; при вызове он вычисляет указанное выражение и возвращает его результат. Пример простейшей lambda‑функции:square = lambda x: x * x
square(5)  # 25По сути это эквивалентно:def square(x):
    return x * xРазница не в «типе функции», а в формате записи: lambda — краткая запись одноразовой функции.Основные свойства, которые важно озвучить на собеседовании:Анонимность. Lambda‑функция часто передаётся сразу как аргумент другой функции, без предварительного объявления по имени.Одно выражение. Внутри lambda нельзя писать несколько операторов, циклы и return; допускается только одно выражение, результат которого возвращается автоматически.Компактность. Удобна, когда полноценный def выглядит избыточно.Где lambda‑функции применяются на практике?Классические примеры:В сортировке (ключ сортировки):users = [
    {"name": "Анна", "age": 30},
    {"name": "Олег", "age": 25},
]
# сортируем по возрасту
sorted_users = sorted(users, key=lambda u: u["age"])В map, filter, sorted и других функциях высшего порядка:numbers = [1, 2, 3, 4]
# возвести все числа в квадрат
squares = list(map(lambda x: x * x, numbers))
# оставить только чётные
evens = list(filter(lambda x: x % 2 == 0, numbers))Вместо небольших одноразовых функций‑заглушек (например, в конфигурации):handlers = {
    "ping": lambda: "pong",
}Lambda против обычной функции — что сказать на собеседованииLambda‑функция определяется через lambda, обычно без имени, может содержать только одно выражение и используется для коротких операций «на месте».Обычная функция, объявленная через def, имеет имя, может содержать несколько строк кода, условия, циклы и подходит для любой нетривиальной логики и повторного использования.

Question 12

Как устроено управление памятью в Python (приватная куча, GC)?

Accepted Answer

При создании объектов (числа, строки, списки, свои классы) память под них берётся не напрямую у операционной системы, а из специальной области — приватной кучи Python. Это внутренняя область памяти, в которой живут все Python‑объекты и структуры данных.Ей управляет Python memory manager: он отвечает за выделение, перераспределение и освобождение памяти. Разработчик на уровне обычного Python‑кода не управляет напрямую кучей (нет malloc/free), он работает только с объектами, а интерпретатор делает всё остальное. На собеседовании достаточно сказать, что «объекты хранятся в приватной куче, которой управляет интерпретатор, а не мы».Подсчёт ссылокОсновной механизм управления памятью в CPython — подсчёт ссылок (reference counting). У каждого объекта есть счётчик того, сколько на него ссылается переменных и других объектов.Создаём новую ссылку → счётчик увеличивается.Удаляем ссылку или переназначаем переменную → счётчик уменьшается.Когда счётчик становится равным 0, объект уничтожается, а память освобождается.Это даёт почти немедленную очистку ненужных объектов и предсказуемое поведение — понятно, когда конкретный объект будет удалён. Но есть ограничение: подсчёт ссылок не умеет сам по себе находить циклические ссылки, когда объекты ссылаются друг на друга, но больше нигде не используются.Генерационный сборщик мусора (GC)Чтобы справиться с циклическими ссылками, Python использует генерационный сборщик мусора.Объекты разделены на поколения (0, 1, 2) по «возрасту» — чем дольше объект живёт, тем реже его проверяют.GC периодически просматривает объекты, пытаясь обнаружить циклы ссылок, которые больше недостижимы из остальной программы.Найденные «мёртвые» циклы удаляются, освобождая память.Разработчик может при необходимости взаимодействовать с GC через модуль gc (например, gc.collect()), но в обычном backend‑коде это почти никогда не требуется.Фраза для собеседованияВ Python объекты живут в приватной куче, которой управляет встроенный менеджер памяти интерпретатора. Основной механизм — подсчёт ссылок: когда на объект больше никто не ссылается, память, занятая им, освобождается. Для циклических ссылок дополнительно используется генерационный garbage collector, который периодически находит и удаляет такие «зависшие» объекты.

Question 13

Как работают циклы for и while? В чём между ними разница?

Accepted Answer

Цикл forВ Python for итерируется по элементам последовательности или любого итерируемого объекта.nums = [1, 2, 3]
for n in nums:
    print(n)Конструкция for n in nums берёт по очереди каждый элемент из nums и кладёт в переменную n, после чего выполняет тело цикла.Часто используют с range(), чтобы повторить действие фиксированное количество раз:for i in range(5):
    print(i)  # 0, 1, 2, 3, 4Цикл whilewhile выполняет блок кода, пока условие остаётся истинным.count = 0
while count < 3:
    print(count)
    count += 1Здесь цикл завершится, когда count станет равен 3. Важно не забывать изменять переменные в условии, иначе можно получить бесконечный цикл.Разница в использованииfor удобен, когда ты итерируешься по уже известной коллекции или диапазону: списки, строки, range, результат enumerate и т.д.while удобен, когда заранее неизвестно количество повторов, и нужно «крутиться, пока условие истинно» — например, читать данные, пока они приходят, или ждать определённого состояния.Как кратко ответить на собеседованииВ Python for перебирает элементы итерируемого объекта (for item in iterable) и выполняет блок для каждого элемента. while выполняет блок, пока условие истинно (while condition). Обычно for используют, когда есть последовательность или известное число итераций, а while — когда количество повторов заранее неизвестно и зависит от условия.

Question 14

Что такое диапазон range() и как его использовать в циклах?

Accepted Answer

Что такое range()range() создаёт объект диапазона — последовательность целых чисел, которая генерируется по мере необходимости и не хранит все числа в памяти сразу.Основные формы вызова:range(stop) — числа от 0 до stop (не включая stop).range(start, stop) — числа от start до stop (не включая).range(start, stop, step) — с шагом step (может быть отрицательным).range(5)           # 0, 1, 2, 3, 4
range(2, 5)        # 2, 3, 4
range(0, 10, 2)    # 0, 2, 4, 6, 8Использование в циклах forЧаще всего range() применяют в for, чтобы выполнить действие заданное число раз или пройтись по индексам.for i in range(3):
    print(i)
# 0
# 1
# 2С индексами списка:nums = [10, 20, 30]
for i in range(len(nums)):
    print(i, nums[i])Хотя в Python обычно предпочитают обходить элементы напрямую или через enumerate, умение пользоваться range — базовый навык.Особенности range()В Python 3 range() возвращает не список, а специальный объект диапазона, который ведёт себя как «ленивая» последовательность.Если нужен именно список чисел, можно сделать list(range(...)), но это расходует память пропорционально количеству элементов.Фраза для собеседованияФункция range() создаёт объект, представляющий последовательность целых чисел и чаще всего используется в циклах for. range(stop) даёт числа от 0 до stop не включительно, range(start, stop[, step]) — от start до stop с указанным шагом. В Python 3 это не список, а отдельный ленивый объект диапазона.

Question 15

Что такое список (list)? Как добавить и удалить элемент?

Accepted Answer

Список (list) — один из самых часто используемых типов в Python. Это упорядоченная коллекция элементов, которая поддерживает изменение «на месте».Создание спискаnums = [1, 2, 3]
empty = []Добавление элементовДобавить элемент в конец списка можно с помощью append():nums = [1, 2, 3]
nums.append(4)
# [1, 2, 3, 4]Добавить элемент по конкретному индексу помогает insert():nums = [1, 3, 4]
nums.insert(1, 2)  # вставить 2 на позицию с индексом 1
# [1, 2, 3, 4]Можно также «слить» в список элементы из другого итерируемого с помощью extend():nums = [1, 2]
nums.extend([3, 4])
# [1, 2, 3, 4]Удаление элементовpop() удаляет элемент по индексу (по умолчанию последний) и возвращает его:nums = [1, 2, 3]
last = nums.pop()     # last == 3, nums == [1, 2]
first = nums.pop(0)   # first == 1, nums == [2]remove() удаляет первое вхождение элемента по значению:nums = [1, 2, 2, 3]
nums.remove(2)
# [1, 2, 3]  — удалили первое 2Оператор del может удалить элемент по индексу или срез:nums = [1, 2, 3, 4]
del nums[1]      # [1, 3, 4]
del nums[1:3]    # удалит элементы с индексами 1 и 2Фраза для собеседованияСписок — это изменяемая упорядоченная последовательность. Элементы можно добавлять через append() и insert(), а удалять через pop(), remove() или del по индексу.

Question 16

Что такое кортеж (tuple)? Чем он отличается от списка?

Accepted Answer

Кортеж (tuple) — это последовательность элементов, очень похожая на список, но с важным отличием: он неизменяемый.Создание кортежаpoint = (10, 20)
colors = ("red", "green", "blue")
empty = ()Можно создать кортеж и без круглых скобок, используя запятые:pair = 1, 2  # это тоже tupleНеизменяемостьПосле создания кортежа его нельзя менять: нельзя добавить элементы, удалить или изменить по индексу.point = (10, 20)
# point[0] = 30  # так сделать нельзя, будет TypeErrorПри этом кортежи поддерживают индексирование, срезы и перебор, как списки:point = (10, 20, 30)
point[0]      # 10
point[-1]     # 30
for value in point:
    print(value)Чем кортеж отличается от спискаИзменяемость. list можно изменять (добавлять, удалять элементы), tuple — нет.Назначение. Кортежи часто используют для фиксированных наборов значений (координаты, параметры конфигурации), а списки — для коллекций, которые меняются.Как ответить на собеседованииКортеж — это упорядоченная последовательность, как список, но неизменяемая. Списки используют, когда нужно менять коллекцию, а кортежи — когда набор данных фиксирован и должен оставаться постоянным.

Question 17

Что такое словарь (dict)? Как работают ключи и значения?

Accepted Answer

Словарь (dict) — один из базовых контейнеров в Python, особенно важный для backend‑разработки, потому что очень похож на JSON‑структуры.Создание словаряuser = {"id": 1, "name": "Ann"}
empty = {}Можно создавать словари и через dict():user = dict(id=1, name="Ann")Ключи и значенияСловарь хранит пары «ключ–значение». Доступ к значению происходит по ключу:user = {"id": 1, "name": "Ann"}
user["name"]      # "Ann"
user["id"]        # 1Добавить или изменить значение можно простым присваиванием по ключу:user["age"] = 30         # добавили новый ключ
user["name"] = "Anna"    # изменили существующий ключТребования к ключамКлючи в словаре должны быть хешируемыми, то есть иметь фиксированное хеш‑значение и быть неизменяемыми: чаще всего это строки, числа или кортежи из неизменяемых значений.Нельзя использовать в качестве ключа изменяемые объекты, например список:# {'ok': 'yes'} — корректный словарь
# {[1, 2]: "bad"} — так нельзя, список не может быть ключомПеребор словаряuser = {"id": 1, "name": "Ann"}
for key in user:
    print(key, user[key])

for key, value in user.items():
    print(key, value)В современных версиях Python обычный dict сохраняет порядок добавления ключей, что удобно при работе с конфигами и API.Как кратко ответить на собеседованииСловарь — это структура «ключ–значение». Доступ к данным идёт по ключу, а не по индексу. Ключи должны быть хешируемыми (строки, числа, неизменяемые кортежи), значения могут быть любыми объектами. В Python 3.7+ словари сохраняют порядок вставки ключей.

Question 18

Что такое множество (set) и для чего оно нужно?

Accepted Answer

Множество (set) — это коллекция уникальных элементов без гарантированного порядка. Если добавить один и тот же элемент несколько раз, он хранится в множестве только один раз.Создание множестваnums = {1, 2, 3}
empty = set()Если создать множество из списка, дубликаты будут удалены:values = [1, 2, 2, 3]
unique = set(values)   # {1, 2, 3}Основные операцииПроверка принадлежности:if 2 in unique:
    print("есть 2")Добавление и удаление элементов:unique.add(4)
unique.remove(1)   # если элемента нет, будет KeyError
unique.discard(5)  # безопасно, не бросает ошибку, если 5 нетОперации теории множествМножества поддерживают объединение, пересечение, разность и симметрическую разность.a = {1, 2, 3}
b = {3, 4}

union = a | b         # {1, 2, 3, 4}
inter = a & b         # {3}
diff = a - b          # {1, 2}
sym_diff = a ^ b      # {1, 2, 4}Где множества полезны на практикеУдаление дублей из коллекции (например, из списка ID).Быстрые проверки «элемент уже был?» (in у множества работает быстро).Операции над группами: какие права есть, какие отсутствуют, пересечение двух наборов и т.п.Фраза для собеседованияМножество — это коллекция уникальных элементов. Оно автоматически убирает дубликаты и позволяет быстро проверять принадлежность через in, поэтому его удобно использовать для удаления повторов и логики вида «есть/нет».

Question 19

Как работают условные операторы if, elif, else?

Accepted Answer

Условные операторы в Python позволяют принимать решения в коде: выполнять один блок инструкций или другой, в зависимости от того, истинно условие или нет.Базовый синтаксисx = 5

if x > 0:
    print("x положительное")
elif x == 0:
    print("x равно нулю")
else:
    print("x отрицательное")Работает это так:если условие после if истинно, выполняется блок if, остальные блоки пропускаются;если нет, по очереди проверяются условия в elif;если ни одно условие не выполнилось, выполняется блок else (если он есть).Истинность значенийВ условии можно использовать не только явные True/False, но и любые выражения. В Python у многих объектов есть «логическое значение»:пустые коллекции ([], {}, (), set()) и пустые строки считаются ложными;0, 0.0, None — тоже ложь;всё остальное обычно считается истиной.items = []
if items:
    print("список не пустой")
else:
    print("список пустой")Как ответить на собеседованииУсловный оператор в Python записывается через if, опциональные elif и else. if condition проверяет условие, при необходимости можно добавить несколько elif с другими условиями и один else на случай, когда ни одно из условий не подошло.

Question 20

Что такое *args и **kwargs?

Accepted Answer

Иногда заранее неизвестно, сколько аргументов понадобится функции: два, три или десять. В таких случаях удобно использовать переменное число аргументов через *args и **kwargs. На собеседовании важно показать, что ты понимаешь именно идею: сделать функцию более гибкой по количеству входных параметров.Что такое *args*args в определении функции означает: «Собери все дополнительные позиционные аргументы в один кортеж».def avg(*args):
    return sum(args) / len(args)

avg(1, 2, 3)           # 2.0
avg(10, 20, 30, 40)    # 25.0Внутри функции args — обычный кортеж. Можно комбинировать обычные параметры и *args, но обычные параметры должны идти до *args:def log(prefix, *messages):
    for msg in messages:
        print(prefix, msg)

log("[INFO]", "start", "processing", "done")Что такое **kwargs**kwargs в определении функции означает: «Собери все дополнительные именованные аргументы в словарь».def create_user(**kwargs):
    return kwargs

create_user(name="Alex", age=30, role="admin")
# {'name': 'Alex', 'age': 30, 'role': 'admin'}Внутри функции kwargs — словарь, где ключи совпадают с именами аргументов. Частый сценарий в backend‑коде — проксировать эти аргументы дальше:def wrapped_request(url, **options):
    options.setdefault("timeout", 5)
    return http_request(url, **options)Совместное использование и порядок аргументовВ одной функции можно использовать и *args, и **kwargs, но порядок строгий: сначала позиционные параметры, потом *args, затем именованные параметры по умолчанию и в конце **kwargs.def handle_request(method, url, *args, retry=3, **kwargs):
    ...Как ответить на собеседовании*args и **kwargs позволяют функции принимать переменное число аргументов. *args собирает дополнительные позиционные аргументы в кортеж, а **kwargs — дополнительные именованные аргументы в словарь. Это удобно, когда заранее неизвестно, сколько параметров придёт в функцию или когда нужно прозрачно прокинуть аргументы дальше.

Question 21

Что такое списки и словари‑генераторы (list / dict comprehension)?

Accepted Answer

List comprehension и dict comprehension — это короткий, но выразительный синтаксис для создания коллекций на основе других коллекций. На собеседованиях часто дают задачи, которые можно решить и обычным циклом, и с помощью comprehension, чтобы посмотреть на твой уровень владения синтаксисом Python.Списковое включение (list comprehension)Общий вид:[expression for item in iterable if condition]Примеры:numbers = [1, 2, 3, 4]
# возвести все числа в квадрат
squares = [x * x for x in numbers]  # [1, 4, 9, 16]

# оставить только чётные
evens = [x for x in numbers if x % 2 == 0]  # [2, 4]То же самое можно записать обычным циклом for, но comprehension короче и часто читается проще, если выражение не слишком сложное.Словарное включение (dict comprehension)Общий вид:{key_expr: value_expr for item in iterable if condition}Пример: построить словарь «число → его квадрат»:numbers = [1, 2, 3]
squares = {x: x * x for x in numbers}
# {1: 1, 2: 4, 3: 9}Частый кейс в backend‑разработке — преобразование списка объектов в словарь по какому‑то ключу.users = [
    {"id": 1, "name": "Ann"},
    {"id": 2, "name": "Max"},
]
users_by_id = {u["id"]: u for u in users}Когда использовать comprehension, а когда нетХорошо подходят для простых преобразований: фильтрация, маппинг, построение словарей по ключу.Если логика слишком сложная (много условий, вложенные циклы), лучше написать обычный цикл — так код будет понятнее.Как ответить на собеседованииList и dict comprehension — это краткая форма записи циклов для построения новых коллекций. Списковое включение выглядит как [expr for x in iterable if cond], а словарное — как {k: v for x in iterable if cond]. Их используют для компактного и читаемого преобразования данных.

Question 22

Что такое модуль и пакет? Как работает import?

Accepted Answer

Чтобы не держать весь код в одном файле, Python использует модули и пакеты.МодульМодуль — это просто один .py-файл, который можно импортировать.# файл math_utils.py
def add(a, b):
    return a + bИспользование в другом файле:import math_utils

result = math_utils.add(2, 3)ПакетПакет — это каталог с модулями (и, как правило, файлом __init__.py), который образует пространство имён и может содержать подпакеты.myapp/
    __init__.py
    models.py
    views.py
    utils/
        __init__.py
        helpers.pyИмпорт из пакета:from myapp import models
from myapp.utils import helpersКак работает importКогда интерпретатор встречает import, он:ищет модуль по имени в определённых местах (стандартная библиотека, установленные пакеты, текущий проект);если модуль ещё не загружен, выполняет его код один раз и создаёт объект модуля;сохраняет объект в sys.modules, чтобы при повторных import не загружать его заново;присваивает модуль (или объекты из него) имени в текущем пространстве имён.Разные формы импорта:import math              # math.sin
from math import sin     # sin
import myapp.utils as u  # u.helpers()Как ответить на собеседованииМодуль — это отдельный Python‑файл, пакет — каталог с модулями, который образует пространство имён. Оператор import находит модуль по имени, при необходимости загружает его и привязывает к имени в текущем файле, чтобы можно было использовать его функции и классы.

Question 23

Для чего нужно условие if __name__ == "__main__"?

Accepted Answer

В каждом Python‑файле есть служебная переменная __name__, которая говорит, как этот файл был загружен. Если файл запущен напрямую как скрипт (python script.py), то __name__ в нём равно строке "__main__". Если же файл импортирован как модуль, то __name__ равно имени модуля (например, "myapp.utils").Зачем нужно if __name__ == "__main__"Конструкция:def main():
    print("Запуск основной логики")

if __name__ == "__main__":
    main()обозначает блок кода, который должен выполняться только при прямом запуске файла, но не при импорте его как модуля из другого файла.Это удобно, когда файл одновременно:содержит функции/классы, которые ты хочешь переиспользовать через import;и может запускаться как самостоятельный скрипт с «точкой входа».Пример использования# utils.py

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

if __name__ == "__main__":
    print(add(2, 3))  # этот код выполнится только при python utils.pyПри импорте import utils функция add будет доступна, но тестовый вывод внутри if __name__ == "__main__" не сработает.Как ответить на собеседованииif __name__ == "__main__" используют, чтобы отделить «точку входа» скрипта от остального кода модуля. Код внутри этого условия выполняется только при прямом запуске файла и не выполняется при импорте, что позволяет писать модули, которые можно и переиспользовать, и запускать как отдельную программу.

Question 24

Разница между is и ==?

Accepted Answer

Когда вы пишете:a == bPython спрашивает у объектов: «Вы представляете одно и то же значение?» — и вызывает под капотом метод __eq__. Поэтому:два разных списка [1, 2] и [1, 2] равны по значению;две разные строки "hi" и "hi" равны по содержимому и т.п.Когда вы пишете:a is bPython вообще не смотрит на содержимое, он сравнивает адреса объектов: «эти переменные указывают на один и тот же объект в памяти или нет?». Пример:x = [1, 2, 3]
y = [1, 2, 3]
z = x
x == y   # True  (значения совпадают)
x is y   # False (разные объекты)
x is z   # True  (это один и тот же объект)[x == y → True, x is y → False] — классика для собеседований.Почему is нельзя использовать вместо ==?Иногда is «случайно» даёт True при сравнении чисел или коротких строк — из‑за кеширования и интернирования объектов в CPython. Это деталь реализации, а не гарантированное поведение.a = 256
b = 256
a is b      # часто True, но на это нельзя опираться

a = 257
b = 257
a is b      # может быть FalseДля сравнения чисел, строк, списков, словарей и т.д. используем ==. is применяем там, где важно, один ли это объект — чаще всего это проверки is None и работа с синглтонами.Когда использовать каждый оператор?Практическое правило для собеседования: == — когда сравниваем значения (числа, строки, структуры данных),if status == "ok":
    ...а is — при проверке на None и синглтоны:if value is None:
    ...В одной фразе: == — «равны ли по смыслу», is — «это точно один и тот же объект?».

Question 25

Что такое mutable и immutable объекты?

Accepted Answer

Immutable (неизменяемый) объект — после создания его значение поменять нельзя; можно только создать новый объект и переназначить ссылку.Mutable (изменяемый) объект — его состояние можно изменять без создания нового объекта: добавлять/удалять элементы, менять содержимое.В Python всё — объект, у каждого есть тип, идентичность (адрес в памяти) и значение; именно тип решает, допускает ли он изменение значения.К встроенным неизменяемым типам (immutable) относятся:числа: int, float, complex, bool;строки: str;кортежи: tuple;неизменяемые множества: frozenset.Пример со строкой:s = "hi"
t = s
s += "!"
# s теперь указывает на НОВУЮ строку "hi!"
# t по‑прежнему указывает на "hi"Строка не меняется «внутри»: создаётся новый объект, а переменная переназначается на него.К изменяемым (mutable) встроенным типам относятся:списки: list;словари: dict;множества: set;многие пользовательские классы.Пример со списком:items = [1, 2, 3]
other = items
items.append(4)
# и items, и other теперь указывают на один и тот же список [1, 2, 3, 4]Мы изменили существующий список, новый объект не создавался; все ссылки на него видят изменения.Почему это важно в коде?Если две переменные указывают на один mutable-объект, изменения через одну переменную видны через другую. Для immutable-объектов переназначение одной переменной не затрагивает остальные ссылки — создаётся новый объект.При передаче аргументов в функции: если передать mutable (список) и менять его внутри, изменения будут видны снаружи; если передать immutable (число, строку) и «изменять» его, на самом деле вы создаёте новый объект, а внешняя переменная не меняется.def add_item(lst):
    lst.append(1)

data = []
add_item(data)
# data == [1]

def add_one(x):
    x += 1

n = 10
add_one(n)
# n по‑прежнему 10Классическая ловушка: значения по умолчаниюИз‑за изменяемости списков и словарей опасно использовать их как значения по умолчанию в параметрах функций: один и тот же список живёт между вызовами и накапливает данные.На собеседовании важно показать понимание: mutable и immutable напрямую влияют на то, как ведут себя аргументы функций, общие структуры и параметры по умолчанию.

Question 26

Что такое поверхностная и глубокая копия (shallow copy vs deep copy)?

Accepted Answer

Для изменяемых структур (списки, словари, вложенные коллекции) важно различать:простое присваивание b = a — не копия, обе переменные указывают на один и тот же объект;поверхностная копия — копируется только внешний контейнер;глубокая копия — копируется и контейнер, и все вложенные объекты.Поверхностная копия (shallow copy)При поверхностной копии создаётся новый контейнер, но его элементы — это те же объекты, что и в оригинале.Сделать shallow copy можно так:import copy

a = [[1, 2], [3, 4]]
b = a.copy()         # для списка
# или
b = list(a)
# или
b = copy.copy(a)Поведение:a = [[1, 2], [3, 4]]
b = a.copy()

b[0][0] = 99
print(a)  # [[99, 2], [3, 4]]
print(b)  # [[99, 2], [3, 4]]Мы создали новый список b, но вложенные списки те же самые, поэтому изменение вложенного элемента отражается и в a.Если заменить элемент верхнего уровня, ситуация другая:a = [[1, 2], [3, 4]]
b = a.copy()

b[0] = [99, 2]
print(a)  # [[1, 2], [3, 4]]
print(b)  # [[99, 2], [3, 4]]Здесь мы подменили ссылку в b[0] на новый список — оригинал не изменился.Глубокая копия (deep copy)При глубокой копии создаётся новый контейнер и рекурсивные копии всех вложенных объектов — копия полностью независима.import copy

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

c[0][0] = 99
print(a)  # [[1, 2], [3, 4]]
print(c)  # [[99, 2], [3, 4]]Изменения в c не затрагивают a, потому что вложенные списки тоже были скопированы.Формулировка для собеседованияПоверхностная копия создаёт новый контейнер, но вложенные объекты остаются общими — копируются только ссылки, поэтому изменение вложенных элементов видно и в оригинале. Глубокая копия рекурсивно копирует всю структуру, и получившаяся копия полностью независима: изменения в ней не влияют на исходные данные.

Question 27

Как работают list comprehension, dict comprehension, set comprehension?

Accepted Answer

Идея comprehensionComprehension заменяет цикл с ручным append() / добавлением в коллекцию на одно выражение.Базовые формы:# list comprehension
[expr for item in iterable if condition]

# set comprehension
{expr for item in iterable if condition}

# dict comprehension
{key_expr: value_expr for item in iterable if condition}Это делает код короче и явнее показывает, что мы строим новую коллекцию из другой.List comprehensionСоздаёт новый список, проходится по итерируемому объекту и применяет выражение к каждому элементу, опционально фильтруя по условию.nums = [1, 2, 3, 4, 5, 6]

squares = [x * x for x in nums if x % 2 == 0]
# [4, 16, 36]Эквивалентно коду с циклом:squares = []
for x in nums:
    if x % 2 == 0:
        squares.append(x * x)Set comprehensionСоздаёт множество (уникальные значения) по аналогичному принципу:words = ["apple", "Apple", "banana", "banana", "pear"]
unique = {w.lower() for w in words}
# {'apple', 'banana', 'pear'}Удобно, когда нужно убрать дубликаты и параллельно преобразовать значения.Dict comprehensionСоздаёт словарь, формируя пары «ключ–значение» прямо в выражении:nums = [1, 2, 3, 4]

squares = {n: n * n for n in nums}
# {1: 1, 2: 4, 3: 9, 4: 16}С фильтрацией:data = {"a": 1, "b": 0, "c": 3}
non_zero = {k: v for k, v in data.items() if v != 0}
# {'a': 1, 'c': 3}Фраза для собеседованияComprehension — это краткий синтаксис создания коллекций. list comprehension строит список [expr for item in iterable if cond], dict comprehension — словарь {k: v for ... if ...}, set comprehension — множество {expr for ... if ...}. Они заменяют циклы с накоплением и делают код короче и читаемее.

Question 28

Что такое генераторы и yield? Чем они отличаются от итераторов?

Accepted Answer

Что такое итераторИтератор — это объект, который возвращает элементы по одному при вызове next() и «знает», где он сейчас в последовательности.Формально итератор реализует два метода:__iter__(), возвращающий сам итератор;__next__(), который возвращает очередное значение или выбрасывает StopIteration, когда значения закончились.Пример простого итератора:class CountDown:
    def __init__(self, start):
        self.current = start

def __iter__(self):
        return self

def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

for n in CountDown(3):
    print(n)  # 3, 2, 1Класс явно хранит состояние и реализует протокол итератора.Что такое генератор и yieldГенератор — это функция (или выражение), которая использует yield и при вызове возвращает объект‑генератор, то есть специальный итератор.def countdown(start):
    while start > 0:
        yield start
        start -= 1

for n in countdown(3):
    print(n)  # 3, 2, 1Особенности yield:При первом next() код выполняется до первого yield, возвращает значение и «замораживает» состояние функции.Следующий next() продолжает выполнение сразу после yield, сохраняя локальные переменные.Когда функция доходит до конца или до return, выбрасывается StopIteration.То есть генератор хранит своё состояние внутри функции, без явной реализации __next__ и __iter__ вручную.Чем генератор отличается от «обычного» итератораСпособ создания. Обычный итератор чаще реализуют как класс с методами __iter__ и __next__. Генератор создаётся функцией с yield или генераторным выражением (expr for ... in ...).Объём кода. В генераторе не нужно самому хранить и обновлять состояние — всё делает интерпретатор. Код получается короче и проще.Отношение между понятиямиВсе генераторы — итераторы: у них есть __iter__ и __next__. Не все итераторы — генераторы: их можно писать классами без yield.Память и ленивостьИ генераторы, и итераторы обычно отдают значения по одному (лениво), не держа всю последовательность в памяти. Генераторы особенно удобны для больших/бесконечных последовательностей: чтение файла построчно, поток событий, последовательная обработка данных.Фраза для собеседованияИтератор — это объект с __iter__ и __next__, который отдаёт элементы по одному и в конце бросает StopIteration. Генератор — это частный случай итератора, который создаётся функцией с yield и автоматически хранит своё состояние между вызовами next(). Генераторы позволяют писать итераторы в виде простой функции вместо отдельного класса.

Question 29

Как работают декораторы? Можно ли навешивать несколько декораторов на одну функцию?

Accepted Answer

Базовая идея декоратора: «взять готовую функцию и добавить к ней поведение, не меняя её исходный код».def log_call(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} finished")
        return result
    return wrapper

@log_call
def process_order(order_id):
    print(f"Processing {order_id}")Строка @log_call эквивалентна записи:process_order = log_call(process_order)То есть декоратор:принимает исходную функцию func;создаёт wrapper, который вызывает func и добавляет нужную логику до/после/вокруг вызова;возвращает wrapper вместо оригинальной функции.В backend‑коде через декораторы часто делают логирование, кеширование, авторизацию, ретраи и т.п.Можно ли навешивать несколько декораторов?Да, можно. Python позволяет «сложить» несколько декораторов над одной функцией:@auth_required
@log_call
def get_user_profile(user_id):
    ...

# Эквивалентно:
def get_user_profile(user_id):
    ...

get_user_profile = auth_required(log_call(get_user_profile))Порядок такой: сначала log_call оборачивает исходную функцию, потом auth_required оборачивает результат log_call.Порядок применения и выполненияВажно различать две вещи:Применение при определении: декораторы применяются снизу вверх (от ближайшего к функции к самому верхнему).Выполнение при вызове: работают как матрёшка — сначала вызывается внешний декоратор (верхний в списке), затем внутренний, и в конце — сама функция.def deco1(func):
    def wrapper(*args, **kwargs):
        print("deco1 before")
        result = func(*args, **kwargs)
        print("deco1 after")
        return result
    return wrapper

def deco2(func):
    def wrapper(*args, **kwargs):
        print("deco2 before")
        result = func(*args, **kwargs)
        print("deco2 after")
        return result
    return wrapper

@deco1
@deco2
def f():
    print("func")

f()Вывод будет:deco1 before
deco2 before
func
deco2 after
deco1 afterЗдесь deco2 ближе к функции, а deco1 — внешняя обёртка.Фраза для собеседованияДекоратор — это функция, которая принимает другую функцию и возвращает обёртку с дополнительной логикой. Несколько декораторов работают как вложенные обёртки: применяются снизу вверх, а вызываются как матрёшка — сначала внешний декоратор, потом внутренний и в конце оригинальная функция.

Question 30

Разница между staticmethod и classmethod?

Accepted Answer

Ключевое отличие между staticmethod и classmethod — есть ли у метода автоматический доступ к самому классу через cls.Что такое staticmethod?Статический метод объявляется так:class User:
    @staticmethod
    def validate_email(email: str) -> bool:
        return "@" in emailСвойства staticmethod:Метод не получает self или cls автоматически — все аргументы ты передаёшь явно.Метод не может обращаться к атрибутам класса или экземпляра, если ты не передал их вручную.Логически относится к классу, но не зависит от его состояния — по сути, это обычная функция, лежащая внутри класса для удобства.Типичный пример: небольшая утилита, связанная по смыслу с доменной сущностью (валидация, простые преобразования), но не использующая состояние объекта или класса.Что такое classmethod?Классовый метод объявляется так:class User:
    users_count = 0

def __init__(self, name):
        self.name = name
        User.users_count += 1

@classmethod
    def from_full_name(cls, full_name: str) -> "User":
        first, last = full_name.split()
        return cls(f"{first} {last}")Свойства classmethod:Первым аргументом получает cls — сам класс, на котором ты вызвал метод (учитывая наследование).Может читать и изменять класс‑уровневые атрибуты (cls.users_count, cls.config и т.д.).Часто используется как альтернативный конструктор (factory method): создаёт экземпляры разными способами и при наследовании возвращает экземпляр нужного подкласса.В иерархиях моделей это важно: cls соответствует конкретному подклассу, на котором ты вызвал метод.Как кратко ответить на собеседовании@staticmethod — обычная функция внутри класса, у неё нет доступа ни к экземпляру, ни к классу, её используют для утилитарной логики, связанной с классом только по смыслу. @classmethod вместо self получает cls, то есть сам класс, может работать с класс‑уровневым состоянием и служить альтернативным конструктором, корректно учитывая наследование. Если методу нужен доступ к классу — это classmethod, если нет — staticmethod.

Question 31

Разница между __init__ и __new__?

Accepted Answer

Создание объекта в Python — это всегда двухшаговый процесс:__new__ — «стройка»: создаётся сам объект (экземпляр), выделяется память.__init__ — «обустройство»: в созданный объект записываются атрибуты и стартовые значения.Удобная аналогия: __new__ строит пустой дом, __init__ расставляет в нём мебель.__new__Метод __new__ создаёт экземпляр и вызывается до __init__. Первым аргументом он получает ссылку на класс cls и должен вернуть новый объект. В обычных классах ты его почти никогда не переопределяешь.__init__Метод __init__ инициализирует экземпляр: вызывается после __new__, первым аргументом получает self — уже созданный объект, и обычно просто заполняет его атрибуты. Всегда возвращает None.В 99% случаев ты работаешь именно с __init__:class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email

user = User("Alex", "alex@example.com")Здесь __new__ молча вызывается под капотом через object.__new__, ты его не видишь и не трогаешь.Когда реально нужен __new__Переопределять __new__ нужно в нескольких специфических случаях:1. Наследование от неизменяемых типов (int, str, tuple)Значение таких объектов задаётся при создании, а не при инициализации, поэтому управлять им можно только в __new__:class EvenInt(int):
    def __new__(cls, value):
        if value % 2 != 0:
            raise ValueError("Only even numbers allowed")
        return super().__new__(cls, value)

EvenInt(4)   # OK
EvenInt(3)   # ValueError2. Синглтон (один объект на класс)class Singleton:
    _instance = None

def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance3. Метаклассы и продвинутые паттерныКогда тебе нужно контролировать сам процесс инстанцирования на уровне метакласса.Как сформулировать на собеседовании__new__ создаёт объект и возвращает его, __init__ получает уже созданный объект и заполняет его атрибутами. Сначала вызывается __new__, затем __init__. В обычных классах ты переопределяешь только __init__, а __new__ нужен в редких случаях: при наследовании от неизменяемых типов (int, str и т.п.) и при реализации паттернов вроде синглтона.

Question 32

Что такое область видимости переменных (LEGB)?

Accepted Answer

Область видимости (scope) определяет, откуда видно имя и где ты можешь к нему обратиться. Python не «угадывает» значения, а ищет имя в нескольких пространствах имён в фиксированном порядке. Нарушение этих правил даёт ошибки вроде NameError или неожиданное перекрытие переменных.LEGB: порядок поиска имёнКогда ты обращаешься к имени, Python ищет его по схеме LEGB:Local (L) — локальная область.Имена, определённые внутри текущей функции или comprehension. Они живут от начала вызова функции до её завершения.def func():
    x = 10  # локальная переменная
    print(x)Enclosing (E) — области внешних функций.Это области видимости внешних функций для вложенных функций (замыкания).def outer():
    x = "outer"
    def inner():
        print(x)  # берёт x из enclosing-области outer
    inner()Global (G) — глобальная область модуля.Имена, определённые на верхнем уровне файла (модуля). Они доступны внутри функций модуля для чтения (если не перекрыты локальными).x = "global"

def func():
    print(x)  # если локального x нет, возьмётся глобальныйBuilt‑in (B) — встроенная область.Пространство имён со стандартными функциями и исключениями (len, print, ValueError и т.д.).Как только имя найдено на одном из уровней, поиск останавливается, внешние области дальше не проверяются.Что важно уметь сказать на собеседованииLEGB — это порядок поиска имени: сначала локальная область, потом enclosing, затем глобальная и в конце built‑in. Локальные переменные не видны снаружи функции: если попробовать обратиться к ним вне функции, ты получишь NameError.Вложенные функции видят переменные внешней функции (enclosing), но не наоборот: внешняя функция не видит локальные переменные внутренней. Глобальные переменные доступны внутри функции для чтения, но для записи нужно явно объявить global, а для изменения переменных enclosing‑области — nonlocal.В одной фразе: область видимости определяет, откуда видно имя, а Python ищет его по правилу LEGB — Local, Enclosing, Global, Built‑in.

Question 33

Что такое замыкание (closure)?

Accepted Answer

Формальное определение замыканияЧтобы в Python возникло замыкание, должны выполняться три условия:Внутри одной функции определена другая, вложенная функция.Внутренняя функция обращается к переменным внешней функции (enclosing scope).Внешняя функция возвращает внутреннюю функцию (сам объект функции), а не результат её вызова.Такая внутренняя функция «носит с собой» ссылки на переменные внешней функции и может использовать их позже, уже вне исходного контекста.Простой пример замыканияdef make_adder(x):
    def adder(y):
        return x + y
    return adder

add10 = make_adder(10)
print(add10(5))   # 15
print(add10(7))   # 17Что здесь происходит:make_adder(10) возвращает функцию adder, которая «помнит», что x = 10.Локальная переменная x во внешней функции уже не живёт в стеке, но её значение доступно через замыкание.Каждый вызов add10(y) использует сохранённое x из enclosing‑области.Так замыкание позволяет хранить состояние между вызовами функции без отдельного класса и объекта.Где замыкания полезны на практикеТипичные сценарии, про которые часто спрашивают:Функции‑фабрики (function factories). Как в примере выше: make_adder создаёт новые функции с «зашитым» параметром x.Инкапсуляция состояния. Замыкание может скрывать внутреннее состояние и давать к нему доступ только через возвращаемые функции — похоже на приватные поля в классах.Коллбеки и обработчики. Функция‑обработчик может помнить контекст, в котором её создали (настройки, параметры, текущего пользователя).Параметризованные декораторы. Декоратор с аргументами почти всегда реализуется через замыкание.Краткая формулировка для собеседованияЗамыкание — это вложенная функция, которая запоминает значения из внешней области видимости и может использовать их позже, даже когда внешняя функция уже завершилась. Условия: есть внутренняя функция, она использует переменные внешней и сама функция возвращается наружу. Это способ хранить состояние в функции без класса.

Question 34

Как работает слайсинг [start:stop:step]?

Accepted Answer

Общая схема среза start:stop:stepБазовый синтаксис слайсинга для последовательностей (списки, строки, кортежи и т.д.): seq[start:stop:step].start — индекс первого включённого элемента (по умолчанию начало последовательности).stop — индекс первого не включаемого элемента (по умолчанию конец последовательности).step — шаг, с которым берутся элементы (по умолчанию 1).Примеры:nums = [0, 1, 2, 3, 4, 5]
nums[1:4]    # [1, 2, 3]  (берём индексы 1, 2, 3; 4 не включаем)
nums[:3]     # [0, 1, 2]  (от начала до индекса 3, не включая)
nums[2:]     # [2, 3, 4, 5]  (от индекса 2 до конца)
nums[::2]    # [0, 2, 4]  (каждый второй элемент)Короткое правило для собеса: start включён, stop исключён, step задаёт шаг.Отрицательные индексы и шагСлайсинг поддерживает отрицательные индексы и отрицательный шаг. Отрицательные start и stop считают от конца: -1 — последний, -2 — предпоследний и т.д.nums = [0, 1, 2, 3, 4, 5]
nums[-3:]    # [3, 4, 5]  (последние 3 элемента)
nums[:-1]    # [0, 1, 2, 3, 4]  (всё, кроме последнего)Отрицательный step означает движение в обратную сторону.nums[::-1]   # [5, 4, 3, 2, 1, 0] — разворот
nums[5:2:-1] # [5, 4, 3] — от индекса 5 до индекса 2, не включая 2Для отрицательного шага значения по умолчанию меняются: если start опущен, берётся конец последовательности, если stop опущен — идём до начала.Как ответить на собеседованииСлайсинг seq[start:stop:step] возвращает подпоследовательность. start включён, stop исключён, step задаёт шаг. Если параметры опущены, используются значения по умолчанию: от начала, до конца, шаг 1. Отрицательные индексы считают от конца, а seq[::-1] разворачивает последовательность.

Question 35

Что такое f-строки? Чем они лучше .format() и %-форматирования?

Accepted Answer

Что такое f‑строки?F‑строка — это обычная строка, перед которой стоит f или F, а внутри строки ты можешь использовать {...} с любыми Python‑выражениями.name = "TeoBrain"
score = 42
msg = f"Платформа {name}, твой результат: {score}"
pi_msg = f"Число пи ≈ {3.14159:.2f}"   # форматирование прямо в фигурных скобках
calc = f"2 + 2 = {2 + 2}"             # выражение внутри {}Под капотом f‑строка превращается в выражение, которое вычисляет все вложенные части и форматирует их через протокол __format__.Чем f‑строки удобнее .format() и %Читаемость: переменные видны там, где используются.# %-форматирование
msg = "User %s has %d points" % (name, points)
# .format()
msg = "User {} has {} points".format(name, points)
# f‑строка
msg = f"User {name} has {points} points"В f‑строке не нужно сопоставлять порядок аргументов и плейсхолдеров — сразу понятно, где какая переменная.Встроенные выражения и форматирование. В str.format() и % ты разделяешь «строку» и «данные», а f‑строка позволяет писать выражения прямо внутри:f"Через год тебе будет {age + 1}"
f"Цена: {price:.2f} BYN"
f"{user.first_name} {user.last_name}"Производительность. F‑строки обычно быстрее .format() и сопоставимы или быстрее современного %-форматирования. Это не всегда критично по одному месту, но полезно в массе (логирование, шаблоны сообщений).Современный стандарт. PEP 498 описывает f‑строки как рекомендуемый способ интерполяции строк в Python 3.6+. В новых проектах f‑строки — де‑факто стандарт.При этом % — старый синтаксис в стиле C, менее гибкий. .format() всё ещё полезен, когда шаблон приходит извне (переводы, конфиги), где ты не можешь написать f"..." прямо в коде.Как ответить на собеседованииF‑строки — это форматированные строковые литералы: строка с префиксом f, внутри которой можно писать выражения в {}. Они читаются проще, чем .format() и старое %-форматирование, позволяют сразу указывать формат ({price:.2f}) и часто работают быстрее. В современном коде на Python 3.6+ f‑строки — базовый способ форматирования строк.

Question 36

Что такое map(), filter(), zip(), enumerate()?

Accepted Answer

map() — применение функции к каждому элементуmap() берёт функцию и один или несколько итерируемых объектов и возвращает итератор, где каждый элемент — результат применения функции к соответствующим элементам входа.numbers = [1, 2, 3]
squares = map(lambda x: x * x, numbers)
print(list(squares))  # [1, 4, 9]Особенности: в Python 3 возвращает ленивый итератор, а не список. Аналог можно записать через list‑comprehension: [x * x for x in numbers].filter() — отбор по условиюfilter() оставляет только те элементы, для которых функция‑предикат вернула True.numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4, 6]Тоже возвращает итератор. Эквивалентный list‑comprehension: [x for x in numbers if x % 2 == 0].zip() — параллельный обход и «сшивание» коллекцийzip() объединяет элементы нескольких итерируемых объектов в кортежи по индексам.names = ["Alice", "Bob", "Carol"]
scores = [10, 20, 15]
pairs = list(zip(names, scores))
# [('Alice', 10), ('Bob', 20), ('Carol', 15)]Особенности: останавливается, когда закончился самый короткий из входов. Удобен для параллельного обхода и для «разворачивания» структур: zip(*pairs).enumerate() — индекс + значениеenumerate() добавляет к элементам последовательности счётчик (индекс).users = ["Ann", "Max", "Leo"]
for i, name in enumerate(users, start=1):
    print(i, name)
# 1 Ann
# 2 Max
# 3 LeoПлюсы: не нужно писать for i in range(len(users)) и обращаться через users[i]. Параметр start задаёт начальный номер (по умолчанию 0).Как компактно ответить на собеседованииФункция map() применяет функцию к каждому элементу и даёт итератор результатов, filter() отбрасывает элементы, не прошедшие условие, zip() «сшивает» несколько последовательностей в кортежи по позициям, а enumerate() добавляет к элементам их индекс. Все они упрощают работу с коллекциями и делают код короче и понятнее по сравнению с ручными циклами.

Question 37

Что такое модуль collections? Назовите часто используемые классы.

Accepted Answer

collections входит в стандартную библиотеку Python и содержит набор готовых контейнеров с дополнительным поведением.Они:упрощают распространённые задачи (подсчёт частот, очереди, объединённые словари, структурированные записи);часто делают код короче и понятнее, чем «голые» списки и словари.В backend‑коде это один из самых полезных модулей стандартной библиотеки.Часто используемые классы из collectionsnamedtuple — кортеж с именованными полямиФабрика для создания подклассов tuple с доступом по имени полей и по индексу.from collections import namedtuple

User = namedtuple("User", ["id", "name"])
u = User(id=1, name="Ann")
u.id   # 1
u.name # "Ann"Применение: лёгкие неизменяемые "DTO"‑объекты, результаты запросов, координаты, конфиги.deque — двусторонняя очередьСписокоподобная структура с быстрыми вставками и удалениями с обеих сторон (append, appendleft, pop, popleft).from collections import deque

q = deque()
q.append(1)
q.appendleft(0)
q.pop()       # 1
q.popleft()   # 0Применение: очереди задач, буферы последних N элементов (maxlen), алгоритмы (BFS, скользящее окно).Counter — счётчик объектовПодкласс dict, который считает количество вхождений каждого элемента.from collections import Counter

counts = Counter("banana")
# Counter({'a': 3, 'n': 2, 'b': 1})
counts.most_common(1)  # [('a', 3)]Применение: статистика, анализ логов, подсчёт частоты значений.defaultdict — словарь со значением по умолчаниюПодкласс dict, который при обращении к отсутствующему ключу автоматически создаёт для него начальное значение с помощью фабрики (например, list или int).from collections import defaultdict

groups = defaultdict(list)
groups["admin"].append("user1")
groups["admin"].append("user2")
# {'admin': ['user1', 'user2']}Применение: группировка по ключам, построение "словаря списков" или "словаря счётчиков" без проверок if key not in dict.OrderedDict — словарь с запоминаемым порядкомСловарь, который помнит порядок добавления ключей. Начиная с Python 3.7 обычный dict тоже сохраняет порядок, поэтому OrderedDict нужен реже (например, для специфических операций перестановки ключей).Другие классы, которые стоит знать по названиюChainMap — единый "вид" на несколько словарей, ведёт себя как один словарь.UserDict, UserList, UserString — обёртки вокруг dict/list/str для удобного наследования и переопределения поведения.Как ответить на собеседованииМодуль collections — это набор специализированных контейнеров, дополняющих обычные list, dict, tuple. На практике чаще всего используют namedtuple для неизменяемых структур с полями по имени, deque для очередей, Counter для подсчёта частот и defaultdict для словарей со значением по умолчанию. Реже — OrderedDict, ChainMap и обёртки UserDict/UserList/UserString.

Question 38

Что такое pickling / unpickling?

Accepted Answer

Что такое picklingPickling (сериализация) — это превращение объекта или целой иерархии объектов в линейное бинарное представление.Ключевые моменты:Работает с большинством базовых и пользовательских типов (list, dict, пользовательские классы, вложенные структуры).Результат — байтовый поток, который можно записать в файл, отправить по сети или сохранить в БД как бинарное поле.Пример: сохранить объект в файл:import pickle

data = {"id": 1, "name": "TeoBrain"}
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)  # picklingЧто такое unpicklingUnpickling (десериализация) — обратный процесс: взять байтовый поток и восстановить из него исходный объект или их иерархию.Пример: прочитать объект из файла:import pickle

with open("data.pkl", "rb") as f:
    data = pickle.load(f)  # unpickling
# data снова обычный dictПри unpickling модуль pickle создаёт новые объекты с тем же содержимым, что было у сохранённых.Зачем это нужно в реальных проектахТипичные сценарии использования pickling/unpickling в backend‑коде:Сохранение промежуточных результатов или состояния программы (кеш, сессии, очереди).Хранение обученных моделей и больших структур данных (особенно в ML‑части Python‑стека).Передача сложных объектов между процессами (например, в задачах очередей и worker‑систем).Ограничения и риски, про которые любят спрашиватьФормат pickle специфичен для Python и может отличаться между версиями, это не кросс‑языковой формат (в отличие от JSON или Protocol Buffers).Unpickling небезопасен для непроверенных данных: вызов pickle.load() на произвольном входе может привести к выполнению произвольного кода. Поэтому его используют только с доверенными источниками.Фраза для собеседованияPickling — это сериализация объектов в байтовый поток с помощью модуля pickle, unpickling — обратное восстановление объектов. Удобно для кешей, передачи данных и хранения моделей, но использовать pickle с непроверенным вводом нельзя из‑за рисков безопасности.

Question 39

Разница между append() и extend()?

Accepted Answer

Как работает append()append() принимает один аргумент любого типа и добавляет его в конец списка как есть.nums = [1, 2, 3]
nums.append(4)
# [1, 2, 3, 4]
nums.append([5, 6])
# [1, 2, 3, 4, [5, 6]]  — вложенный список как один элементОсобенности: список удлиняется ровно на один элемент; аргумент может быть чем угодно — числом, строкой, другим списком, объектом твоего класса.Как работает extend()extend() принимает итерируемый объект (список, кортеж, множество, строку и т.п.) и добавляет каждый его элемент в конец списка.nums = [1, 2, 3]
nums.extend([4, 5])
# [1, 2, 3, 4, 5]
nums.extend((6, 7))
# [1, 2, 3, 4, 5, 6, 7]
nums.extend("ab")
# [1, 2, 3, 4, 5, 6, 7, 'a', 'b']Особенности: длина списка увеличивается на количество элементов в переданном итерируемом; нельзя передать неитерируемый объект (например, nums.extend(5) вызовет TypeError).Как ответить на собеседованииОба метода добавляют данные в конец списка, но по‑разному. append(x) добавляет один объект как элемент списка, поэтому при append([4, 5]) ты получишь вложенный список. extend(iterable) разворачивает итерируемый объект и добавляет каждый его элемент по отдельности, так что при extend([4, 5]) список становится [1, 2, 3, 4, 5]. Если нужно добавить один объект — используй append, если «слить» в список содержимое другого итерируемого — extend.

Question 40

Что такое PYTHONPATH?

Accepted Answer

Что делает PYTHONPATHПри импорте модуля Python ищет его в наборе директорий, формирующих путь поиска модулей (sys.path). В него входят:текущий каталог / каталог скрипта;стандартная библиотека;установленные пакеты (site-packages);директории из переменной окружения PYTHONPATH (если она задана).То есть PYTHONPATH позволяет «подсказать» интерпретатору: «смотри ещё и сюда, когда делаешь import». Например:export PYTHONPATH=/home/user/my_libsпосле этого можно import my_module из /home/user/my_libs, даже если он не установлен как пакет.Основные моменты, которые нужно уметь сформулировать:PYTHONPATH — переменная окружения, а не Python‑переменная.Она добавляет директории к пути поиска модулей (sys.path), что удобно при разработке, когда код ещё не оформлен как устанавливаемый пакет или используется общий «internal libs» каталог.В современных проектах чаще полагаются на виртуальные окружения и нормальную установку пакетов, а PYTHONPATH используют точечно и осторожно, чтобы не путать импорты.Краткая формулировка для интервьюPYTHONPATH — это переменная окружения, которая добавляет дополнительные каталоги в sys.path. При импорте модулей Python помимо стандартных путей смотрит ещё и в папки, указанные в PYTHONPATH. Это удобно для разработки и внутренних библиотек, но в продакшене обычно предпочитают виртуальные окружения и установку пакетов, чтобы не запутывать путь поиска модулей.

Question 41

Как работает GIL (Global Interpreter Lock)? Когда он мешает?

Accepted Answer

Как GIL работает концептуально? Зачем вообще нужен GIL?В CPython управление памятью основано на подсчёте ссылок: у каждого объекта есть счётчик ссылок, и когда он опускается до нуля, объект освобождается. Изменение этого счётчика из нескольких потоков без синхронизации приводит к гонкам, утечкам или крашам. Чтобы не ставить отдельные блокировки на каждый объект и не усложнять реализацию, CPython вводит одну глобальную блокировку интерпретатора — GIL. Правило простое, но сильное: "Любой поток, который выполняет Python‑байткод или трогает Python‑объекты, должен сначала захватить GIL".Это сильно упрощает потокобезопасность внутри интерпретатора и C‑расширений, но и задаёт ограничения на параллельность.Что происходит при многопоточности?Внутри одного процесса CPython потоки есть, ОС может планировать их на разные ядра, но:В каждый момент времени только один поток владеет GIL и выполняет Python‑код.GIL периодически переходит от одного потока к другому: интерпретатор через определённые интервалы времени даёт другим потокам шанс захватить GILКогда поток выполняет блокирующий I/O (например, socket.recv(), file.read()), он отпускает GIL, позволяя другим потокам исполнять байт‑код, пока сам ждёт.Поэтому важно разделять два типа нагрузок:CPU‑bound — большинство времени тратится на чистые вычисления (парсинг, математика, обработка изображений и т.п.).I/O‑bound — большинство времени тратится на ожидание внешних операций (сеть, диск, БД).Когда GIL мешает, а когда — почти нет?GIL — реальная проблема в CPU‑bound многопоточных сценариях. Ты запускаешь несколько потоков, каждый делает тяжёлые вычисления на чистом Python (например, поиск простых чисел, обработка больших массивов без NumPy). Логика в этих потоках почти не делает I/O и не отпускает GIL. В результате потоки вынуждены делить один GIL, в реальности на многоядерной машине ты почти не видишь ускорения, а иногда вообще получаешь замедление из‑за накладных расходов на переключения. Таким образом, в CPython многопоточность не даёт настоящего параллелизма для CPU‑bound задач — GIL не позволяет нескольким потокам одновременно крутить байт‑код на разных ядрах.GIL почти не мешает в I/O‑bound многопоточных задачах. Поток инициирует I/O (HTTP‑запрос, чтение файла), интерпретатор отпускает GIL и блокируется на системном вызове. В это время другой поток может захватить GIL и крутить Python‑код. Поэтому многопоточность отлично подходит для параллельной обработки большого числа запросов к сети/диску, даже с GIL. GIL здесь почти не мешает, потому что время CPU‑вычислений невелико по сравнению с ожиданием I/O.Поэтому в ответах на интервью часто говорят: многопоточность в Python хорошо подходит для I/O‑bound задач (много ожиданий сети/диска) и плохо — для CPU‑bound, где лучше использовать multiprocessing или выносить вычисления в C/NumPy.Как обходят GIL в реальных проектахНа уровне middle важно уметь предложить варианты действий, если GIL мешает:multiprocessing вместо threading - Каждый процесс имеет свой интерпретатор и свой GIL → процессы могут реально работать на разных ядрах. Минусы: межпроцессное взаимодействие тяжелее (IPC, сериализация), форк/спаун процессов дороже, чем создание потоков.Использовать C‑расширения / NumPy / библиотеки, которые освобождают GIL - Многие библиотеки для работы с числами (NumPy, часть SciPy, некоторые крипто/ML‑библиотеки) реализуют тяжёлые вычисления в C/C++ и временно отпускают GIL, позволяя выполнять их параллельно.Асинхронщина (asyncio) для большого числа I/O‑операций - Она не убирает GIL, но помогает структурировать конкурентное I/O‑bound выполнение в одном потоке.Другие интерпретаторы - PyPy, Jython, IronPython и эксперименты с «no‑GIL» в CPython (пока не основная ветка) упоминают скорее как перспективу.Как сформулировать ответ на уровне middleВ CPython GIL — это глобальный мьютекс интерпретатора, который гарантирует, что только один поток одновременно выполняет Python‑байткод. Это упростило управление памятью и сделало объекты потокобезопасными на уровне …

Question 42

Как работает Garbage Collector и reference counting в Python?

Accepted Answer

В CPython у каждого объекта есть внутреннее поле refcount — количество активных ссылок на этот объект. При создании объекта счётчик = 1. Присвоили объект новой переменной, положили в список, передали в функцию — счётчик увеличился. Переменная вышла из области видимости, удалили элемент из списка, присвоили другое значение — счётчик уменьшился.Как только счётчик становится равным 0, объект моментально деаллоцируется, память освобождается сразу, без ожидания прохода GC. Это даёт предсказуемый момент освобождения (важно, например, для файловых дескрипторов), меньшую потребность в тяжелых «stop‑the‑world» проходах сборщика. Но у механизма подсчета ссылок есть фундаментальная проблема: циклические ссылки.Проблема циклических ссылок и роль GCЕсли два (или больше) объекта ссылаются друг на друга, их refcount никогда не станет нулём, даже если до них нельзя добраться из кода программы.a = {}
b = {}
a["b"] = b
b["a"] = a
del a, b  # внешних ссылок больше нет, но объекты держат друг другаОба словаря остаются в памяти: refcount > 0 из-за взаимных ссылок, хотя они уже не достижимы из программы. Чтобы такие объекты не «висели» в памяти бесконечно, в CPython есть дополнительный сборщик циклов — модуль gc и встроенный алгоритм - генерационный GC.Генерационный Garbage CollectorGC в Python заточен именно под обнаружение циклических ссылок. Он работает поверх счетчика ссылок и работает по принципу поколений:Все новые объекты попадают в поколение 0 (младшее).Если объект пережил один проход GC, он «стареет» и переезжает в поколение 1.Выжившие ещё дольше попадают в поколение 2 (старшее).GC чаще всего сканирует младшее поколение (там много короткоживущих объектов), реже — старшие поколения, чтобы не тратить ресурсы на длинноживущие объекты. Триггером служат пороги (thresholds): когда разница «создано – уничтожено» объектов превышает порог для поколения 0, запускается сборка этого поколения; после нескольких сборок 0‑го поколения может запуститься сборка 1‑го, и так далее. Алгоритмически это вариант mark‑and‑sweep, оптимизированный под циклы: GC ищет группы объектов, достижимые только друг через друга, и удаляет их как мусор.Ключевые тезисы, которые ожидают услышать на собеседованииPython (CPython) использует комбинированный подход: reference counting — основной механизм освобождения памяти; generational garbage collector — дополнительный механизм для циклических ссылок. Reference counting даёт немедленное освобождение, но не справляется с циклическими ссылками. GC работает поколениями, чаще проверяя молодые объекты, реже — старые, чтобы уменьшить overhead (расход ресурсов).Разработчик может посмотреть статистику и пороги через модуль gc, вызвать gc.collect() вручную, временно отключить GC (gc.disable()), если он даёт заметные паузы, и управлять сборкой вручную, например, в узких местах производительности.Краткая формулировка для ответаВ CPython память автоматически управляется двумя механизмами: счетчиком ссылок и генерационным GC. Каждый объект хранит счётчик ссылок; как только он падает до нуля, объект сразу освобождается. Но при циклических ссылках refcount никогда не становится нулём, поэтому поверх этого работает сборщик мусора, который периодически сканирует объекты (в трёх поколениях) и удаляет циклические ссылки. Счетчик ссылок обеспечивает быстрое и предсказуемое освобождение памяти, GC решает проблему циклических ссылок.

Question 43

Что такое модель памяти Python? Что такое __slots__?

Accepted Answer

Куча (heap) - все объекты (числа, строки, списки, экземпляры классов и т.д.) живут в куче — области памяти, управляемой интерпретатором.Стек вызовов - для каждой вызываемой функции создаётся фрейм на стеке: локальные переменные, аргументы, ссылки на объекты в куче.Важный момент: локальная переменная x — это не сам объект, а ссылка на него.Подсчёт ссылок + GCУ объекта есть счётчик ссылок; когда он падает до нуля, объект сразу освобождается, память возвращается аллокатору. Для циклов ссылок поверх этого работает генерационный сборщик мусора.Модель «всё — объект»Даже функции, классы и модули — объекты в куче, на которые ссылаются имена в пространствах имён. Ответ для middle‑специалиста обычно ожидают на уровне: «объекты в куче, ссылки на них в стеке, управление памятью через подсчёт ссылок плюс GC для циклов».Что делает __slots__По умолчанию у каждого экземпляра пользовательского класса есть словарь __dict__, где хранятся его атрибуты:class User:
   def __init__(self, name, age):
       self.name = name
       self.age = age
       
u = User("Ann", 30)
print(u.__dict__)  # {'name': 'Ann', 'age': 30}Это даёт гибкость (можно в любой момент дописать u.foo = 1), но у словаря есть цена: память и скорость доступа. Если в классе объявить __slots__, Python не будет создавать __dict__ для экземпляров, а вместо этого выделит фиксированную структуру под указанные атрибуты:class User:
   __slots__ = ("name", "age")
   def __init__(self, name, age):
       self.name = name
       self.age = age
       
u = User("Ann", 30)
# u.__dict__  -> AttributeError: 'User' object has no attribute '__dict__'Эффекты коллекции __slots__Экономия памяти. Для большого количества однотипных объектов (например, миллионов DTO или ORM‑моделей) экономия может составлять 20–50% на экземпляр.Более быстрый доступ к атрибутам. Доступ идёт по смещению в фиксированной структуре, а не через словарь → обычно даёт прирост 10–20% к скорости доступа к полям.Запрет произвольных атрибутов. Нельзя написать u.foo = 1, если foo не объявлен в __slots__ — будет AttributeError. Это иногда используют как способ ограничить интерфейс объектов и ловить опечатки вместо тихого создания нового поля.Ограничения и нюансы __slots__На собеседовании хорошо упомянуть не только плюсы, но и ограничения:__slots__ не наследуются автоматически как ожидают новички — при сложной иерархии классов нужно аккуратно их проектировать, учитывая, как объединяются слоты базовых и дочерних классов.Экземпляр класса с __slots__ по умолчанию не имеет __dict__ и __weakref__; если они нужны, их нужно явно добавить в __slots__.__slots__ разумно применять там, где:- очень много однотипных объектов (модели, ноды AST, структуры данных);- набор полей стабилен и заранее известен;- важны память и скорость доступа.В обычном бизнес‑коде для нескольких десятков объектов выгода минимальна, а гибкость теряется.Модель памяти Python: объекты живут в куче, переменные — это ссылки на них в стеке и словарях пространств имён, память управляется подсчётом ссылок и генерационным GC для циклических ссылок. __slots__ — это настройка класса, которая отключает словарь атрибутов __dict__ у экземпляров и заменяет его фиксированной структурой с заранее объявленными полями. Это уменьшает память на экземпляр и ускоряет доступ к атрибутам, но запрещает динамически добавлять новые поля и требует аккуратности при наследовании.

Question 44

Async Python: event loop, async/await, asyncio. Что под капотом?

Accepted Answer

Вся асинхронность крутится вокруг одного объекта — event loop (событийный цикл). Он делает две вещи: запускает async def‑функции (корутины);переключается между ними, когда они чего‑то ждут (сетевой ответ, таймер и т.п.), чтобы в это время выполнялся другой код.Важно: это всё происходит в одном потоке и с тем же GIL. Асинхронность даёт нам одновременное ожидание многих I/O‑операций, а не параллельные вычисления на всех ядрах.async/await простыми словамиasync def — объявляет асинхронную функцию (корутину), а не обычную функцию. Вызов такой функции (например, назовём её coro) записью coro() возвращает объект‑корутину, а не готовый результат; чтобы получить результат, нужно либо написать await coro() внутри другой async‑функции, либо передать эту корутину в asyncio.create_task(coro()), чтобы её выполнил событийный цикл. await — это место, где корутина приостанавливается.Когда интерпретатор встречает await something:текущая корутина говорит event loop’у: «я жду something»;управление возвращается в event loop;event loop в это время запускает другие корутины или ждёт I/O.Пока корутина выполняется между await‑ами, она блокирует event loop сама, поэтому внутри async‑кода нельзя долго крутить чистый CPU‑код без await — остальные задачи будут стоять.Что такое Future и TaskЧтобы event loop мог понимать, что уже завершилось, а что ещё выполняется, используются объекты Future. Future — это контейнер для результата, который появится позже: либо значения, либо исключения. У него есть состояние: «ожидание», «успешно завершён», «завершён с ошибкой».asyncio.Task — это обёртка над корутиной, которая одновременно является и задачей (Task), и Future. Task запускает корутину и по завершении кладёт её результат или ошибку внутрь себя как в Future;await task означает «подождать, пока задача завершится, и получить её результат».То есть:корутина — это «что делать» (код);Future — «коробка» для результата;Task = «корутина + Future» в одном объекте, другими словами, обёртка вокруг корутины.Event loop по шагамЦикл событий (asyncio‑loop) делает примерно следующее:Хранит список задач (Task).Берёт задачу, продвигает её корутину до ближайшего await.Если корутина упёрлась в await asyncio.sleep(), ожидание сети и т.п., задача помечается как «ждущая», и цикл запускает следующую задачу.Внутри у цикла есть ожидание событий ОС (select/epoll/kqueue и аналоги) — там он ждёт:срабатывание таймеров;появления данных на сокетах или готовности к записи;перехода связанных Future в состояние «готов» (например, завершения других задач).Как только нужное событие произошло (например, пришли данные по сети или истёк таймер), event loop:помечает соответствующий Future как завершённый;возвращает связанную с ним задачу в очередь «готовых»;продолжает её корутину с места await.Ключевой момент: переключение кооперативное — корутина сама отдаёт управление, но только когда делает await.Зачем нужен asyncio?... asyncio — это стандартная библиотека, которая даёт реализацию событийного цикла; умеет превращать корутины в задачи (asyncio.create_task); позволяет одним await ждать сразу несколько корутин/задач (asyncio.gather); предоставляет готовые awaitable‑объекты:asyncio.sleep — ждать таймер;сетевые клиенты и серверы для TCP/UDP/HTTP и т.п.;примитивы синхронизации (Lock, Queue и др.).import asyncio

async def fetch(i):
   print(f"start {i}")
   await asyncio.sleep(1)  # имитация запроса
   print(f"end {i}")
   return i
   
async def main():
   tasks = [asyncio.create_task(fetch(i)) for i in range(3)]
   results = await asyncio.gather(*tasks)
   print(results)
   
asyncio.run(main())Что произойдёт:все 3 fetch начнут выполняться почти одновременно;каждый await asyncio.sleep(1) отдаст управление циклу;цикл одновременно дождётся всех трёх sleep (через таймеры/Future) и по очереди продолжит каждую корутину;общее время работы ≈ 1 секунда, а не 3.asyncio.gather здесь создаёт один общий Future, который «готов», только когда завершились все три задачи, и await этого Future возв…

Question 45

Разница между threading, multiprocessing и asyncio?

Accepted Answer

threading (многопоточность)Модель: один процесс, несколько потоков. Все потоки разделяют память процесса: общие объекты, общий heap (куча). Планирование потоков делает ОС (preemptive): она сама решает, когда переключаться между потоками.Особенности в CPython:Есть GIL: одновременно байткод реально исполняет только один поток, остальные ждут.В итоге нет настоящего параллелизма для чисто вычислительных задач, но при блокирующем I/O поток отпускает GIL, другие потоки могут работать. Для I/O‑bound задач (много ожиданий сети/диска) многопоточность даёт выигрыш.Плюсы:Легко прикрутить к старому синхронному коду и к библиотекам, которые не умеют работать асинхронно (async).Минусы:GIL убивает параллелизм для CPU‑bound.Нужны блокировки/синхронизация при доступе к общим данным.Потоки «тяжелее» задач в asyncio (больше накладных расходов).multiprocessing (многопроцессность)Модель: несколько процессов, каждый со своим интерпретатором, своей памятью и своим GIL. ОС реально выполняет процессы на разных ядрах → настоящий параллелизм для CPU‑bound задач.Особенности:Процессы не разделяют память по умолчанию: данные передаются через очереди, пайпы, shared memory, что требует сериализации (pickle и т.п.). Также создание процессов дороже, чем создание потоков, больше накладных расходов на взаимодействие.Плюсы:Реально задействует несколько ядер для тяжёлых вычислений.GIL перестаёт быть проблемой (у каждого процесса свой).Минусы:Более тяжёлый старт и коммуникация между процессами.Сложнее отлаживать, особенно на Windows со spawn.asyncio (асинхронность / event loop)Модель: один процесс, один поток, один event loop. Много корутин (async‑функций), которые кооперативно делят время: отдают управление, когда делают await. Как работает: Event loop запускает корутины и переключается между ними только в точках await. Пока корутина ждёт (сетевой запрос, таймер, БД), event loop выполняет другие корутины. GIL никуда не исчезает, просто код почти всё время ждёт I/O, а не считает CPU.Плюсы:Очень маленькие накладные расходы на задачу — можно держать десятки тысяч одновременных запросов.Хорошо структурирует I/O‑bound код (сетевые сервисы, чаты, прокси и т.д.).Минусы:Нужно «переписать мозг» под async‑стиль: await тянется по стеку вызовов.Любой блокирующий вызов внутри async‑кода тормозит весь event loop.Не даёт параллелизма для CPU‑bound (всё равно один поток).Когда что выбирать?Кандидату уровня middle обычно нужно уметь уверенно сказать:I/O‑bound задачи (много ожидания сети/диска, мало CPU):если библиотека поддерживает async — asyncio (либо фреймворк на нём: FastAPI, aiohttp и т.п.);если нет async‑API — threading (или смешанный вариант: asyncio + to_thread/run_in_executor).CPU‑bound задачи (много вычислений):multiprocessing или внешние воркеры (Celery, RQ и т.п.);либо выносить тяжёлое в C/NumPy, которые сами умеют использовать потоки.Если ни I/O‑bound, ни тяжёлый CPU (обычный CRUD‑backend) — можно начать с простого синхронного подхода; async/threads/процессы подключать по мере появления узких мест.Краткая устная формулировкаВ CPython threading и asyncio подходят для I/O‑bound задач: они позволяют перекрывать ожидания I/O, но не дают настоящего параллелизма по CPU из‑за GIL. multiprocessing создаёт отдельные процессы с отдельными интерпретаторами, поэтому подходит для CPU‑bound задач и позволяет использовать все ядра. Asyncio даёт гораздо меньшие накладные расходы и лучше масштабируется по числу задач, но требует писать код в async‑стиле и аккуратно обходиться с блокирующими вызовами.

Question 46

Что такое type annotations и typing? Для чего используют Protocol, TypeVar?

Accepted Answer

Что такое type annotations и typingType annotations (type hints) — это синтаксис вида x: int, def f(x: str) -> int: ..., который говорит: «я ожидаю здесь такой тип», но не меняет поведение кода во время выполнения. Они используются статическими анализаторами (mypy, pyright), IDE и фреймворками (например, FastAPI), чтобы находить ошибки, улучшать автодополнение и генерировать схемы/валидацию.Модуль typing даёт «словарь типов»: List, Dict, Optional, Union, Callable, Literal, Annotated и т.д., а также продвинутые механизмы вроде Protocol, TypeVar, Generic.Пример базовых аннотаций:from typing import List

def average(values: List[float]) -> float:
   return sum(values) / len(values)Зачем нужен ProtocolProtocol — это способ описать структурный тип, т.е. интерфейс «утка, которая крякает так-то», а не «класс, унаследованный от такого-то базового класса». Класс считается совместимым с протоколом, если имеет нужные методы/атрибуты с подходящими сигнатурами, даже если он не наследуется от Protocol и вообще про него не знает. Это формализует привычный Python‑овский duck typing ("утиная типизация") на уровне статической типизации.from typing import Protocol

class Notifier(Protocol):
   def send(self, message: str) -> None: ...
   
class EmailNotifier:
   def send(self, message: str) -> None:
       print("Email:", message)
       
class SmsNotifier:
   def send(self, message: str) -> None:
       print("SMS:", message)
       
def notify(user_notifier: Notifier, msg: str) -> None:
   user_notifier.send(msg)И EmailNotifier, и SmsNotifier автоматически подходят под Notifier, потому что у них есть метод send(str) -> None.Protocol позволяет описывать интерфейсы в духе duck typing: я говорю, какие методы и атрибуты мне нужны, а тип‑чекер считает любой класс совместимым, если он это реализует, без наследования и общей иерархии.Зачем нужен TypeVarTypeVar — это параметр типа, который даёт возможность писать обобщённый (generic) код: функция одна, но типы входа/выхода связаны между собой.Мы объявляем T = TypeVar("T") и дальше используем T в аннотациях, чтобы сказать: «функция принимает и возвращает один и тот же тип, но какой именно — решается при использовании». Type checker потом подставляет конкретные типы и проверяет, что ты не смешиваешь, например, int и str там, где обещал один и тот же T.Пример функции, которая «сохраняет» тип:from typing import TypeVar, Iterable, List

T = TypeVar("T")
def to_list(items: Iterable[T]) -> List[T]:
   return list(items)Если передать Iterable[int], тип результата будет List[int]. Если Iterable[str] — List[str] и т.д.TypeVar можно ограничивать: T = TypeVar("T", bound=BaseClass) или T = TypeVar("T", int, float) — тогда функция будет работать только с указанными типами, а checker это гарантирует.Protocol + TypeVar вместеProtocol и TypeVar часто комбинируют, чтобы описывать дженерик‑интерфейсы:from typing import Protocol, TypeVar

T = TypeVar("T")
class Repository(Protocol[T]):
   def get(self, id: int) -> T: ...
   def save(self, obj: T) -> None: ...Так можно описать общий интерфейс репозитория поверх доменных сущностей (User, Order, Product), сохранив корректные типы туда/обратно. IDE и статический анализатор знают, что UserRepository вернёт User, а OrderRepository — Order, хотя код интерфейса один и тот же.Формулировка для ответаTypeVar — это параметр типа для дженериков: он связывает типы аргументов и результата функции/класса. Protocol описывает интерфейс через набор методов и атрибутов. Вместе они позволяют строить типобезопасные generic‑интерфейсы в духе репозиториев, клиентских обёрток и т.п.

Question 47

Что такое дескрипторы?

Accepted Answer

Технически дескриптор — любой объект, у которого определён хотя бы один из методов протокола дескрипторов:__get__(self, instance, owner) — вызывается при чтении obj.attr;__set__(self, instance, value) — при присваивании obj.attr = value;__delete__(self, instance) — при del obj.attr.Когда такой объект лежит как атрибут класса, доступ к этому имени (obj.attr) идёт через методы дескриптора, а не напрямую к __dict__ экземпляра.Формулировка для собеседованияДескрипторы — это объекты с методами __get__, __set__, __delete__, которые управляют тем, как читаются, записываются и удаляются атрибуты у других объектов. В коде это выглядит следующим образом:class LoggedAttribute:
   def __init__(self, name: str):
       self.name = name
       
   def __get__(self, instance, owner):
       if instance is None:
           return self
       value = instance.__dict__.get(self.name)
       print(f"GET {self.name} -> {value}")
       return value
       
   def __set__(self, instance, value):
       print(f"SET {self.name} = {value}")
       instance.__dict__[self.name] = value

class User:
   age = LoggedAttribute("age")  # дескриптор – атрибут класса

u = User()
u.age = 30      # вызывает LoggedAttribute.__set__(...)
print(u.age)    # вызывает LoggedAttribute.__get__(...)Здесь age — дескриптор, который логирует чтение/запись, когда ты обращаешься к u.age.Зачем они нужны?На дескрипторах внутри Python построены:@property — это частный случай дескриптора c __get__/__set__;методы класса — функции тоже являются дескрипторами и при доступе через экземпляр превращаются в «связанный метод» с self;@classmethod, @staticmethod — тоже реализованы через дескрипторы.Пользовательские дескрипторы используют для:валидации и тип‑проверки полей (например, PositiveInt, EmailStr и т.п.);ленивых вычислений и кеширования (LazyProperty, кэширование результата первого вычисления);логирования, трассировки, контроля доступа.Data и non‑data дескрипторыЕсть два важных подтипа дескрипторов:Data descriptor — у дескриптора есть __set__ или __delete__ (обычно оба). Такие дескрипторы имеют приоритет над instance.__dict__.Non‑data descriptor — у дескриптора только __get__. В этом случае, если в instance.__dict__ есть одноимённый атрибут, он перебивает дескриптор.Это объясняет, почему property — это «жёсткое» поле: оно всегда контролирует и чтение, и запись, и не даёт тебе просто так сохранить поверх него другое значение в экземпляре. Любая попытка obj.prop = ... идёт через его __set__.Обычный метод — «мягкий» дескриптор: он управляет только чтением. Если ты один раз сделал obj.method = 123, ты просто положил значение в obj.__dict__ и тем самым «перекрыл» метод для этого конкретного объекта.Дескрипторы в Python — это механизм, который позволяет вынести логику доступа к атрибутам в отдельные объекты. Любой объект с __get__, __set__, __delete__, положенный как атрибут класса, становится дескриптором и управляет тем, что происходит при чтении, записи и удалении этого атрибута. На дескрипторах реализованы property, методы, classmethod и staticmethod. На практике их применяют для переиспользуемых «умных» полей: валидация, логирование, lazy‑свойства и т.д.

Question 48

Как работают метаклассы? Когда их применяют?

Accepted Answer

В Python классы — тоже объекты, и они создаются другим объектом — метаклассом (по умолчанию это type).Когда интерпретатор видит class MyClass(...): ..., он в итоге вызывает метакласс примерно так: MyClass = MetaClass(name, bases, attrs_dict)где: имя класса, базовые классы и словарь атрибутов передаются в метакласс. Обычный путь: используется встроенный метакласс type, он просто создаёт класс из этих данных. Если ты задаёшь metaclass=MyMeta, то вместо type вызывается твой метакласс, и у тебя есть точка, где можно перехватить создание класса, что‑то поменять и вернуть модифицированный класс.class MyMeta(type):
   def __new__(mcls, name, bases, attrs):
       print("Создаём класс:", name)
       # например, добавим атрибут
       attrs["from_meta"] = True
       return super().__new__(mcls, name, bases, attrs)
       
class MyClass(metaclass=MyMeta):
   pass
   
print(MyClass.from_meta)  # TrueЗдесь MyMeta.__new__ вызывается в момент определения MyClass, и именно он создаёт объект класса, добавляя ему атрибуты.Когда метаклассы применяют?Метаклассы — тяжёлая артиллерия; их используют редко и обычно на уровне фреймворков или больших библиотек, когда нужно повлиять на множество классов сразу:ORM и модели — Django ORM, SQLAlchemy и другие используют метаклассы для обработки определения моделей. При написании класса модели метакласс собирает поля, строит метаданные и генерирует нужные методы/SQL‑структуры.Автоматическая регистрация классов — плагины, команды CLI, обработчики событий: метакласс может автоматически регистрировать каждый новый подкласс в реестре, чтобы не писать ручной boilerplate.Валидация и навязывание интерфейса — метакласс может при создании класса проверять, что он определил нужные методы/атрибуты, не нарушил контракт и т.п.Создание DSL и магии уровня фреймворка — когда хочется, чтобы объявление классов выглядело как мини‑язык (описание схемы БД, конфигов, правил доступа и т.д.), метакласс может превратить объявленный класс в нужную структуру данных или обёртку.Для ежедневного прикладного кода обычно хватает декораторов, миксинов, фабрик и классов, а к метаклассам имеет смысл прибегать, только если ты реально проектируешь фреймворк или инфраструктурный слой и тебе нужно «одним движением» менять или проверять все классы определённого семейства в момент их объявления.Формулировка для собеседованияВ Python классы сами по себе объекты, и их создаёт метакласс. По умолчанию это type, который получает имя, базовые классы и словарь атрибутов и на их основе конструирует объект класса. Если задать свой metaclass=..., можно перехватить момент создания класса: перед его созданием модифицировать атрибуты, навесить регистрацию, проверки, сгенерировать методы и вернуть уже обработанный класс. Метаклассы используются редко, в основном в библиотеках и фреймворках: ORM, плагинные системы, DSL и места, где нужно автоматом модифицировать или регистрировать семейство классов. В прикладном коде чаще достаточно декораторов и обычных классов, потому что метаклассы усложняют понимание и поддержку.

Question 49

Что такое dunder-методы?

Accepted Answer

Под dunder‑методами (double underscore) обычно понимают специальные методы вида __name__, которые Python вызывает автоматически при выполнении разных операций над объектами. Они не вызываются напрямую в типичном коде (хотя можно), а срабатывают «под капотом», когда ты используешь синтаксис языка.Например:__init__ — инициализация объекта при создании obj = MyClass(...);__str__ и __repr__ — человекочитаемое и отладочное представление в строке (str(obj), repr(obj), в том числе внутри print и REPL);__len__ — длина контейнера для len(obj);__getitem__, __setitem__, __delitem__ — индексный доступ и изменение obj[key];__iter__, __next__ — протокол итератора для for ... in obj;__enter__, __exit__ — протокол контекстного менеджера для with obj:;__add__, __sub__, __mul__ и др. — перегрузка операторов +, -, * и т.п.;__eq__, __lt__, __hash__ — сравнение и работа в качестве ключей словарей/элементов множеств.Пример: делаем свой «контейнер»class Bucket:
   def __init__(self):
       self._items = []
       
   def __len__(self):
       return len(self._items)
       
   def __getitem__(self, index):
       return self._items[index]
       
   def __setitem__(self, index, value):
       self._items[index] = value
       
   def __repr__(self):
       return f"Bucket({self._items!r})"

b = Bucket()
b._items.append(1)
b._items.append(2)
print(len(b))      # вызывает b.__len__
print(b[0])        # вызывает b.__getitem__
b[1] = 42          # вызывает b.__setitem__
print(b)           # вызывает b.__repr__Благодаря dunder‑методам пользовательский класс может выглядеть и вести себя как встроенный тип — список, словарь, число и т.д.Зачем это нужно на практике?На уровне middle часто ожидают, что ты:умеешь делать осмысленные __repr__/__str__ для удобной отладки;понимаешь, как сделать класс итерируемым (реализовать __iter__ и по необходимости __next__);знаешь, как перегрузить операторы для доменных объектов (Money, Point и т.п.);понимаешь контекстные менеджеры через __enter__/__exit__.Dunder‑методы — это «крючки», с помощью которых твой класс интегрируется со стандартным синтаксисом языка. Правильная реализация ключевых dunder‑методов делает API класса естественным и понятным для любого Python‑разработчика.

Question 50

Статические анализаторы: Flake8, Pylint, mypy, Radon — в чём разница?

Accepted Answer

Все четыре инструмента относятся к статическому анализу, но решают разные задачи и часто используются вместе в пайплайне CI.Flake8Flake8 — тонкий слой над pycodestyle, pyflakes и рядом плагинов. Основной фокус:соблюдение стиля кода (PEP 8: отступы, длина строк, пробелы, имена и т.п.);простые ошибки уровня «мертвый импорт», «неиспользуемая переменная», «перекрытие импортов» (частично за счёт pyflakes);богатая система плагинов (командный стандарт оформления, проверка docstring’ов и т.п.).На практике: Flake8 — дешёвый и быстрый линтер, который почти всегда включают первым в пайплайн.PylintPylint идёт дальше простого стиля и даёт более глубокий анализ:качество кода: подозрительные конструкции, потенциальные баги, неиспользуемый код;code smells: слишком большие функции/классы, совпадающие фрагменты кода, плохие имена;«оценка» модуля в виде числового рейтинга;более сложные проверки импортов, иерархий и т.п.Минусы: медленнее Flake8 и даёт много «мнений» из коробки, поэтому его часто конфигурируют под командный стиль или используют точечно.mypymypy — это уже не линтер стиля, а статический проверяющий типов для аннотированного кода:использует аннотации типов (type hints) и модуль typing;ловит несоответствия типов: передача str туда, где объявлен int; неверные возвращаемые типы; несовместимые перегрузки и т.п.;поддерживает строгие режимы, плагинную систему (например, плагины для pydantic, SQLAlchemy).С точки зрения собеседования важно подчеркнуть: mypy проверяет типы, а не стиль; он не заменяет Flake8/Pylint, а дополняет их.RadonRadon специализируется на метриках сложности и качества:цикломатическая сложность функций/методов;поддерживаемость кода (Maintainability Index);подсчёт raw‑метрик (количество строк кода, комментариев и т.п.).На основе Radon можно искать «горячие точки» — функции c высокой сложностью, которые стоит рефакторить, и отслеживать динамику метрик по проекту.Хорошая устная формулировкаFlake8 — лёгкий линтер и стайл‑чекер; Pylint — более тяжёлый анализатор качества и стиля; mypy — проверяющий типов поверх аннотаций; Radon — анализатор сложностей и метрик. В живых проектах их обычно комбинируют: Flake8/Pylint для стиля и качества кода, mypy для типов, Radon — для поиска слишком сложных участков и отслеживания поддерживаемости.

Question 51

Как передаются аргументы в функции Python — by value или by reference?

Accepted Answer

Классические термины by value/by reference плохо ложатся на модель Python, поэтому корректнее говорить о передаче по объектной ссылке (call by object reference или call by sharing).Что это означает на практикеПри вызове функции создаются новые имена в локальной области видимости, которые указывают на уже существующие объекты.Если внутри функции ты изменяешь сам объект (например, список через .append()), это изменение видно снаружи.Если внутри функции ты переназначаешь локальное имя на новый объект (obj = ...), это не влияет на то, на что ссылается имя снаружи.Примеры с изменяемыми и неизменяемыми объектамиdef add_one(x):
   x += 1

n = 10
add_one(n)
print(n)  # 10, не изменилсяЧисла — неизменяемые объекты. Операция x += 1 создаёт новый объект и перепривязывает локальное имя x на него. Снаружи переменная n продолжает ссылаться на старый объект.def append_item(items):
   items.append(42)

lst = []
append_item(lst)
print(lst)  # [42], список изменилсяСписки — изменяемые. append меняет объект по месту; и локальное имя items, и внешнее lst указывают на один и тот же список, поэтому изменение видно снаружи.Как это корректно сформулировать на собеседованииВ Python в функцию передаются ссылки на объекты, а не сами объекты по значению и не «указатели», как в C. Если ты мутируешь объект внутри функции (список, словарь, свой экземпляр класса), изменения видны снаружи. Если ты просто переназначаешь локальный параметр на новый объект, это не затрагивает внешнюю переменную. Такой подход обычно описывают как call by object reference или call by sharing.

Question 52

Что такое thread locals?

Accepted Answer

В многопоточном коде часто нужны данные «глобальные» для потока, но невидимые другим потокам: текущий пользователь, id запроса, коннект к БД, контекст логирования. Thread‑locals решают эту задачу.Базовая идеяОбъект threading.local() создаётся один раз, но его атрибуты фактически хранятся отдельно для каждого потока. Запись в storage.user в одном потоке не влияет на значение storage.user в другом.import threading

storage = threading.local()

def worker(name):
   storage.user = name
   print(threading.current_thread().name, storage.user)

threads = [threading.Thread(target=worker, args=(f"user-{i}",)) for i in range(3)]
for t in threads:
   t.start()
for t in threads:
   t.join()Каждый поток увидит своё значение storage.user, даже несмотря на общий объект storage на уровне модуля.Где это применяютWeb‑фреймворки: хранение контекста текущего запроса (request id, user id, locale) без явной передачи по всей цепочке вызовов.Логирование: добавление в логи информации о запросе/пользователе из thread‑local контекста.Подключения к БД, кешам и т.п.: один коннект на поток (в старых WSGI‑подходах).Ограничения и нюансыThread‑locals работают на уровне threading; в asyncio‑коде они не подходят для различения задач внутри одного потока — там используют contextvars.Чрезмерное использование thread‑locals делает зависимости неявными: функция опирается на «глобальное» состояние вместо явных аргументов, что усложняет тестирование.Важно очищать/пересоздавать thread‑local‑контекст в пулах потоков, чтобы данные предыдущего запроса не «утекали» в следующий.Формулировка для ответаThread‑locals — это локальное хранилище на поток: один объект threading.local, у которого каждый поток видит собственный набор атрибутов. Это удобно для хранения контекста запроса, текущего пользователя и других данных, которые должны быть «глобальными» в рамках потока, но изолированными между потоками. В асинхронном мире аналогичную задачу решают contextvars.

Question 53

Как сравнить асинхронные фреймворки: FastAPI, aiohttp, Starlette?

Accepted Answer

Эти три инструмента часто упоминают рядом, но они не на одном уровне абстракции.StarletteStarlette — лёгкий ASGI‑фреймворк/микро‑ядро:реализует протокол ASGI, даёт routing, middleware, background‑tasks, WebSocket, sessions;минималистичен, хорошо подходит как база для своих фреймворков и узкоспециализированных сервисов;не навязывает модель данных/валидации — ты сам выбираешь Pydantic, dataclasses, Marshmallow и т.п.Во многом Starlette — это «асинхронный Flask» на уровне ядра, но с ASGI и полноценной поддержкой современного стека.FastAPIFastAPI построен поверх Starlette и Pydantic:декларативные эндпоинты с аннотациями типов: запросы/ответы, схемы, валидация;автоматическая генерация OpenAPI, Swagger‑UI и Redoc‑документации из аннотаций;удобная работа с зависимостями через dependency injection (Depends);по умолчанию async‑подход, но можно и синхронные обработчики.Если нужны быстрые в разработке REST/JSON‑сервисы с сильной типизацией и документированием, FastAPI — хороший выбор. Цена — зависимость от Pydantic, своя магия DI и чуть больший overhead по сравнению с «голой» Starlette.aiohttpaiohttp — это:асинхронный HTTP‑клиент (очень широко используется для исходящих запросов);асинхронный HTTP‑серверный фреймворк поверх asyncio (но не ASGI);своя экосистема middleware, routing и т.п., но без автоматической генерации OpenAPI и «из коробки» схем/валидации, как у FastAPI.Серверная часть aiohttp более низкоуровневая относительно FastAPI/Starlette; для сложных проектов часто придётся больше инфраструктуры писать руками.Что отметить на собеседованииFastAPI = Starlette + Pydantic + DI + OpenAPI — быстрый старт для typed‑API.Starlette — лёгкая асинхронная основа (ASGI), на которой можно строить свои решения или более тонко контролировать стек.aiohttp — отдельный async‑фреймворк и HTTP‑клиент, не завязанный на ASGI; хорош как клиент, серверную часть выбирают, если нужен максимально гибкий контроль или уже есть опыт/код на нём.Выбор обычно такой: FastAPI — когда важна скорость разработки и типизация API; Starlette — когда нужен контролируемый лёгкий каркас ASGI без лишнего; aiohttp — когда нужен мощный HTTP‑клиент и/или более низкоуровневый серверный стек.

Question 54

Какие паттерны проектирования используете чаще всего в Python-коде?

Accepted Answer

На собеседовании по Python от middle обычно ждут не перечисления всех 23 паттернов GoF, а понимания, как решать типичные задачи архитектуры в живом коде.Фабрики и фабричные функции (Factory, Factory Method)В Python часто используют простые фабричные функции или классы‑фабрики:скрыть детали конфигурации объекта (клиент к БД, HTTP‑клиент, репозиторий);выбирать конкретную реализацию по настройкам/окружению (mock vs real, разные драйверы);интегрировать с DI‑контейнерами.Стратегия (Strategy)Strategy удобно использовать там, где есть несколько алгоритмов под один интерфейс:разные политики ретраев;варианты расчёта цены/скидок;разные провайдеры уведомлений (email, SMS, push).В Python стратегия часто выглядит как набор классов с общим интерфейсом или просто набор функций/корутин, хранящихся в словаре по ключу (mapping[key](...)), плюс Protocol для типобезопасности.Адаптер и Фасад (Adapter, Facade)При работе с внешними сервисами (платёжки, CRM, склад) удобно:делать Adapter, который приводит неудобный/шумный внешний API к нашему доменному интерфейсу;строить поверх нескольких низкоуровневых клиентов Facade — один высокоуровневый сервис, который решает задачу бизнеса и прячет детали интеграций.Это даёт более чистый доменный код и упрощает тестирование (можно подменять фасад или адаптер).Repository и Service (слой домена / слой приложений)Частый практический паттерн в Python‑backend — Repository + Service:Repository инкапсулирует доступ к данным (БД, кеш, внешние API), возвращая доменные объекты;Service реализует бизнес‑логику, опираясь на репозитории и другие сервисы, не зная деталей БД.Это помогает держать доменную логику независимой от инфраструктуры, облегчает миграции между БД и тестирование.Декоратор (в том числе синтаксический @decorator)Декоратор в Python естественен благодаря синтаксису @name:логирование и трассировка вызовов;кеширование (@lru_cache, свои декораторы кеша);контроль доступа, ретраи, метрические счётчики;единая обработка ошибок.Важно уметь писать декораторы и понимать, как они влияют на сигнатуры функций (использование functools.wraps и typing).Observer / Pub‑Sub, CQRS, Event‑drivenВ более сложных системах часто всплывают event‑подходы:Observer / Pub‑Sub: внутренний event‑bus или брокер сообщений (Kafka, RabbitMQ) со слушателями;CQRS и разделение команд/запросов в приложениях с насыщенным доменом.Реализуются они чаще на уровне инфраструктуры (брокеры, handlers), но важно понимать мотив: развязать отправителя и получателя, масштабировать обработку, упростить расширение поведения.Хорошая формулировка для ответаВ реальном Python‑коде я чаще использую фабрики и strategy для выбора поведения, adapter/facade для интеграций с внешними системами, Repository/Service для разделения домена и инфраструктуры и декораторы для кросс‑срезочных задач (логирование, кеш, ретраи, права доступа). При нужной сложности системы добавляются event‑подходы (Observer/pub‑sub) и элементы CQRS. Чистые классовые паттерны GoF я подстраиваю под идиоматику Python (функции первого класса, декораторы, dataclasses, typing).

Question 55

Как запустить код на Python параллельно? Какие есть ограничения?

Accepted Answer

На уровне senior важно не просто перечислить инструменты, а увязать их с моделью исполнения CPython и типами нагрузок.Параллелизм через потоки (threading)Пакет threading даёт абстракции потоков, локального для потока хранилища, примитивов синхронизации и т.п. ОС может распараллеливать потоки по ядрам, но в CPython есть GIL, из‑за которого в каждый момент времени только один поток исполняет Python‑байткод.Практически:для I/O‑bound задач (много ожидания сети/диска, мало CPU) потоки работают хорошо: при блокирующем I/O GIL отпускается, и другие потоки могут выполняться;для CPU‑bound чисто на Python многопоточность почти не даёт выигрыша и может даже ухудшать ситуацию за счёт переключений и конкуренции за GIL.Параллелизм через процессы (multiprocessing)multiprocessing создаёт отдельные процессы, у каждого свой интерпретатор и свой GIL. Это позволяет реально задействовать несколько ядер для CPU‑bound задач.Плюсы:настоящий параллелизм по CPU, хорош для тяжёлых вычислений;изоляция по памяти между процессами (повышенная надёжность, отсутствие shared‑state).Минусы:дороже создание процессов, тяжёлое IPC и сериализация (pickle), особенно на Windows;сложнее отладка и управление жизненным циклом воркеров.Частая практика: CPU‑тяжёлое выносится в пул процессов (локальный через multiprocessing.Pool или внешние воркеры: Celery, RQ и т.п.).Конкурентность через asyncioasyncio и фреймворки поверх него (FastAPI, aiohttp, Starlette) дают конкурентное выполнение большого числа I/O‑операций в одном потоке.всё по‑прежнему крутится в одном потоке, под тем же GIL;параллелизма по CPU нет, но можно одновременно обслуживать тысячи соединений, пока корутины ждут сеть/диск;любой длительный CPU‑bound участок внутри event loop блокирует все задачи, его нужно выносить в run_in_executor или процессы.Нативные расширения и библиотеки, которые освобождают GILМногие вычислительные библиотеки (NumPy, часть SciPy, некоторые ML/crypto‑библиотеки) реализованы на C/C++ и временно отпускают GIL во время тяжёлых участков. Тогда несколько потоков одного процесса могут действительно загружать несколько ядер, хотя байткод Python по‑прежнему защищён GIL.Ещё один путь — писать свои C‑расширения или использовать Cython и напрямую управлять тем, где отпускать GIL.Ключевые ограничения и архитектурные выводыGIL делает многопоточность в CPython плохим выбором для CPU‑bound workloads — для них лучше процессы/нативный код;для I/O‑bound: выбираем между threading и asyncio/ASGI‑фреймворками, в зависимости от экосистемы и удобства разработки;важно понимать, где именно у тебя «параллельность» (процессы, потоки, корутины, нативные библиотеки) и как это влияет на модель ошибок, отладку и деплой.Формулировка уровня seniorВ CPython я могу распараллеливать I/O‑bound задачи потоками или async/await, а CPU‑bound — через процессы или нативный код, который отпускает GIL. При выборе подхода я учитываю накладные расходы на IPC, модель отказов, интеграцию с используемым фреймворком и то, насколько прозрачно это будет поддерживаться командой.

Question 56

Как устроен CPython? Что такое bytecode, dis, compile()?

Accepted Answer

На уровне senior полезно показать, что вы понимаете хотя бы верхнеуровневую архитектуру CPython и умеете использовать инструменты, которые она предоставляет.Кратко об архитектуре CPythonреализация интерпретатора и стандартной библиотеки написана на C;исходный код Python‑модулей проходит через этапы: парсинг → AST → байткод → исполнение стековой виртуальной машиной;объекты (числа, строки, списки, классы и т.п.) — структуры на C, живущие в куче и управляемые подсчётом ссылок + GC для циклов;GIL синхронизирует доступ потоков к этим объектам.Что такое байткодБайткод — это последовательность инструкций, которую исполняет виртуальная машина CPython (stack‑based VM). При первом импорте модуля код компилируется в объект code, который содержит байткод, константы, список переменных и т.д., и может кешироваться в __pycache__.def add(a, b):
   return a + bМожно посмотреть байткод этой функции через модуль dis:import dis

dis.dis(add)Вы увидите последовательность инструкций VM (LOAD_FAST, BINARY_ADD, RETURN_VALUE и т.п.), которая и есть байткод.Модуль disМодуль dis занимается дизассемблированием байткода:позволяет увидеть, во что компилятор превратил ваш высокоуровневый код;помогает исследовать производительность, оптимизации, изменение семантики между версиями Python;полезен при написании низкоуровневых оптимизаций или отладке «магии» (декораторы, метаклассы, автогенерируемый код).Функция compile()Встроенная compile() даёт явный доступ к шагу компиляции:src = "a + b"
code_obj = compile(src, filename="", mode="eval")
result = eval(code_obj, {"a": 1, "b": 2})
print(result)  # 3Она принимает строку кода, имя файла (для сообщений об ошибках) и режим (eval, exec, single) и возвращает объект code, который можно исполнять через eval/exec или исследовать.Практические применения:динамическая генерация кода (DSL, шаблоны, конфиги);инструменты анализа (линтеры, форматтеры, статический анализ), которым нужен AST/байткод;оптимизации с предкомпиляцией выражений.Формулировка для собеседованияCPython — это стековая байткод‑виртуальная машина, написанная на C. Исходный код Python проходит парсинг и компиляцию в байткод, который хранится в объектах code и исполняется интерпретатором. Модуль dis позволяет посмотреть эти инструкции и понять, во что превращается ваш код. Функция compile() даёт программный доступ к шагу компиляции: можно из строки кода получить объект code и потом исполнять или анализировать его. На уровне senior важно уметь использовать эти механизмы хотя бы для диагностики и исследований.

Question 57

Что такое @property? Как реализовать кэшируемое свойство?

Accepted Answer

Что такое @property@property — это встроенный дескриптор, который позволяет объявить метод, но использовать его как атрибут без скобок:class User:
   def __init__(self, first_name, last_name):
       self.first_name = first_name
       self.last_name = last_name
       
   @property
   def full_name(self):
       return f"{self.first_name} {self.last_name}"Теперь u.full_name вызывает геттер, но синтаксически выглядит как обычное поле. За этим стоит дескриптор: у объекта property определены __get__, __set__, __delete__ (для сеттеров/делитеров).Преимущества:инкапсуляция: можно начать с обычного поля, потом заменить его на вычисляемое свойство без изменения внешнего API;валидация и побочные эффекты при чтении/записи/удалении;совместимость с дескрипторной моделью Python.Кэшируемое (ленивое) свойствоЗадача: вычислить значение один раз при первом доступе и дальше возвращать кэш, не пересчитывая. Классический паттерн — вычислить и сохранить результат в __dict__ экземпляра:class cached_property:
   def __init__(self, func):
       self.func = func
       self.__doc__ = getattr(func, "__doc__")
       self.name = func.__name__
       
   def __get__(self, instance, owner):
       if instance is None:
           return self
       if self.name in instance.__dict__:
           return instance.__dict__[self.name]
       value = self.func(instance)
       instance.__dict__[self.name] = value
       return value

class Report:
   @cached_property
   def heavy_stats(self):
       print("computing...")
       # дорогой расчёт
       return {"value": 42}Вызовы r.heavy_stats впервые приведут к расчёту и записи в __dict__, последующие — просто вернут кэш.Начиная с Python 3.8 есть готовый functools.cached_property, реализующий тот же паттерн. Senior‑разработчик должен понимать идею: дескриптор, который после первого вычисления «замораживает» результат в экземпляре.Нюансы и расширенияесли объект изменяем и кэш нужно сбрасывать при изменении других полей, нужно явно инвалидацию (удалять ключ из __dict__ или переинициализировать экземпляр);в многопоточной среде возможны гонки при одновременном первом доступе — для критичных кейсов нужен lock вокруг вычисления;можно комбинировать с @property.setter, если нужно вручную обновлять кэш.Формулировка для собеседования@property — это дескриптор, который позволяет объявить геттер/сеттер/делитер и работать с ними как с обычным атрибутом. Кэшируемое свойство реализуется либо через собственный дескриптор, который при первом доступе вычисляет значение и записывает его в instance.__dict__, либо через готовый functools.cached_property. На уровне senior ожидают понимание того, что за этим стоит дескрипторный протокол и как организовать инвалидацию и потокобезопасность при необходимости.

Question 58

Как работает import изнутри? importlib, sys.modules, circular imports?

Accepted Answer

Импортная машина и sys.modulesКогда интерпретатор видит import package.module as m, он делает примерно следующее:проверяет, есть ли модуль в sys.modules; если да, просто возвращает уже загруженный объект;если нет, запускает импортную машину: проходит по sys.meta_path, вызывая find_spec у finder’ов, чтобы найти спецификацию модуля (откуда и как его грузить);использует loader из spec, чтобы загрузить модуль (прочитать файл, скомпилировать, выполнить байткод);создаёт объект модуля, регистрирует его в sys.modules ещё до выполнения кода, затем исполняет его тело в пространстве имён модуля.Ключевой момент: модуль попадает в sys.modules до того, как его код полностью выполнен. Это важно для понимания циклических импортов.importlibПакет importlib даёт программный доступ к импортной машине:importlib.import_module(name) — эквивалент __import__, но с более приятным API;importlib.util.find_spec, importlib.machinery — работа со spec, кастомные loader’ы и finder’ы;reload модулей, динамический импорт по строке и т.п.На уровне senior полезно понимать importlib хотя бы настолько, чтобы:делать ленивый/отложенный импорт (для снижения времени старта или избегания тяжёлых зависимостей);писать плагинообразные системы, подгружающие модули по имени/пути.Циклические импорты (circular imports)Циклический импорт возникает, когда:модуль A при инициализации импортирует B;модуль B при инициализации импортирует A;один из модулей в момент обращения к атрибутам другого видит его в частично инициализированном состоянии (атрибутов ещё нет).Поскольку модуль регистрируется в sys.modules до полного исполнения кода, второй участник цикла может получить объект модуля, в котором ещё не выполнены нижние строки, и попытка взять из него что‑то (класс, функцию) приведёт к AttributeError или неожиданному поведению.Как обходить циклические импортыпереносить импорт внутрь функции/метода (lazy import) там, где это допустимо по производительности;выделять общий код в третий модуль и импортировать его из обоих;реорганизовывать архитектуру: отделять слои (API, сервисы, репозитории, модели), избегая двунаправленных зависимостей между слоями;для аннотаций типов использовать строковые типы или from __future__ import annotations, чтобы не создавать реальные зависимости на момент импорта.Формулировка уровня seniorВ Python импорт реализован через импортную машину: модуль ищется через sys.meta_path/sys.path, загружается loader’ом, регистрируется в sys.modules и после этого исполняется. sys.modules — это кеш уже загруженных модулей, из которого берутся все последующие импорты. Пакет importlib даёт программный доступ к этим механизмам — динамический импорт, поиск spec, кастомные загрузчики. Циклические импорты возникают из‑за того, что модуль может быть виден в sys.modules ещё до завершения инициализации; решаются они реорганизацией зависимостей, lazy‑импортами и выносом общих частей в отдельные модули. На практике я стараюсь проектировать модули и слои так, чтобы направленность зависимостей была односторонней и циклов не возникало.

Question 59

Какие задачи решали с помощью метаклассов в продакшене?

Accepted Answer

На senior‑уровне вопрос про метаклассы — это скорее вопрос про архитектурные решения и trade‑offs, чем про синтаксис.Типичные задачи, которые оправдывают метаклассыORM/модели данных и декларативные схемыКлассический кейс — собственные или расширенные модели поверх ORM/валидаторов. При объявлении класса модели метакласс:собирает атрибуты‑поля (Field, Column и т.п.) в структуру метаданных;генерирует методы (например, create_table, to_dict, валидацию);регистрирует модель в реестре схем.Пример из реального мира — подход Django ORM и многих других фреймворков.Автоматическая регистрация компонентов/плагиновКогда у вас расширяемая система (команды CLI, обработчики событий, плагины), удобно, чтобы каждый новый подкласс автоматически регистрировался в реестре:class CommandMeta(type):
   registry = {}
   
   def __new__(mcls, name, bases, attrs):
       cls = super().__new__(mcls, name, bases, attrs)
       if not attrs.get("abstract", False):
           CommandMeta.registry[cls.name] = cls
       return cls

class Command(metaclass=CommandMeta):
   abstract = True
   name: strКаждый конкретный класс команды сам себя регистрирует; основной код CLI потом может находить и запускать команды по имени без ручной регистрации. Метакласс здесь заменяет явный вызов регистратора в каждом классе и гарантирует консистентность.Навязывание контрактов и инвариантовМетаклассы позволяют проверить класс на этапе его объявления:проверить наличие обязательных методов или атрибутов;убедиться, что сигнатуры соответствуют базовому интерфейсу;запретить определённые шаблоны (например, видимые глобальные побочные эффекты в классе определённого типа).Это полезно в инфраструктурных слоях, где множество команд/обработчиков должны соответствовать строгому контракту, и вы хотите получать ошибку при старте приложения, а не в рантайме под нагрузкой.DSL‑подобные APIИногда метаклассы используют, чтобы превращать декларативное объявление классов в данные для движка правил, workflow‑движка и т.п. Например, класс, описывающий шаги бизнес‑процесса, при объявлении конвертируется в граф состояний и транзишнов, а сам класс используется как удобный синтаксис для конфигурации.Как об этом говорить на собеседованииХороший ответ senior‑уровня включает:1–2 конкретных реальных кейса, где вы использовали или расширяли метаклассы (ORM, фреймворк, плагинная система, DSL);обоснование, почему метакласс был выбран вместо альтернатив (декораторы, фабрики, регистрация через явные вызовы);осознание рисков: усложнение отладки, скрытая магия, важность хорошей документации и тестов.Типовая формулировкаВ продакшене я использовал метаклассы для инфраструктурных задач: авто‑регистрации команд CLI и обработчиков событий, чтобы новые классы автоматически появлялись в реестре; а также для декларативного описания моделей/конфигов, где метакласс собирал поля и генерировал вспомогательные методы. В каждом случае мы взвешивали сложность: если требовалось массово обрабатывать семейство классов на этапе объявления, метакласс был оправдан; в остальных местах я предпочитаю более прозрачные техники — декораторы, фабрики, явную регистрацию.

Question 60

Как управлять памятью при работе с большими объёмами данных?

Accepted Answer

Управление памятью для больших данных в Python — это комбинация понимания модели объектов и осознанного выбора структур/алгоритмов.Потоковая обработка и ленивость вместо загрузки всего в памятьчтение файлов/стримов построчно или чанками (итерация по файлу, iter с буфером, read(n));использование генераторов вместо списков там, где результат не нужно хранить целиком ((f(x) for x in data) вместо [f(x) for x in data]);pipeline‑подход: каждая стадия получает итератор и отдаёт итератор, не материализуя промежуточные коллекции.Выбор подходящих структур данныхвместо списка чисел — array, numpy.ndarray или pandas‑колонки, хранящие данные компактно в виде плотных буферов;избегать вложенных Python‑объектов (списки словарей словарей), если можно перейти на табличное или колонночное представление;использовать сжатые форматы хранения (Parquet, Feather) и подгружать только нужные колонки/строки.Memory‑mapped файлы и частичный доступДля очень больших файлов можно использовать memory‑mapping (mmap, поддержка в numpy.memmap): операционная система отображает файл в адресное пространство процесса, а вы обращаетесь к его частям как к массиву, не загружая всё содержимое в память сразу. Это особенно полезно для больших бинарных матриц/векторов.Избегание лишних копийследить за местами, где создаются временные списки/словаря/строки, которые можно заменить на итераторы или in‑place операции;в numpy использовать вьюшки вместо копий, где возможно (view, срезы без копирования);быть осторожным с конкатенацией строк в цикле — лучше использовать join или буферы.Управление жизненным циклом объектовявно разрывать ссылки на большие структуры, когда они больше не нужны (присвоить None, убрать из контейнеров), чтобы GC мог их освободить;делить обработку на этапы, между которыми крупные объекты выживают как можно меньше;при необходимости использовать gc.collect() после крупного этапа, если известно, что освободилось много объектов и пауза предсказуема.Инструменты контроля и диагностикиНа senior‑уровне важно не только проектировать код, но и проверять гипотезы: использовать tracemalloc, memory_profiler, objgraph, чтобы находить утечки и лишние копии, понимать, какие объекты занимают больше всего памяти и как меняется их количество во времени.Формулировка для собеседованияПри работе с большими данными я стараюсь: обрабатывать их потоково и лениво, а не загружать всё в память; выбирать плотные структуры (numpy/pandas/array), избегать лишних копий и временных коллекций; при необходимости использовать memory‑mapped файлы; и контролировать реальное потребление памяти через профилировщики, корректируя архитектуру, если вижу «горячие точки».

Question 61

Что такое __slots__ и как это влияет на производительность?

Accepted Answer

Что делает __slots__ техническиПо умолчанию у экземпляра пользовательского класса есть словарь __dict__, где хранятся все его атрибуты. Это даёт гибкость, но стоит памяти и косвенного обращения через хеш‑таблицу.Если в классе объявить __slots__, интерпретатор:перестаёт создавать __dict__ для экземпляров (если его явно не включили в __slots__);выделяет для каждого имени в __slots__ фиксированное место в структуре объекта (как поля в C‑структуре).class Point:
   __slots__ = ("x", "y")
   def __init__(self, x, y):
       self.x = x
       self.y = yЭкземпляр Point будет занимать меньше памяти, чем аналогичный класс без __slots__, и не позволит динамически добавить новый атрибут (p.z = ... приведёт к AttributeError).Влияние на производительностьПамять: для большого числа однотипных объектов экономия может быть существенной (десятки процентов на экземпляр), особенно если в объекте всего несколько полей.Скорость: доступ к атрибуту через фиксированный offset обычно немного быстрее, чем через словарь; выигрыш небольшой, но на горячих путях может быть заметен.Ограничения и подводные камнинельзя добавлять произвольные атрибуты, не указанные в __slots__ (если не включить "__dict__" в список слотов);слоты и наследование: при сложной иерархии важно аккуратно проектировать __slots__ в базах и наследниках, объединять их и помнить, что слоты не наследуются «автоматически» как ожидают многие;если нужны weakref’ы, нужно явно добавить "__weakref__" в __slots__;в обычном бизнес‑коде для десятков объектов выгода зачастую не оправдывает усложнение модели классов.Когда __slots__ уместенмассовые структуры: миллионы однотипных объектов (DTO, ноды AST, элементы графа, внутренние структуры в высоконагруженном коде);слои, где важно жёстко фиксировать API объекта и не допускать динамических атрибутов (раннее выявление опечаток/ошибок);в сочетании с dataclasses (slots=True), где генерация кода и слотов берётся на себя стандартной библиотекой.Формулировка уровня senior__slots__ — это способ сказать интерпретатору: «экземпляры этого класса имеют фиксированный набор полей, словарь атрибутов им не нужен». Это уменьшает память и иногда ускоряет доступ к атрибутам, но усложняет наследование и лишает гибкости динамических атрибутов. В продакшене я применяю __slots__ точечно — в горячих местах и массовых структурах, чаще через @dataclass(slots=True), чем руками.

Question 62

Способы профилирования Python-кода (cProfile, py-spy, memory_profiler)?

Accepted Answer

Senior‑ответ важен не перечнем инструментов, а пониманием, когда к какому подходу тянуться.CPU-профилирование: cProfile + pstatscProfile — встроенный детерминированный профилировщик CPU:инструментирует каждый вызов функции, считает общее и собственное время;даёт подробный call graph, но вносит заметный overhead;отлично подходит для локального анализа, бенчей и одноразовых исследований.import cProfile, pstats

pr = cProfile.Profile()
pr.enable()
# ... код для профилирования ...
pr.disable()
stats = pstats.Stats(pr)
stats.sort_stats("cumulative").print_stats(20)Часто вывод импортируют в инструменты визуализации (snakeviz, gprof2dot + Graphviz) для удобного анализа.Сэмплирующие профайлеры: py-spy и аналогиpy-spy — внешний сэмплирующий профилировщик:подключается к уже запущенному процессу, не требует изменения кода;регулярно «снимает стек» (sampling), строит flamegraph и статистику по функциям;имеет куда меньший overhead и подходит для продакшена (осторожно, но реально применимо);умеет работать с многопоточными/async‑приложениями.Плюс сэмплирующих профайлеров в том, что они не искажают нагрузку столь сильно, как детерминированные, и позволяют подобрать «горячие» участки на бою.Память: memory_profiler, tracemalloc, objgraphmemory_profiler — измеряет использование памяти по строкам/функциям; часто используется через декоратор @profile или командную утилиту; позволяет увидеть, какие участки кода дают рост RSS процесса.tracemalloc (стандартная библиотека) отслеживает выделения памяти в Python‑объектах, даёт срезы по top‑allocations, умеет сравнивать снимки до/после, помогает в поиске утечек и неожиданных аллокаций.objgraph и подобные библиотеки полезны для анализа графа объектов: какие типы растут, какие объекты держат ссылки на другие.Практический workflowТипичный подход senior‑разработчика:сначала — высокоуровневые метрики (APM, метрики latency/CPU/RSS), чтобы понять, есть ли вообще проблема;для CPU — локально cProfile на репрезентативном нагрузочном сценарии, а если нужно — py-spy или аналог на staging/production для уточнения «горячих» функций;для памяти — tracemalloc/memory_profiler на подозрительных путях, сравнение снимков, поиск мест, где количество объектов растёт и не падает.Формулировка для собеседованияДля профилирования CPU я обычно начинаю с cProfile + pstats локально, а при необходимости использую сэмплирующий профайлер вроде py-spy, который можно подключить даже к живому процессу и посмотреть flamegraph с меньшим overhead’ом. Для памяти — memory_profiler и tracemalloc, иногда с objgraph, чтобы увидеть, какие объекты растут. Дальше уже принимаю архитектурные решения: менять алгоритм, структуру данных, точки кеширования и т.п.

Question 63

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

Accepted Answer

Классический способ: класс с __enter__ и __exit__Контекстный менеджер — это объект, реализующий методы __enter__(self) и __exit__(self, exc_type, exc, tb). Конструкция with вызывает эти методы по протоколу:перед входом в блок with вызывается __enter__; его результат присваивается переменной после as;при выходе из блока (нормальном или по исключению) вызывается __exit__;если __exit__ возвращает True, исключение подавляется.class managed_resource:
   def __init__(self, name):
       self.name = name
       self.handle = None
       
   def __enter__(self):
       print(f"acquire {self.name}")
       self.handle = open(self.name, "w")
       return self.handle
       
   def __exit__(self, exc_type, exc, tb):
       print(f"release {self.name}")
       if self.handle:
           self.handle.close()
       # вернём False, чтобы не подавлять исключения
       return False

with managed_resource("log.txt") as f:
   f.write("hello")Этот способ удобен, когда вам нужен полноценный объект с состоянием и, возможно, повторным использованием.Функциональный способ: contextlib.contextmanagerВторой способ — описать контекстный менеджер как генератор и обернуть его @contextlib.contextmanager. В этом случае:код до yield соответствует __enter__;значение, переданное через yield, — это то, что попадёт в as;код после yield — это __exit__; он выполнится всегда, даже при исключении.from contextlib import contextmanager

@contextmanager
def managed_resource(name):
   print(f"acquire {name}")
   f = open(name, "w")
   try:
       yield f  # сюда попадает переменная после 'as'
   finally:
       print(f"release {name}")
       f.close()

with managed_resource("log.txt") as f:
   f.write("hello")Такой способ чаще используют, когда нужен лёгкий одноразовый менеджер без отдельного класса, особенно когда логика инициализации/финализации компактна.Отличия и выборкласс даёт больше контроля, возможности наследования, хранения состояния и тестирования по отдельности;генераторный подход с @contextmanager — более лаконичен для простых кейсов, но скрывает детали протокола и чуть сложнее отлаживается при большой логике.Формулировка для собеседованияСвой контекстный менеджер можно реализовать классом с методами __enter__/__exit__ или функцией‑генератором под @contextmanager. В первом случае мы явно работаем с протоколом, во втором — используем более декларативный синтаксис: всё, что до yield, — настройка, всё, что после, — гарантированная финализация ресурса в блоке finally.

Question 64

Как работает GC с циклическими ссылками?

Accepted Answer

Проблема циклических ссылок при подсчёте ссылокВ CPython у каждого объекта есть счётчик ссылок; когда он падает до нуля, объект немедленно деаллоцируется. Однако если два или больше объектов ссылаются друг на друга, их счётчики никогда не опустятся до нуля, даже если на этот цикл больше нельзя добраться из программы.a = {}
b = {}
a["b"] = b
b["a"] = a
del a, b  # внешних ссылок больше нет, но объекты держат друг другаС точки зрения простого reference counting оба словаря «живы» бесконечно. Чтобы такие циклы не накапливались, поверх подсчёта ссылок работает дополнительный сборщик мусора.Генерационный GC и поиск цикловGC в CPython специализируется на обнаружении циклических ссылок. Он делит объекты на поколения (0 — молодые, 1 и 2 — более старые) и периодически запускает сборку:младшее поколение сканируется чаще, так как там много короткоживущих объектов;старшие поколения — реже, чтобы не тратить ресурсы на долгоживущие объекты.Алгоритм упрощённо выглядит так:выбрать множество кандидатов на сборку (обычно контейнеры: списки, словари, пользовательские объекты), у которых могут быть циклы;построить граф ссылок между ними;определить, какие объекты достижимы из «корней» (глобальные переменные, стеки вызовов, регистрированные объекты и т.п.);те объекты, которые достижимы только через друг друга, но не от корней, считаются мусором и могут быть освобождены, даже если их счётчики ссылок > 0.Роль модуля gcМодуль gc даёт управление над этим механизмом:gc.get_threshold() / gc.set_threshold() — пороги, при превышении которых запускается сборка поколений;gc.collect() — принудительная сборка, возвращает количество собранных объектов;gc.get_objects(), gc.get_stats() — диагностика и отладка утечек;gc.garbage — список объектов, которые не удалось корректно финализировать (например, из‑за __del__ в цикле).Циклы и __del__Особый случай — циклы, в которые вовлечены объекты с определённым __del__. Уничтожать такие объекты сложно: порядок вызова финализаторов может быть неопределённым, а внутри __del__ могут быть побочные эффекты. Поэтому GC может не собирать такие циклы автоматически, перекладывая их в gc.garbage; этим нужно управлять вручную.Формулировка уровня seniorВ CPython основной механизм управления памятью — подсчёт ссылок, который не умеет сам по себе собирать циклы. Поверх него работает генерационный GC, который периодически сканирует контейнеры, строит граф ссылок и вычищает группы объектов, достижимые только друг через друга. Через модуль gc можно настраивать пороги, принудительно запускать сборку и диагностировать «висящие» объекты, особенно когда в циклах участвуют объекты с __del__.

Вопросы для собеседований с группировкой по стеку и уровню

Собери свой маршрут подготовки к собеседованию!

Выбери технологию, по которой готовишься к собеседованию

Выбери уровень экспертности, на который рассчитываешь

Начни сфокусированную подготовку к собеседованию