🎸 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
Запрос проходит так:
- Сервер приложений (gunicorn, uvicorn) вызывает Django через WSGI или ASGI — интерфейсы разобраны на странице про WSGI и ASGI
- Django создаёт
HttpRequestи прогоняет его через middleware сверху вниз по спискуMIDDLEWARE - URL-резолвер находит view по
urls.py - View работает с ORM и возвращает
HttpResponse - Ответ идёт через те же 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.urlsModelViewSet даёт список, создание, чтение, изменение и удаление. Роутер сам выписывает маршруты: 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и почему объектные права не работают в списках