# Вопросы на собеседовании по Python

211 вопросов с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/python

## Типы данных и коллекции

### В чём разница между списком (list) и кортежем (tuple)?

Оба хранят упорядоченную последовательность произвольных объектов, но **список изменяемый**, а **кортеж неизменяемый**: после создания кортеж нельзя дополнить или переприсвоить его элементы. Из неизменяемости следуют практические отличия. **Кортеж хешируем**, если хешируемы все его элементы, поэтому может быть ключом словаря или элементом множества, а **список — нет**. **Кортеж не хранит запаса под рост**, тогда как **список — динамический массив с over-allocation** под будущие вставки. По документации **список** обычно используют **для однородных элементов**, **кортеж** — **для разнородных данных** фиксированной структуры. Граница: неизменяемость кортежа неглубокая. Если внутри лежит список, содержимое этого списка менять можно, а такой кортеж нехешируем.

Источник: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range

### Какие типы в Python изменяемые, а какие неизменяемые, и как это влияет на работу с ними?

Неизменяемые (immutable) встроенные типы: **int**, **float**, **bool**, **complex**, **str**, **bytes**, **tuple**, **frozenset**, **frozendict** (с Python 3.15), а также **None**. Изменяемые (mutable): **list**, **dict**, **set**, **bytearray** и **большинство пользовательских объектов**. Переменная в Python — это имя, связанное с объектом, а не ячейка с самим значением. Операция над неизменяемым объектом создаёт новый объект (например, `s += "x"` для строки возвращает новую строку), а над изменяемым — правит объект на месте, поэтому все имена, ссылающиеся на него, увидят изменение. Только хешируемые (как правило неизменяемые) объекты можно класть в set и использовать как ключи dict. Граница: неизменяемость контейнера не глубокая. Кортеж со списком внутри остаётся кортежем, но его значение меняется вместе со списком, и такой кортеж нехешируем.

Источник: https://docs.python.org/3/reference/datamodel.html#objects-values-and-types

### Как устроен словарь (dict) под капотом и какова сложность операций с ним?

`dict` в CPython — хеш-таблица, поэтому чтение, вставка и удаление по ключу в среднем занимают O(1), а в худшем случае при массовых коллизиях O(n).

Источник: https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

## Модель объектов и память

### В чём разница между операторами is и ==?

`==` сравнивает значения через `__eq__`, а `is` проверяет, что это один и тот же объект (идентичность, определяемая через `id()`).

Источник: https://docs.python.org/3/reference/expressions.html#is

### В чём разница между поверхностным (copy) и глубоким (deepcopy) копированием?

**copy.copy** делает поверхностную копию: для изменяемого контейнера создаётся новый контейнер верхнего уровня, но вложенные объекты не копируются — на них ставятся те же ссылки. Изменение вложенного изменяемого объекта будет видно и в оригинале, и в копии: после `a = [[1], [2]]; b = copy.copy(a); b[0].append(9)` список `a[0]` тоже равен `[1, 9]`.

Источник: https://docs.python.org/3.15/library/copy.html

### Почему в CPython объект с циклической ссылкой не освобождается подсчётом ссылок и что его освобождает?

Счётчик ссылок объектов в цикле не доходит до нуля, поэтому их освобождает циклический сборщик мусора модуля **gc**. Основной механизм CPython — **подсчёт ссылок** (reference counting): каждый объект хранит счётчик, и когда он достигает нуля, объект освобождается сразу (кроме бессмертных, immortal, объектов). Если объекты ссылаются друг на друга и снаружи недостижимы, их счётчики остаются положительными, и подсчёт ссылок их не освободит. Эти циклы находит и собирает **gc**. В сборке по умолчанию (с GIL) он делит объекты на три поколения (0, 1, 2): молодые проверяются часто и дёшево, старшие реже; пороги показывает `gc.get_threshold()`.

Источник: https://docs.python.org/3.15/library/gc.html

## Функции, декораторы, генераторы, контекстные менеджеры

### Что такое декоратор и как он работает под капотом?

**Декоратор** — это вызываемый объект, который принимает функцию (или класс) и привязывает к её имени то, что вернул, обычно новую функцию-обёртку с дополнительным поведением. Синтаксис `@decorator` над определением — синтаксический сахар: `func = decorator(func)`. Он выполняется в момент определения функции, а не при её вызове.

Источник: https://docs.python.org/3.15/reference/compound_stmts.html#function-definitions

### Как написать декоратор, принимающий параметры?

Нужен дополнительный уровень вложенности — **«фабрика декораторов»**: внешняя функция принимает параметры и возвращает собственно декоратор, тот принимает функцию и возвращает wrapper. Запись `@retry(times=3)` сначала вызывает `retry(times=3)`, получает декоратор и затем применяет его к функции.

Источник: https://docs.python.org/3.15/reference/compound_stmts.html#function-definitions

### Зачем при написании декораторов нужен functools.wraps?

Чтобы обёртка сохранила имя, docstring, аннотации и ссылку `__wrapped__` исходной функции. Без него снаружи функция выглядит как wrapper: у неё имя `wrapper`, пустой или чужой docstring и потерянные аннотации. Это ломает интроспекцию, автогенерацию документации и отладку.

Источник: https://docs.python.org/3.15/library/functools.html#functools.wraps

### Что такое замыкание (closure) и как оно устроено?

**Замыкание** — это вложенная функция, которая запоминает и продолжает использовать переменные из объемлющей области видимости даже после того, как внешняя функция завершилась. Такие свободные переменные хранятся не в глобальной области, а в специальных ячейках (cell), на которые ссылается объект функции через `__closure__`.

Источник: https://docs.python.org/3.15/reference/executionmodel.html#binding-of-names

### В чём разница между итерируемым объектом (iterable) и итератором (iterator)?

**Итерируемый объект** — это то, по чему можно пройти циклом for; он реализует `__iter__` (или `__getitem__` с семантикой последовательности), и `iter()` от него возвращает итератор. **Итератор** — объект, который реализует `__next__` (выдаёт следующий элемент или бросает StopIteration) и `__iter__`, возвращающий самого себя. Список, кортеж, словарь, строка — итерируемые, но не итераторы: каждый вызов `iter()` над ними даёт новый независимый итератор, поэтому по ним можно проходить многократно. Итератор одноразовый: после исчерпания он остаётся пустым, и каждый следующий `next()` снова бросает StopIteration. Именно итератор хранит состояние обхода (текущую позицию).

Источник: https://docs.python.org/3.15/glossary.html#term-iterator

## ООП

### Что такое ООП и каковы его основные принципы?

**ООП** — парадигма, в которой программа строится из объектов, объединяющих данные и поведение. Классические принципы: **инкапсуляция** — сокрытие внутреннего состояния за интерфейсом, чтобы менять реализацию не ломая клиентов; **наследование** — переиспользование и специализация поведения базового класса в производном; **полиморфизм** — единый интерфейс для разных типов, когда вызов метода зависит от фактического объекта; часто добавляют **абстракцию** — выделение существенного и сокрытие деталей.

Источник: https://docs.python.org/3.15/tutorial/classes.html#private-variables

### Что такое принципы SOLID? Кратко опишите каждый.

SOLID — акроним для пяти принципов проектирования (S, O, L, I, D), а не правила языка Python.

Источник: https://en.wikipedia.org/wiki/SOLID

### В чём разница между методами `__new__` и `__init__` и каков порядок их вызова?

`__new__` — статический метод, отвечающий за создание и возврат нового экземпляра; он вызывается первым и получает сам класс (cls). `__init__` — инициализирует уже созданный экземпляр (self), заполняя его атрибуты, и должен вернуть None: любое другое значение вызывает TypeError.

Источник: https://docs.python.org/3.15/reference/datamodel.html#object.__new__

### Что такое MRO и как Python решает проблему ромбовидного наследования?

**MRO** (Method Resolution Order) — это порядок, в котором Python ищет атрибут или метод по цепочке классов при наследовании. При множественном наследовании возможна «ромбовидная» проблема: два родителя имеют общего предка, и неясно, чей метод выбрать. Python строит MRO по алгоритму C3-линеаризации, который даёт единый детерминированный порядок, сохраняющий приоритет потомков над предками и порядок базовых классов слева направо. Именно по MRO работает `super()`: он вызывает следующий класс в линеаризации, а не «жёстко» родителя, что и делает кооперативное множественное наследование корректным. Посмотреть порядок можно через `ClassName.mro()` или `ClassName.__mro__`.

Источник: https://docs.python.org/3.15/howto/mro.html

## GIL, потоки и процессы

### Что такое GIL, зачем он нужен и какие проблемы создаёт?

**GIL** (Global Interpreter Lock) — механизм CPython, который гарантирует, что в один момент байт-код Python исполняет только один поток. Он нужен для простоты реализации: объектная модель, включая критичные встроенные типы вроде `dict`, становится неявно безопасной при конкурентном доступе. Цена в том, что потоки теряют большую часть параллелизма многопроцессорных машин. Поэтому потоки не ускоряют CPU-bound код на чистом Python, но полезны для I/O-bound: при вводе-выводе GIL всегда отпускается.

Источник: https://docs.python.org/3.15/glossary.html#term-global-interpreter-lock

### В чём фундаментальное отличие процесса от потока на уровне ОС?

**Процесс** — исполняющаяся программа со своим виртуальным адресным пространством, открытыми дескрипторами системных объектов и другими ресурсами; у него есть хотя бы один поток. **Поток** — единица внутри процесса, которой ОС выделяет процессорное время: все потоки процесса разделяют его адресное пространство и ресурсы, а у каждого потока свои контекст (включая регистры), стек и приоритет планирования.

Источник: https://learn.microsoft.com/en-us/windows/win32/procthread/about-processes-and-threads

### Когда выбирать threading, а когда multiprocessing в Python?

**Ключ — характер нагрузки и сборка Python.** Для I/O-bound задач (сеть, диск, ожидание БД) подходят потоки: по документации `ThreadPoolExecutor` чаще всего используют, чтобы перекрывать ввод-вывод, а не вычисления, потому что при вводе-выводе GIL отпускается. Для структурированного сетевого и другого I/O-кода также подходит asyncio. Для CPU-bound кода на чистом Python в сборке с GIL потоки не помогают, и берут `multiprocessing` или `ProcessPoolExecutor`: он обходит GIL, но выполняемые и возвращаемые объекты должны быть picklable, то есть данные сериализуются.

Источник: https://docs.python.org/3.15/library/concurrent.futures.html

## Асинхронность (asyncio)

### Что такое asyncio, корутина и event loop?

**asyncio** — библиотека для конкурентного кода на синтаксисе async/await. **Корутина** — результат вызова функции, объявленной как `async def`: сам вызов код не запускает, `main()` лишь возвращает объект корутины, а выполняется она через `asyncio.run()`, `await` или обёртку в Task. **Event loop** (цикл событий) использует кооперативное планирование: он исполняет одну Task за раз, а пока Task ждёт завершения Future, цикл запускает другие Task, колбэки или операции ввода-вывода.

Источник: https://docs.python.org/3.15/library/asyncio-task.html

### Как работают async/await под капотом и как это связано с генераторами?

Корутина, как и генератор, — **приостанавливаемая функция**: у корутины есть методы, аналогичные методам генератора, но в отличие от генераторов она не поддерживает итерацию напрямую, а её выполнением управляют через итератор, который возвращает `__await__()`. Выражение `await` допустимо над awaitable-объектом; в asyncio основные виды — корутины, Task и Future. Когда корутина в Task ждёт Future, Task приостанавливает корутину, цикл событий в это время запускает другие Task, а когда Future завершится, выполнение корутины возобновляется.

Источник: https://docs.python.org/3.15/reference/datamodel.html#coroutines

### Чем asyncio отличается от многопоточности и когда что выбирать?

Главное отличие — кто и когда переключает выполнение. В потоках интерпретатор может переключиться между любыми двумя инструкциями байт-кода, поэтому составные операции над общими данными (вроде `i = i+1`) нужно защищать блокировками. В asyncio планирование **кооперативное**: цикл событий исполняет одну Task за раз и переключается на другие, пока текущая Task ждёт Future, поэтому между точками ожидания код не прерывается.

Источник: https://docs.python.org/3.15/library/asyncio.html

## Исключения и обработка ошибок

### Как устроен механизм обработки исключений в Python (try/except/else/finally)?

Код в **try** выполняется под защитой: если в нём возникло исключение, Python ищет подходящий обработчик среди блоков **except** по порядку, сверху вниз, и выполняет первый, чей тип подходит (или его базовый класс). Если обработчика нет, исключение необработанное, и выполнение останавливается с сообщением об ошибке. Блок **else** выполняется, если в try исключения не было; он лучше, чем лишний код внутри try, потому что не даёт случайно поймать исключение, которое поднял не защищаемый код. Блок **finally** выполняется последним перед завершением try независимо от того, было исключение или нет, поэтому в нём освобождают ресурсы; если исключение не обработано, оно пробрасывается дальше уже после finally. `raise` пробрасывает исключение, а `raise ... from exc` явно указывает причину в цепочке исключений; `from None` отключает автоматическую цепочку.

Источник: https://docs.python.org/3.15/tutorial/errors.html

### В чём разница между except: и except Exception:?

**Голый `except:`** без выражения должен стоять последним и по справочнику языка ловит любое исключение, а **`except Exception:`** — это wildcard, который ловит почти всё, кроме исключений вне ветки `Exception`. Такие исключения обычно не обрабатывают, потому что они сигнализируют, что программа должна завершиться: `SystemExit` (его поднимает `sys.exit()`), `KeyboardInterrupt` (Ctrl+C), а также `GeneratorExit` и `BaseExceptionGroup`, прямые наследники `BaseException`. Голый `except:` перехватывает и их, поэтому мешает нормально остановить программу.

Источник: https://docs.python.org/3.15/library/exceptions.html#exception-hierarchy

### Почему часто предпочитают try/except предварительной проверке через if (EAFP против LBYL)?

Потому что у LBYL между проверкой и действием есть окно, а EAFP его избегает. **LBYL** (Look Before You Leap) сначала явно проверяет предусловия через `if`; **EAFP** (Easier to Ask Forgiveness than Permission) предполагает, что ключи или атрибуты существуют, и ловит исключение, если предположение оказалось ложным. В многопоточной среде `if key in mapping: return mapping[key]` может упасть, если другой поток удалил ключ после проверки, но до обращения; по глоссарию это решают блокировками или стилем EAFP. Глоссарий называет EAFP «clean and fast» и общим для Python стилем.

Источник: https://docs.python.org/3.15/glossary.html#term-EAFP

## Веб-фреймворки (FastAPI, Django, Flask)

### Что такое WSGI и ASGI и в чём разница между ними?

**WSGI** — стандарт Python для совместимости веб-серверов, фреймворков и приложений: по PEP 3333 это простой и универсальный интерфейс между сервером и приложением. WSGI-приложение — один синхронный вызываемый объект, который принимает запрос и возвращает ответ. **ASGI** — его «духовный преемник»: один асинхронный вызываемый объект, который получает `scope` (словарь с деталями соединения) и асинхронные `receive` и `send` для обмена событиями. Поэтому ASGI поддерживает долгоживущие соединения и протоколы с несколькими входящими событиями, например WebSocket, а WSGI с единственным синхронным вызовом и единственным путём передачи запроса — нет. Подспецификация Lifespan сообщает приложению о запуске и остановке, чтобы, например, создать и закрыть пул соединений в работающем цикле событий.

Источник: https://asgi.readthedocs.io/en/latest/introduction.html

### Как работает механизм внедрения зависимостей (Depends) в FastAPI?

**Depends** — система внедрения зависимостей FastAPI: параметр обработчика объявляют как `Depends(get_something)`, и FastAPI сам вызывает функцию-зависимость и подставляет её результат; так выносят общую логику и общие подключения к БД. Зависимости могут иметь вложенные зависимости (sub-dependencies). Если одна зависимость объявлена несколько раз для одной операции, FastAPI вызовет её один раз за запрос и передаст сохранённое значение всем, кто от неё зависит; `use_cache=False` это отключает. В зависимости с `yield` код до `yield` выполняется до создания ответа, а код после `yield` — после ответа; типичный пример — сессия БД, которую открывают и закрывают. В тестах зависимости подменяют через словарь `app.dependency_overrides`.

Источник: https://fastapi.tiangolo.com/tutorial/dependencies/

### Что такое middleware в веб-фреймворке и для чего оно применяется?

**Middleware** — компонент, который работает с каждым запросом до того, как его обработает конкретная операция пути, и с каждым ответом перед его возвратом клиенту. Так сквозную логику выносят из эндпоинтов: в документации FastAPI пример — замер времени обработки и добавление заголовка `X-Process-Time`, а в Django middleware — это лёгкая низкоуровневая система «плагинов» для глобального изменения входа и выхода; например, `AuthenticationMiddleware` связывает пользователей с запросами через сессии. Middleware выстраиваются в стек. В Django слои выполняются сверху вниз в порядке списка `MIDDLEWARE`, как «луковица» вокруг представления, а ответ проходит их в обратном порядке. В FastAPI последний добавленный middleware внешний: на пути запроса он срабатывает первым, на пути ответа последним.

Источник: https://fastapi.tiangolo.com/tutorial/middleware/

## Базы данных и ORM

### Что такое ORM и какие у неё преимущества и недостатки?

**ORM** (Object-Relational Mapping) отображает таблицы БД на классы: в SQLAlchemy Declarative Mapping задаёт объектную модель и метаданные таблиц, и вы работаете с данными через классы и запросы, а не собираете SQL вручную. Преимущество, которое подтверждает документация: запросы Django ORM защищены от SQL-инъекций, потому что строятся через параметризацию, то есть код SQL отделён от параметров, а параметры экранирует драйвер БД. Недостаток: ORM может незаметно выполнять лишние запросы. Классический пример — проблема N+1: при ленивой загрузке обращение к связанным атрибутам N загруженных объектов даёт N+1 запросов SELECT.

Источник: https://docs.sqlalchemy.org/en/20/orm/quickstart.html

### Что такое проблема N+1 запросов в ORM и как её решать?

N+1 возникает, когда после одного запроса за N объектами обращение к их лениво загружаемым атрибутам порождает по отдельному SELECT на каждый объект: итого N+1 запросов. Лечат жадной загрузкой (eager loading): связанные данные приходят вместе с основным запросом. В SQLAlchemy это `joinedload` (JOIN в основном SELECT) или `selectinload` (дополнительный SELECT после основного). В Django аналоги — `select_related` (JOIN для связей к одному: ForeignKey и OneToOne) и `prefetch_related` (отдельный запрос для связей ко многим).

Источник: https://docs.sqlalchemy.org/en/20/orm/queryguide/relationships.html#relationship-loading-techniques

### В чём разница между select_related и prefetch_related в Django ORM?

`select_related` достаёт связанные объекты одним SQL-запросом через JOIN, `prefetch_related` делает отдельный запрос на каждую связь и соединяет результаты в Python.

Источник: https://docs.djangoproject.com/en/stable/ref/models/querysets/#select-related

### Как работает ленивая и жадная загрузка связанных данных в SQLAlchemy и почему ленивая опасна в async?

**Ленивая загрузка** (по умолчанию, `lazy='select'`) возвращает объекты без связанных данных, а при первом обращении к коллекции или ссылке выполняет дополнительный SELECT. **Жадная загрузка** подтягивает связанные данные сразу: либо JOIN в основном SELECT (joined loading), либо дополнительными SELECT после основного (selectin loading). В asyncio ленивая загрузка проблемна, потому что для успеха она обычно требует обращения к БД при доступе к атрибуту, а неявный IO в asyncio не разрешён.

Источник: https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html

### Что такое транзакция и что означает аббревиатура ACID?

**Транзакция** — группа операций, которая выполняется как единое целое: по документации PostgreSQL это «всё или ничего», промежуточные состояния не видны параллельным транзакциям, а данные записаны на диск до подтверждения. **ACID** расшифровывается как atomicity, consistency, isolation, durability. **Consistency** (согласованность) означает, что транзакция переводит БД из одного согласованного состояния в другое и сохраняет инварианты: записанные данные соответствуют всем правилам, включая ограничения, каскады и триггеры. В ORM транзакцией управляет сессия: `Session` в SQLAlchemy ведёт одну «виртуальную» транзакцию, а в Django по умолчанию включён автокоммит (каждый запрос фиксируется сразу), и `atomic()` оборачивает блок кода в транзакцию.

Источник: https://www.postgresql.org/docs/current/tutorial-transactions.html

### Какие бывают уровни изоляции транзакций и от каких аномалий они защищают?

Стандарт SQL определяет четыре уровня: Read Uncommitted, Read Committed, Repeatable Read и Serializable. Они различаются тем, какие аномалии запрещают. **Грязное чтение** — транзакция читает данные параллельной незакоммиченной транзакции. **Неповторяющееся чтение** — повторное чтение даёт данные, изменённые другой закоммитившейся транзакцией. **Фантомное чтение** — повторный запрос по условию возвращает другой набор строк. **Аномалия сериализации** — результат группы транзакций не совпадает ни с каким последовательным порядком. Read Uncommitted допускает всё перечисленное, Read Committed запрещает грязное чтение, Repeatable Read запрещает ещё и неповторяющееся, Serializable запрещает все аномалии.

Источник: https://www.postgresql.org/docs/current/transaction-iso.html

### Что такое индексы в БД, зачем они нужны и в чём их минусы?

**Индекс** — вспомогательная структура, с помощью которой система находит строки по условию без построчного сканирования всей таблицы. По умолчанию `CREATE INDEX` в PostgreSQL создаёт B-tree: он обрабатывает сравнения `<`, `<=`, `=`, `>=`, `>`, а также `BETWEEN`, `IN`, `IS NULL` и `LIKE` с шаблоном, закреплённым в начале строки (`col LIKE 'foo%'`), но не `col LIKE '%bar'`. Hash-индекс умеет только простое равенство, а GIN — инвертированный индекс для значений из нескольких компонентов, например массивов.

Источник: https://www.postgresql.org/docs/current/indexes-types.html

### Что такое миграции и зачем нужен инструмент вроде Alembic?

**Миграции** — версионируемые изменения схемы БД. Документация Django предлагает думать о них как о системе контроля версий для схемы: `makemigrations` упаковывает изменения моделей в файлы миграций (аналог коммитов), а `migrate` применяет их и откатывает. **Alembic** — лёгкий инструмент миграций для SQLAlchemy: у миграции есть функции `upgrade()` и `downgrade()`, а `autogenerate` сравнивает модели со схемой и предлагает кандидата миграции.

Источник: https://alembic.sqlalchemy.org/en/latest/

### В SQLAlchemy 2.x внутри `with engine.connect() as conn:` выполнен `conn.execute(text("INSERT ..."))`, блок завершился без исключения, `commit()` не вызывался. Окажется ли строка в базе и как сделать так, чтобы фиксация происходила автоматически при успешном выходе из блока?

Строки в базе не будет: при освобождении соединения выполняется `ROLLBACK`, автоматического `COMMIT` нет.

Источник: https://docs.sqlalchemy.org/en/21/tutorial/dbapi_transactions.html

## Тестирование

### Что такое фикстуры в pytest и какие у них области видимости (scope)?

**Фикстура** — функция с декоратором `@pytest.fixture`, которая готовит данные или состояние для теста; тест объявляет её как аргумент, и pytest подставляет результат. Фикстуру можно переиспользовать: два теста, запросивших одну фикстуру, получают каждый свой результат, поэтому тесты не влияют друг на друга и стартуют с чистого состояния. Код очистки (teardown) размещают после `yield`; после теста pytest выполняет эту часть в порядке, обратном порядку создания фикстур. **Область видимости** (scope) задаёт, как часто фикстура создаётся и уничтожается: function (по умолчанию), class, module, package и session. Фикстуры class, module и package уничтожаются при завершении последнего теста класса, модуля или пакета соответственно.

Источник: https://docs.pytest.org/en/stable/how-to/fixtures.html

### Что такое Mock и в каких случаях его применяют?

**Mock** (из `unittest.mock`) — гибкий объект, который заменяет в тесте реальную зависимость: по документации он предназначен заменять stubs и test doubles. Атрибуты он создаёт как новые моки при первом обращении, а повторное обращение к тому же атрибуту возвращает тот же мок. Возвращаемое значение или исключение задают через `return_value` и `side_effect`. Mock записывает, как его использовали, поэтому после вызова можно проверить, что делал ваш код (`assert_called_with`, `call_count`). Зависимость подменяют через `patch`, и подменять нужно имя там, где объект ищется, а не там, где он определён.

Источник: https://docs.python.org/3/library/unittest.mock.html

### В чём разница между mock и stub?

**Stub** даёт заготовленные ответы на вызовы во время теста и обычно не отвечает ни на что за пределами того, что в него запрограммировано. **Mock** — объект, запрограммированный ожиданиями, которые образуют спецификацию ожидаемых вызовов. Из всех видов тестовых дублёров только мок настаивает на проверке поведения (behavior verification), остальные обычно используют проверку состояния (state verification). Во время выполнения теста мок ведёт себя как другие дублёры, чтобы тестируемый код считал, что общается с настоящими соседями, а отличается он на стадиях настройки и проверки.

Источник: https://martinfowler.com/articles/mocksArentStubs.html

### Сотня юнит-тестов эндпоинта `POST /users` с подменённой базой зелёная, а в проде вторая регистрация с тем же email падает на уникальном индексе, которого код не ожидал. Какой самый низкий уровень теста поймал бы такую ошибку и почему юнит-тест с подменой базы не мог?

Это тест с настоящей базой: узкий интеграционный тест на стыке кода и базы.

Источник: https://martinfowler.com/articles/practical-test-pyramid.html

## Пакеты, зависимости и окружения

### Зачем нужно виртуальное окружение и что оно делает на самом деле?

Виртуальное окружение — каталог с собственным интерпретатором и пакетами проекта, который по умолчанию изолирован от пакетов других окружений и интерпретаторов и от пакетов операционной системы, поэтому зависимости разных проектов не сталкиваются. `python -m venv` создаёт каталог с файлом `pyvenv.cfg`, подкаталогом `bin` (на Windows `Scripts`) с копией или симлинком интерпретатора и подкаталогом `site-packages` для пакетов. Активация — скрипт из этого каталога: он добавляет `bin` (`Scripts`) в начало `PATH`, чтобы `python` и установленные скрипты запускались без полного пути.

Источник: https://docs.python.org/3.15/library/venv.html

### Чем список зависимостей отличается от lock-файла и зачем нужны оба?

Список зависимостей проекта (`install_requires`) задаёт минимум, нужный для работы: имена и ограничения версий, «абстрактные» требования без указания, откуда их брать. Lock-файл фиксирует конкретный результат: точные версии, которые дают воспроизводимую установку. В pip это requirements-файл с закреплёнными версиями (`==`), который можно получить командой `pip freeze`: он фиксирует не только прямые, но и все транзитивные зависимости. Для стандартного формата lock-файла есть `pylock.toml`, он нужен, чтобы описать зависимости для воспроизводимой установки. Закрепление защищает от ошибок и несовместимостей в только что вышедших версиях зависимостей, поэтому нужны оба артефакта: минимальные требования проекта и полный закреплённый список для окружения.

Источник: https://pip.pypa.io/en/stable/topics/repeatable-installs/

### Что такое pyproject.toml и почему он вытеснил setup.py?

`pyproject.toml` — файл описания проекта: PEP 518 ввёл в нём таблицу `[build-system]` с требованиями сборки, а PEP 621 — стандартные метаданные проекта (имя, версия, зависимости). `setup.py` — исполняемый файл, и в этом проблема: по PEP 518 его нельзя выполнить, не зная его зависимостей, а информация о них хранится в нём самом, поэтому инструмент не мог автоматически узнать, что нужно для сборки («catch-22»). Декларативная таблица `[build-system]` это решает, а PEP 517 определяет интерфейс между фронтендом и бэкендом сборки и рекомендует по умолчанию создавать для каждой сборки изолированное окружение с только стандартной библиотекой и явно запрошенными зависимостями сборки.

Источник: https://peps.python.org/pep-0518/

### Чем wheel отличается от source distribution?

Sdist — архив с исходниками: чтобы поставить, его нужно собрать на машине пользователя, а для пакетов с расширениями на C это означает наличие компилятора.

Источник: https://packaging.python.org/en/latest/discussions/package-formats/

## Типизация и аннотации

### Функция объявлена как `def add(x: int, y: int) -> int: return x + y` и вызвана как `add("a", "b")`. Что вернётся и что проверяет такие аннотации?

Вернётся строка `"ab"` без всякой ошибки: интерпретатор аннотации функций не применяет, `+` для строк определён.

Источник: https://docs.python.org/3/library/typing.html

### В Python 3.15 в модуле объявлена `def func(a: Cls) -> None`, а класс `Cls` определён ниже по файлу. Упадёт ли определение функции и что произойдёт при чтении аннотаций?

Определение не упадёт: с Python 3.14 выражения аннотаций вычисляются лениво, а не при выполнении `def`. До 3.14 без `from __future__ import annotations` здесь был бы `NameError`.

Источник: https://docs.python.org/3/whatsnew/3.14.html#pep-649-749-deferred-evaluation-of-annotations

### Функция `def greeting(name): return "Hello " + name` вызвана как `greeting(123)`. Почему mypy с настройками по умолчанию молчит и что нужно изменить, чтобы ошибка нашлась до запуска?

Функция без аннотаций считается динамически типизированной: mypy по умолчанию не проверяет её тело, а параметр `name` считает `Any`, поэтому сверять вызов `greeting(123)` ему не с чем. Ошибку нашёл бы только запуск (`TypeError`).

Источник: https://mypy.readthedocs.io/en/stable/getting_started.html

## FastAPI

### Обработчик FastAPI объявлен как `async def read(limit: int | None)` без значения по умолчанию. Обязателен ли query-параметр `limit` и что получит клиент, не передав его?

Параметр обязателен: клиент получит ответ 422 с ошибкой типа `missing` и `loc: ["query", "limit"]`.

Источник: https://fastapi.tiangolo.com/tutorial/query-params/

### В приложении FastAPI сначала объявлен `@app.get("/users/{user_id}")`, а ниже `@app.get("/users/me")`. Какой обработчик получит запрос `GET /users/me`?

Первый, с параметром: `user_id` получит значение `"me"`, а обработчик `/users/me` не будет вызван никогда.

Источник: https://fastapi.tiangolo.com/tutorial/path-params/#order-matters

### Обработчик `POST /items/` принимает модель `Item(name: str, price: float)`. Клиент шлёт с `Content-Type: application/json` тело `{"name": "Foo"}`. Какой ответ он получит?

Ответ 422 с телом вида `{"detail": [{"type": "missing", "loc": ["body", "price"], "msg": "Field required", ...}]}`; обработчик не вызывается.

Источник: https://fastapi.tiangolo.com/tutorial/body/

### После обновления FastAPI до 0.132 клиент, который шлёт JSON без заголовка `Content-Type`, перестал проходить на эндпоинты с телом-моделью. Что изменилось и как вернуть прежнее поведение?

Начиная с 0.132.0 строгая проверка `Content-Type` включена по умолчанию: запрос без заголовка больше не считается JSON и тело как JSON не разбирается. В проверку модели уходят сырые байты, и запрос не проходит валидацию.

Источник: https://fastapi.tiangolo.com/release-notes/

## Django и DRF

### Пакет `polls` лежит в проекте Django, в нём есть `models.py` и `apps.py`, но строки `"polls"` нет в `INSTALLED_APPS`. Что вернут `apps.is_installed("polls")` и `apps.get_app_config("polls")`?

`is_installed` вернёт `False`, а `get_app_config` поднимет `LookupError`.

Источник: https://docs.djangoproject.com/en/6.1/ref/applications/

### Запрос `Country.objects.get(code="RU")` стоит в двух местах: на уровне модуля `polls/models.py` и в методе `PollsConfig.ready()`. Что произойдёт в каждом из них?

На уровне модуля `models.py` Django поднимет `AppRegistryNotReady`: реестр моделей ещё не готов. В `ready()` модели уже доступны, запрос выполнится, но Django выдаст `RuntimeWarning`.

Источник: https://docs.djangoproject.com/en/6.1/ref/applications/#initialization-process

### Код делает `qs = Entry.objects.filter(headline__startswith="What")`, затем `qs = qs.filter(pub_date__lte=today)`, затем `qs = qs.exclude(body__icontains="x")` и в конце `list(qs)`. Сколько SQL-запросов выполнит Django и в какой момент?

Один запрос, и только на `list(qs)`.

Источник: https://docs.djangoproject.com/en/6.1/topics/db/queries/#querysets-are-lazy

### Для невычисленного `qs = Entry.objects.filter(headline__startswith="What")` код делает `a = qs[0]`, затем `b = qs[0]`, затем `list(qs)` и, наконец, `c = qs[0]`. Сколько запросов выполнит Django?

Три запроса: по одному на `qs[0]` (оба раз) и один на `list(qs)`; последний `qs[0]` читает кэш.

Источник: https://docs.djangoproject.com/en/6.1/topics/db/queries/#caching-and-querysets

### В `urlpatterns` стоят по порядку `path("articles/special/", views.special)`, `path("articles/<slug:name>/", views.detail)` и `path("articles/<int:year>/", views.year_archive)`. Какое представление получит запрос `/articles/2005/`?

`views.detail`: строка `2005` подходит конвертеру `slug`, а его шаблон стоит выше. Представление `year_archive` недостижимо.

Источник: https://docs.djangoproject.com/en/6.1/topics/http/urls/#how-django-processes-a-request

### Класс-представление определяет только `get` и `post`, а клиент отправляет `DELETE` на его URL. Что вернёт Django и что вернёт функция-представление, в которой `request.method` не проверяется?

Класс-представление вернёт 405 Method Not Allowed с заголовком `Allow`, перечисляющим поддерживаемые методы. Функция без проверки выполнится и вернёт обычный ответ на `DELETE`.

Источник: https://docs.djangoproject.com/en/6.1/ref/class-based-views/base/#django.views.generic.base.View.dispatch

## Flask

### Обработчик Flask возвращает `({"error": "not found"}, 404)`. Какой ответ получит клиент?

Статус 404, заголовок `Content-Type: application/json` и тело `{"error": "not found"}`.

Источник: https://flask.palletsprojects.com/en/stable/quickstart/#about-responses

### В обработчике Flask читается `request.form["username"]`, а клиент прислал форму без этого ключа. Что получит клиент и как читать ключ, который может отсутствовать?

Клиент получит 400 Bad Request: при обращении к отсутствующему ключу Flask поднимает специальную ошибку `KeyError` (`BadRequestKeyError`), и если её не перехватить, она превращается в ответ 400.

Источник: https://flask.palletsprojects.com/en/stable/quickstart/#the-request-object

### Расширение Flask читает `current_app.config` на верхнем уровне своего модуля, а `create_app()` ещё не вызывалась. Что произойдёт и где настройки читать правильно?

Будет `RuntimeError: Working outside of application context`: на уровне модуля контекста приложения нет, а `current_app` — прокси, который указывает на приложение из контекста.

Источник: https://flask.palletsprojects.com/en/stable/appcontext/

## Проектирование HTTP API

### Разработчик реализовал удаление записи как `GET /items/42/delete`. Почему удаление нельзя делать методом GET и каким методом его выразить?

GET по спецификации безопасный: он не должен менять состояние сервера. Удаление выражают методом `DELETE /items/42`.

Источник: https://www.rfc-editor.org/rfc/rfc9110.html#name-safe-methods

### К админскому эндпоинту обращаются два клиента: первый без токена, второй с действительным токеном обычного пользователя. Какие коды статуса вернёт API каждому?

Первому 401 Unauthorized, второму 403 Forbidden.

Источник: https://www.rfc-editor.org/rfc/rfc9110.html#name-401-unauthorized

### Клиент платёжного API после таймаута повторяет `POST /payments` и боится списать деньги дважды. Какой механизм защищает от дубля и как сервер должен ответить на повтор?

Клиент отправляет заголовок `Idempotency-Key` с уникальным значением (например, UUID) для логической операции и повторяет запрос с тем же ключом. Сервер, увидев известный ключ, не выполняет операцию заново, а возвращает результат первого выполнения.

Источник: https://datatracker.ietf.org/doc/draft-ietf-httpapi-idempotency-key-header/

## Рантайм CPython

### Скрипт начинается со строки `print("старт")`, а ниже в теле функции, которую никто не вызывает, стоит синтаксическая ошибка `x = = 5`. Что выведет `python script.py` и на какой фазе всё упадёт?

Слово «старт» не напечатается: программа упадёт с `SyntaxError` на фазе компиляции, до исполнения первой инструкции.

Источник: https://docs.python.org/3.15/glossary.html

### Вы запускаете `python app.py`, а `app.py` импортирует `helper.py`. Исходники не менялись, команду запускают второй раз. Какой из двух файлов Python компилирует в байткод заново и ускорит ли кэш `.pyc` само выполнение программы?

Заново компилируется `app.py`; `helper.py` берётся из кэша, а выполнение кэш не ускоряет, только загрузку.

Источник: https://docs.python.org/3.15/tutorial/modules.html

## Наблюдаемость: логи, метрики, трассы

### После релиза p95 длительности `POST /orders` вырос с 0,4 до 8 секунд. Метрика показала масштаб и время начала. Какой канал телеметрии покажет, в каком шаге обработки запроса теряется время, и почему этого не покажут метрики и логи?

Это трассы: трасса показывает путь одного запроса и длительность каждого шага.

Источник: https://opentelemetry.io/docs/concepts/observability-primer/

### Нужно показать на графике, сколько заказов с купоном оформляется в час, и настроить по этому алерт. Какой тип метрики `prometheus_client` подойдёт и что нельзя класть в значения меток?

Подойдёт `Counter` с меткой вида «с купоном» или «без»; в метки нельзя класть значения с неограниченным числом вариантов.

Источник: https://prometheus.io/docs/concepts/metric_types/

### Сервис запущен четырьмя воркерами Gunicorn, в нём `Counter` запросов из `prometheus_client`. При ровном потоке запросов обновление страницы `/metrics` даёт значения 130, 96, 142. Почему значение скачет и что настроить, чтобы получать суммарное?

Каждый воркер Gunicorn — отдельный процесс со своей памятью и своим счётчиком; на запрос `/metrics` отвечает тот воркер, которому он достался. Чтобы получать сумму, нужен multiprocess-режим библиотеки.

Источник: https://prometheus.github.io/client_python/multiprocess/

## Фоновые задачи и очереди

### Обработчик FastAPI создаёт счёт, добавляет отправку письма в `BackgroundTasks` и возвращает `202`. Во время деплоя процесс останавливается, и часть писем не ушла. Почему так вышло и какой инструмент нужен, если задача обязана выполниться?

Работа `BackgroundTasks` лежит в памяти процесса приложения и выполняется после отправки ответа, поэтому остановка процесса её прерывает. Если задача должна выжить при рестарте, нужна очередь с брокером, например Celery.

Источник: https://fastapi.tiangolo.com/tutorial/background-tasks/

### Асинхронный обработчик запускает «выстрелил и забыл» так: `asyncio.create_task(send_email(order))`, а результат нигде не сохраняет. Иногда письмо не уходит, хотя ошибок нет. Какая причина по документации Python и как запускать такие задачи надёжно?

Цикл событий хранит только слабые ссылки на задачи: задача, на которую нигде нет ссылки, может быть удалена сборщиком мусора в любой момент, даже до завершения.

Источник: https://docs.python.org/3/library/asyncio-task.html

### Идемпотентная задача Celery `send_invoice` работает с настройками по умолчанию. Хост воркера внезапно выключился в середине задачи. Что станет с задачей и что изменится при `acks_late=True`?

С настройками по умолчанию задача потеряна, а с `acks_late=True` её выдадут другому воркеру и выполнят заново.

Источник: https://docs.celeryq.dev/en/stable/userguide/tasks.html

## Контейнеры, конфигурация и CI/CD

### На одном хосте нужно запустить двадцать изолированных копий сервиса. Чем контейнеры отличаются от виртуальных машин в том, что у них общее, и чем это выгодно?

Контейнеры изолируют процесс и делят ядро операционной системы хоста, поэтому двадцать контейнеров дешевле двадцати виртуальных машин.

Источник: https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/

### В опубликованном образе `shop-api:1.4` найдена уязвимая версия библиотеки. Можно ли обновить библиотеку внутри образа и как правильно выкатить исправление?

Образ неизменяем, поэтому его не правят: исправление выкатывают новым образом.

Источник: https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-an-image/

### Класс `Settings(BaseSettings)` с `env_prefix="SHOP_"`, `env_file=".env"` и полем `redis_url` со значением по умолчанию `redis://localhost:6379/0`. В окружении контейнера задано `SHOP_REDIS_URL=redis://cache:6379/0`, а в файле `.env`, по ошибке попавшем в образ, `SHOP_REDIS_URL=redis://localhost:6379/1`. Какое значение получит вызов `Settings()` и какое `Settings(redis_url="redis://test:6379/0")`?

`Settings()` получит `redis://cache:6379/0`, вызов с аргументом получит `redis://test:6379/0`: побеждает источник с большим приоритетом.

Источник: https://docs.pydantic.dev/latest/concepts/pydantic_settings/

### В манифесте контейнера вместо `SHOP_REDIS_URL` написано `SHOP_REDIS_RUL=redis://cache:6379/0`. В `Settings` у поля `redis_url` есть значение по умолчанию, задано `env_prefix="SHOP_"` и `extra="forbid"`. Упадёт ли сервис при старте и какой Redis он будет использовать?

Сервис не упадёт и будет использовать значение по умолчанию, то есть `localhost` внутри собственного контейнера.

Источник: https://docs.pydantic.dev/latest/concepts/pydantic_settings/
