Если вы хотите заново изучить Django: план обучения, начинающий с HTTP

Когда наступает конец года, мы естественно вспоминаем прошедший год. Для меня каждый год поднимается один и тот же вопрос: «Действительно ли я правильно изучал Django?»

Я работал с Django и Django REST Framework (DRF) уже несколько лет, проходил через крупные и мелкие проекты, и теперь могу сказать, что:

«Я понимаю, как и где работают различные части, и чувствую уверенность, чем раньше»

Конечно, всё ещё остаётся много неизвестного, но теперь я могу сказать своему прошлому «Если вы будете изучать в таком порядке, то не будете так сильно теряться».

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

1. Django – это в итоге фреймворк для работы с HTTP

Commandbox 광고

Это звучит очевидно, но при первом знакомстве с Django мы часто забываем об этом.

Независимо от того, рендерим ли мы UI или возвращаем только JSON, суть Django – получать HTTP‑запросы и отдавать HTTP‑ответы.

  • Клиент (браузер, приложение, другой сервер) посылает HTTP‑запрос.
  • Django принимает запрос и обрабатывает его.
  • Затем возвращает HTTP‑ответ (HTML, JSON, файл, ошибку и т.д.).

Типичные элементы Django:

  • URLConf
  • View (FBV/CBV)
  • Template
  • ORM
  • Middleware
  • Authentication / Permission
  • DRF: Serializer, ViewSet, Router…

Все они – лишь инструменты, помогающие получить запрос, обработать его и вернуть ответ.

Если вы упустите этот взгляд, фреймворк быстро превратится в «чудо‑коробку».

«Пока что так работает, но почему именно так?»

Если это состояние сохранится, вы начнёте «плыть» по фреймворку.

2. Понимайте «почему» до того, как использовать «что»

При первом изучении Django обычно привлекают такие функции:

  • Регистрация/авторизация, социальный вход
  • Управление правами
  • Настройка кэша
  • Асинхронные задачи (Celery и т.д.)
  • Различные middleware и настройки

Эти функции действительно нужны позже, но если вы погружаетесь в них слишком рано, возникают вопросы:

«Почему именно так?»

Если вы не можете ответить, код будет выглядеть:

  • Ошибки остаются «непонятными»
  • При изменении структуры вы будете «заперты» в фреймворке
  • Вы будете «копировать» решения из Google и продолжать работать, не понимая

Поэтому первое, что я бы сказал себе и новичкам:

«Сначала поймите принципы работы веба и HTTP, а уже потом – функции».

3. Понимание HTTP открывает глаза на «внешний» Django

Commandbox 광고

Чтобы «прозрачно» работать с Django, нельзя игнорировать базовый поток HTTP.

Ниже несколько вещей, которые стоит понять, погружаясь в практику:

  • Как выглядит запрос: URL, метод (GET/POST/PUT/DELETE…), заголовки, query‑строка, тело
  • Как определяется ответ: статус‑код, заголовки, тело (JSON/HTML и т.д.)
  • Что кэширует браузер, а что сервер должен учитывать

Пример простого запроса из терминала:

curl -X GET "http://localhost:8000/articles/1/" -H "Accept: application/json"

В этом запросе уже есть всё, что нужно для понимания HTTP:

  • URL: /articles/1/
  • Метод: GET
  • Заголовок: Accept: application/json
  • Ожидаемый формат ответа: JSON

Когда вы видите этот поток в уме, вы начинаете видеть и «внешний» Django:

  • Почему в nginx проксируем определённые пути к Django
  • Как работают WSGI‑серверы (gunicorn, uWSGI)
  • Что именно Django делает, а что – другие слои

В этот момент Django перестаёт быть «чудом» и становится «необходимой частью» HTTP‑обработки.

Функции Django – это просто вспомогательные инструменты. Понимание HTTP делает их естественным продолжением.

4. Первый проект – простейший, FBV

image of dev who is developing web service with Django

При начале изучения я рекомендую такой подход:

Первый проект – простейший, Function‑Based View (FBV).

Постарайтесь соблюсти следующие условия:

  • Минимальная реализация аутентификации/прав
  • Простая структура без сложных настроек
  • Простые модели (например, статьи и комментарии)
  • Фокус на «потоке» работы, а не на «красивой» архитектуре

Пример простого списка/деталей статьи в FBV:

# views.py
from django.http import JsonResponse
from .models import Article

def article_detail(request, pk):
    article = Article.objects.get(pk=pk)
    data = {
        "id": article.id,
        "title": article.title,
        "content": article.content,
    }
    return JsonResponse(data)

В этом одном представлении содержится весь поток Django:

  1. Принимаем объект request.
  2. С помощью pk извлекаем данные через ORM.
  3. Формируем словарь.
  4. Возвращаем его как JSON‑ответ.

Отслеживая каждый шаг, вы видите:

  • Как URL‑конфиг связывает URL с представлением
  • Что содержит объект request
  • Как ORM генерирует SQL
  • Как сериализуется ответ в JSON

Особенно полезно, если вы освоите ORM на этом этапе – это будет ценным ресурсом в любом проекте.

5. Далее – CBV и DRF

После того как вы освоили FBV, переходите к более «магическим» инструментам: CBV и DRF.

Преимущества:

  • Уменьшение повторяющихся шаблонов
  • Единый стиль по всему проекту
  • Чёткая ответственность компонентов
  • Расширяемость через URL/Serializer/ViewSet/Permission

Пример того же функционала в DRF:

# views.py (DRF)
from rest_framework.viewsets import ReadOnlyModelViewSet
from .models import Article
from .serializers import ArticleSerializer

class ArticleViewSet(ReadOnlyModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

И регистрация маршрута:

# urls.py
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet

router = DefaultRouter()
router.register(r'articles', ArticleViewSet, basename='article')

urlpatterns = router.urls

Теперь:

  • /articles/
  • /articles/{id}/

работают автоматически.

Если вы уже понимаете HTTP‑поток, то «магия» CBV/DRF становится просто абстракцией того же процесса.

«Внутри всё равно тот же HTTP‑запрос/ответ, но теперь он вынесен в класс».

Если что‑то непонятно – загляните в исходный код Django.

6. Итоговый порядок обучения

Для тех, кто только начинает, я предлагаю следующий план:

  1. Основы веба и HTTP - Поток запрос‑ответ - Методы, коды, заголовки, куки, сессии - Практика с curl/Postman
  2. Базовый Django: FBV - URLConf → View → Template → ORM - Мини‑проект без аутентификации - CRUD через ORM
  3. Глубже в ORM и Admin - Модели, связи, оптимизация запросов - Управление данными через Admin
  4. CBV - Generic View, mixins, наследование
  5. DRF - Serializer, ViewSet, Router, Permission, Authentication
  6. Только после – «красивые» функции - Аутентификация, throttling, pagination, filter - Кэш, асинхронные задачи, деплой, масштабирование

Главное – в каждом шаге уметь объяснить «почему».

7. Итоги: не учите фреймворк, учите веб

Наконец, хочу оставить одно послание:

Не учите фреймворк, учите, как работает веб.

Django – лишь инструмент, помогающий понять HTTP.

Если вы сохраняете этот взгляд, то:

  • Новые версии Django не будут вас сбивать
  • Вы легко перейдёте на Flask, FastAPI, Node, Spring и т.д.
  • Вы будете задавать одинаковые вопросы: «Какой слой отвечает за HTTP?», «Где происходит сериализация?»

И тогда вы станете разработчиком, который не «зависит» от конкретного фреймворка, а понимает фундаментальные принципы веба.