К содержимому
Войти

Python Road Map

🎸 Django и DRF

Django — фреймворк «с батарейками»: ORM, миграции, админка, формы, аутентификация и middleware идут в коробке, а Django REST Framework (DRF) добавляет поверх него сериализаторы, viewsets и права для API. В вакансиях middle на hh.ru Django и DRF встречаются в 6–9% вакансий против 22–25% у FastAPI, но в легаси и в продуктах с админкой их много, а вопросы про Django на собеседовании повторяются: N+1, ленивый QuerySet, порядок middleware и гонки при инкременте. Здесь всё это с реальным SQL, который генерирует ORM

🧠 Как это устроено

MTV и путь запроса

Django называет свою схему MTV: модель (данные и ORM), шаблон (HTML) и представление, то есть view, которое принимает запрос и возвращает ответ. Роль «контроллера» из MVC берут на себя фреймворк и urls.py

Запрос проходит так:

  1. Сервер приложений (gunicorn, uvicorn) вызывает Django через WSGI или ASGI — интерфейсы разобраны на странице про WSGI и ASGI
  2. Django создаёт HttpRequest и прогоняет его через middleware сверху вниз по списку MIDDLEWARE
  3. URL-резолвер находит view по urls.py
  4. View работает с ORM и возвращает HttpResponse
  5. Ответ идёт через те же middleware в обратном порядке, снизу вверх

Middleware: луковица

Документация Django сравнивает middleware с луковицей: каждый слой оборачивает следующий, view в середине. Middleware — это вызываемый объект, которому при старте передают get_response, то есть следующий слой:

class TimingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response   # вызывается один раз при старте

    def __call__(self, request):
        t = time.perf_counter()            # до view: порядок сверху вниз
        response = self.get_response(request)
        response["X-Time"] = f"{time.perf_counter() - t:.3f}"  # после view: снизу вверх
        return response

Для MIDDLEWARE = [A, B, C] код «до» выполняется в порядке A, B, C, код «после» — C, B, A. Если B вернул ответ сам и не вызвал get_response, до C и view запрос не дойдёт, а ответ увидят только B и A

Отсюда правила порядка в настройках. SecurityMiddleware стоит первым, SessionMiddleware — раньше AuthenticationMiddleware, потому что пользователь достаётся из сессии. Свой middleware, которому нужен request.user, ставят ниже AuthenticationMiddleware

QuerySet ленивый

Book.objects.filter(price__gt=50).order_by("title") не ходит в базу. QuerySet копит описание запроса, и каждый filter, exclude, order_by возвращает новый QuerySet. SQL выполняется, когда нужны данные: итерация, list(), len(), bool(), repr() в консоли, срез с шагом, а также методы, которые не возвращают QuerySet: get, first, count, exists, update, delete

Ленивость нужна, чтобы собирать запрос по кусочкам: базовый QuerySet в одном месте, фильтры и пагинация в другом, а в базу уходит один итоговый SQL

После первой итерации результаты лежат в кэше QuerySet (_result_cache), и повторная итерация того же объекта запроса не делает. Кэш живёт в конкретном объекте: новый Book.objects.all() пойдёт в базу заново, и индекс qs[0] на ещё не вычисленном QuerySet тоже каждый раз делает отдельный запрос с LIMIT 1. Проверка на Django 6.1.3:

with CaptureQueriesContext(connection) as ctx:
    qs = Book.objects.filter(price__gt=50).order_by("title")
    print(len(ctx))   # 0 — запрос только описан
    list(qs)
    print(len(ctx))   # 1
    list(qs)
    print(len(ctx))   # 1 — взято из кэша
    qs2 = Book.objects.all()
    qs2[0]; qs2[0]
    print(len(ctx))   # 3 — каждый индекс на невычисленном QuerySet идёт в базу

Для больших выборок кэш съедает память: миллион объектов в списке. Тогда используют .iterator(), который читает порциями и ничего не кэширует

N+1: select_related против prefetch_related

Модели: Book с внешним ключом author и связью многие-ко-многим tags. Обращение к book.author ORM обслуживает лениво: если автор не загружен, это отдельный SELECT. На списке из N книг получается один запрос за книгами и N запросов за авторами — N+1

select_related решает это через JOIN, одним запросом. Работает только для связей, где на другой стороне один объект: ForeignKey и OneToOne

prefetch_related делает второй запрос с IN по собранным ключам и склеивает результаты в Python. Он нужен, где на другой стороне много объектов: ManyToMany и обратная сторона внешнего ключа (author.books). JOIN там размножил бы строки книг

Реальный SQL на SQLite, три книги двух авторов, Django 6.1.3. Список столбцов в SELECT сокращён:

[b.author.name for b in Book.objects.all()]
[b.author.name for b in Book.objects.select_related("author")]
[[t.name for t in b.tags.all()] for b in Book.objects.prefetch_related("tags")]
--- без оптимизации: 4 запроса
SELECT ... FROM "shop_book"
SELECT ... FROM "shop_author" WHERE "shop_author"."id" = 1 LIMIT 21
SELECT ... FROM "shop_author" WHERE "shop_author"."id" = 1 LIMIT 21
SELECT ... FROM "shop_author" WHERE "shop_author"."id" = 2 LIMIT 21
--- select_related: 1 запрос
SELECT ... FROM "shop_book" INNER JOIN "shop_author" ON ("shop_book"."author_id" = "shop_author"."id")
--- prefetch_related: 2 запроса
SELECT ... FROM "shop_book"
SELECT ("shop_book_tags"."book_id") AS "_prefetch_related_val_book_id", ... FROM "shop_tag"
  INNER JOIN "shop_book_tags" ON ("shop_tag"."id" = "shop_book_tags"."tag_id")
  WHERE "shop_book_tags"."book_id" IN (1, 2, 3)

Автор с id = 1 загружен дважды: у каждой книги свой объект автора, общего кэша между ними нет. Для обратного внешнего ключа Author.objects.prefetch_related("books") второй запрос получается ещё проще: WHERE "shop_book"."author_id" IN (1, 2)

Поймать N+1 помогают connection.queries (только при DEBUG=True), CaptureQueriesContext, assertNumQueries в тестах и django-debug-toolbar

only, defer, F, Q, annotate

only("title") загружает только перечисленные поля, defer("body") — все, кроме указанных. Цена ошибки видна на замере: [b.price for b in Book.objects.only("title")] дал 4 запроса вместо одного, потому что каждое обращение к незагруженному полю дозапрашивает его отдельным SELECT для одной строки

F("price") ссылается на значение столбца в базе, а не в Python. Book.objects.filter(pk=1).update(price=F("price") + 1) превращается в UPDATE "shop_book" SET "price" = ("shop_book"."price" + 1) WHERE "shop_book"."id" = 1

Q собирает условия с |, & и ~: filter(Q(price__gt=100) | ~Q(author__name="Чехов")) даёт WHERE (price > 100 OR NOT (author.name = 'Чехов')) с JOIN на автора

annotate добавляет к каждой строке вычисляемое поле: Author.objects.annotate(n=Count("books")) — это LEFT OUTER JOIN и GROUP BY одним запросом вместо счётчика в цикле

Миграции

makemigrations сравнивает модели с последним состоянием миграций и пишет файл миграции, migrate применяет его к базе. Как менять схему без простоя и блокировок, разобрано на странице про Postgres из Python

🛠️ DRF: сериализаторы, viewsets, права

Сериализатор превращает модель в словарь для JSON и обратно проверяет входящие данные. ModelSerializer строит поля по модели сам:

class BookSerializer(serializers.ModelSerializer):
    author = serializers.CharField(source="author.name")

    class Meta:
        model = Book
        fields = ["id", "title", "author"]

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.select_related("author")  # без этого — N+1
    serializer_class = BookSerializer
    permission_classes = [IsAuthenticated]

router = routers.DefaultRouter()
router.register("books", BookViewSet)
urlpatterns = router.urls

ModelViewSet даёт список, создание, чтение, изменение и удаление. Роутер сам выписывает маршруты: books/ с именем book-list, books/<pk>/ с именем book-detail, варианты с суффиксом формата (books.json) и корень API от DefaultRouter

N+1 в сериализаторах самый частый: source="author.name" или вложенный сериализатор лезут в связь у каждого объекта. На DRF 3.18.3 BookSerializer(Book.objects.all(), many=True).data сделал 4 запроса на три книги, а с select_related("author") обошёлся одним. Сериализатор не знает, откуда пришёл QuerySet, поэтому оптимизация делается в queryset или get_queryset() у view

Права. По умолчанию DEFAULT_PERMISSION_CLASSES — AllowAny, то есть API открыт всем, пока не настроишь. У класса прав два метода: has_permission проверяет доступ к view целиком, has_object_permission — к конкретному объекту. Второй вызывается только из get_object(), то есть в detail-запросах. В списке DRF объектные права к каждой записи не применяет: чужие записи из списка убирают фильтром в get_queryset()

🆕 Что нового в Django 6.0

Django 6.0 вышел 3 декабря 2025, требует Python 3.12+. Актуальные ветки сейчас: 6.1 (6.1.3), 6.0 (6.0.10) и LTS 5.2 (5.2.19) с исправлениями безопасности до апреля 2028. Следующая LTS — 6.2, её ждут в апреле 2027

  • Фоновые задачи. Функцию помечают @task из django.tasks и ставят в очередь через .enqueue(), который возвращает TaskResult со статусом. Воркера в коробке нет: Django описывает, валидирует и ставит задачу, а выполнять её должен внешний процесс из стороннего бэкенда. Встроенные бэкенды учебные: ImmediateBackend (по умолчанию) выполняет задачу сразу в том же процессе, DummyBackend только сохраняет её. Без настройки TASKS вызов .enqueue() вернул результат со статусом SUCCESSFUL синхронно. Чем это отличается от Celery, разобрано на странице про Kafka, RabbitMQ и Celery из Python
  • CSP из коробки. ContentSecurityPolicyMiddleware и настройки SECURE_CSP и SECURE_CSP_REPORT_ONLY с константами вроде CSP.SELF и CSP.NONCE
  • Template partials. Теги {% partialdef %} и {% partial %} и обращение "page.html#card" в render() и {% include %}, удобно для htmx
  • DEFAULT_AUTO_FIELD по умолчанию BigAutoField
  • После save() поля, которым присвоили выражение, перечитываются через RETURNING (SQLite, PostgreSQL, Oracle). После b.price = F("price") + 1; b.save() в b.price уже число 101, а SQL заканчивается на RETURNING "shop_book"."price". До 6.0 там оставалось выражение и нужен был refresh_from_db()

⚡ Async в Django и его границы

View можно объявить через async def. Под ASGI это даёт главное: сотни одновременных соединений без потока на каждое, долгие запросы, стриминг, long-polling. Под WSGI async-view тоже работает, но в одноразовом цикле событий, и выгоды по конкурентности нет

У ORM есть асинхронные методы с префиксом a: aget, afirst, acount, acreate, asave, adelete, а итерировать можно через async for. Внутри это та же синхронная ORM в потоке: в исходниках Django 6.1.3 aget — это await sync_to_async(self.get)(...). Цикл она не блокирует, но платит переключением потоков

Что остаётся синхронным:

  • Транзакции. В async-режиме они не поддерживаются и дают SynchronousOnlyOperation. Код с transaction.atomic() выносят в синхронную функцию и вызывают через sync_to_async
  • Ленивые связи. book.author.name после aget без select_related в async-коде падает с SynchronousOnlyOperation: дозапрос автора синхронный. Связи грузят заранее через select_related или prefetch_related
  • list(qs) и обычный for по QuerySet в корутине — та же ошибка, вместо них async for
  • Синхронный middleware в цепочке: на каждом запросе Django переключает из-за него потоки

sync_to_async по умолчанию работает с thread_sensitive=True: все такие вызовы одного запроса идут в одном общем потоке, по очереди. Переменная DJANGO_ALLOW_ASYNC_UNSAFE снимает проверку, но в проде она опасна: можно испортить данные

⚠️ Где ошибаются

Вложенный сериализатор без select_related. Добавили вложенный сериализатор автора, а queryset во view остался Book.objects.all(). На странице из 50 книг выходит 51 запрос, и на тестовых данных из трёх записей этого не видно. Число запросов на эндпоинт фиксируют тестом с assertNumQueries

filter() по предзагруженной связи. prefetch_related("tags") положил теги в кэш, но b.tags.filter(name="ru") — новый QuerySet, и он идёт в базу. Итог: 2 запроса префетча и ещё по одному на каждую книгу. Нужна выборка с условием — используют Prefetch("tags", queryset=Tag.objects.filter(name="ru"))

Инкремент в Python. book.views += 1; book.save() читает значение, увеличивает в памяти и пишет обратно. Два запроса одновременно прочитают 10 и оба запишут 11. Это классическая гонка «прочитал-изменил-записал» со страницы про гонки и синхронизацию, только между процессами, и threading.Lock от неё не спасёт. F("views") + 1 переносит сложение в сам UPDATE, и база выполняет его атомарно над текущим значением строки

only() и обращение к отложенному полю. Сократили выборку до only("title"), а шаблон или сериализатор берёт price. Каждая строка дозапрашивает поле отдельно, запросов становится больше, чем без only()

🎯 Вопросы с собеседований

N+1 в Django ORM: чем select_related отличается от prefetch_related

N+1 — один запрос за списком и ещё по запросу на каждый объект, когда код лезет в связь, которая не загружена. select_related делает JOIN и достаёт всё одним запросом, но работает только для ForeignKey и OneToOne, где на другой стороне один объект. prefetch_related делает второй запрос WHERE ... IN (1, 2, 3) по собранным ключам и склеивает результаты в Python. Он нужен для ManyToMany и обратных связей, где JOIN размножил бы строки. Проверяют количеством запросов через CaptureQueriesContext или assertNumQueries

Почему QuerySet ленивый и когда он выполняется

QuerySet хранит описание запроса, а filter и order_by возвращают новый QuerySet, поэтому запрос можно собирать по частям и выполнить один итоговый SQL. Выполняется он при итерации, list(), len(), bool(), repr() и в методах, которые не возвращают QuerySet: get, first, count, exists, update. Результат первой итерации кэшируется в самом объекте, и повторный проход по нему в базу не ходит. Новый QuerySet или индекс qs[0] на невычисленном QuerySet делают новый запрос. Для огромных выборок кэш отключают через .iterator()

Как работает middleware в Django и почему важен порядок

Middleware оборачивают view как луковица: при запросе выполняются сверху вниз по MIDDLEWARE, при ответе снизу вверх. Каждый получает get_response следующего слоя и может не вызвать его, а вернуть ответ сам. Тогда внутренние слои и view запрос не увидят, а ответ пройдёт только через уже пройденные слои. Порядок важен из-за зависимостей: AuthenticationMiddleware читает пользователя из сессии, поэтому стоит после SessionMiddleware, а свой middleware, которому нужен request.user, ставят ниже обоих

Чем F() помогает от гонки при инкременте

obj.counter += 1; obj.save() — это чтение, изменение в Python и запись, и два параллельных запроса потеряют одно увеличение. С F("counter") + 1 Django генерирует UPDATE ... SET counter = counter + 1, и сложение выполняет база над текущим значением строки, атомарно. Блокировка в Python тут не помогает: воркеры gunicorn — разные процессы, а общая у них только база. Если логика сложнее простого инкремента, нужен select_for_update() в транзакции

Что даёт async в Django и где его ограничения

Под ASGI async-view держат много одновременных соединений без потока на каждое: стриминг, long-polling, параллельные вызовы внешних API через httpx.AsyncClient. ORM даёт методы aget, afirst, acreate и async for, но внутри это синхронная ORM, запущенная через sync_to_async, а не асинхронный драйвер. Транзакции в async не поддерживаются, ленивые связи и list(qs) в корутине падают с SynchronousOnlyOperation, синхронный middleware добавляет переключения потоков. Выигрыш заметен во view, которые в основном ждут сеть

Сериализатор DRF против Pydantic-модели

Оба описывают форму данных и валидируют вход. Сериализатор DRF привязан к Django: ModelSerializer строит поля по модели, умеет create и update, валидация через методы validate_<поле>, работает в рантайме без опоры на аннотации. Pydantic строит модель из аннотаций типов, валидирует ядром на Rust, с ORM-объектами работает через from_attributes, и его используют FastAPI и любые проекты вне Django

📚 Что почитать

  • Database access optimization — официальный список приёмов: вычисление QuerySet, кэш, select_related, only, iterator
  • Middleware — луковица, ранний ответ и порядок хуков
  • Asynchronous support — async-view, sync_to_async, что пока синхронно
  • Django 6.0 release notes — фоновые задачи, CSP, partials и изменения по умолчанию
  • DRF: Permissions — has_permission, has_object_permission и почему объектные права не работают в списках