Python Backend-разработка на Django

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

Добро пожаловать в курс по Backend-разработке на Python! Мы начинаем погружение в один из самых мощных и популярных веб-фреймворков в мире — Django. В этой статье мы разберем, что такое Django, зачем нужны виртуальные окружения, как создать свой первый проект и из чего он состоит.

Что такое Django и философия «Batteries Included»

Django — это высокоуровневый веб-фреймворк на языке Python, который поощряет быструю разработку и чистый, прагматичный дизайн. Он был создан разработчиками новостного издания для того, чтобы успевать публиковать материалы в сжатые сроки.

Главная особенность Django описывается фразой «Batteries included» (Батарейки в комплекте). Это означает, что «из коробки» вы получаете множество инструментов, которые в других фреймворках пришлось бы настраивать вручную или устанавливать отдельно:

* ORM (Object-Relational Mapping) — работа с базой данных через объекты Python, без необходимости писать SQL-запросы вручную. * Административная панель — готовый интерфейс для управления контентом. * Аутентификация — система регистрации, входа и управления правами пользователей. * Безопасность — защита от распространенных атак (SQL Injection, XSS, CSRF).

!Схема обработки запроса в Django: от пользователя к серверу и базе данных.

Подготовка рабочего окружения

Прежде чем писать код, необходимо подготовить фундамент. Профессиональная разработка на Python немыслима без использования виртуальных окружений.

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

Представьте, что вы работаете над двумя проектами: «Интернет-магазин» и «Личный блог». Магазин написан год назад и использует Django версии 3.2, а блог вы начинаете сейчас и хотите использовать новейший Django 5.0. Если вы установите Django глобально на свой компьютер, возникнет конфликт версий. Вы не сможете запустить оба проекта одновременно.

Виртуальное окружение (Virtual Environment) — это изолированная папка, которая содержит свою версию интерпретатора Python и набор библиотек, необходимых конкретному проекту. Это позволяет каждому проекту иметь свои собственные зависимости, не мешая другим.

Шаг 1: Проверка установки Python

Убедитесь, что у вас установлен Python версии 3.8 или выше. Откройте терминал (командную строку) и введите:

Если команда не найдена, попробуйте python3 --version (актуально для macOS/Linux).

Шаг 2: Создание виртуального окружения

Создайте папку для вашего нового проекта и перейдите в нее:

Теперь создадим виртуальное окружение. Мы назовем его venv (стандартное название):

Эта команда создаст папку venv, в которой будут лежать изолированные файлы Python.

Шаг 3: Активация виртуального окружения

Чтобы компьютер понял, что мы хотим использовать именно это окружение, его нужно активировать.

Для Windows:

Для macOS и Linux:

После активации в начале строки терминала появится надпись (venv). Это знак того, что вы находитесь в изолированном пространстве.

Установка Django и создание проекта

Теперь, когда мы защищены виртуальным окружением, установим сам фреймворк.

Установка через pip

pip — это менеджер пакетов Python. Выполните команду:

Чтобы убедиться, что установка прошла успешно, можно проверить версию:

Создание проекта

В терминологии Django есть два важных понятия:

Проект (Project) — это глобальная конфигурация вашего веб-сайта. Это контейнер для всего веб-приложения.

Приложение (App) — это отдельный модуль, отвечающий за конкретную функциональность (например, модуль новостей, модуль чата, модуль опросов).

Один проект может состоять из множества приложений. Одно приложение может использоваться в разных проектах.

Создадим проект с названием config. Часто корневую папку конфигурации называют config, core или именем сайта.

> Обратите внимание: Точка . в конце команды очень важна. Она говорит Django создать проект в текущей папке, а не создавать новую вложенную папку. Это делает структуру удобнее.

Структура проекта Django

После выполнения команды ваша папка будет выглядеть так:

!Файловая структура только что созданного Django-проекта.

Разберем назначение каждого файла:

1. manage.py

Это утилита командной строки для взаимодействия с вашим проектом. Через этот файл вы будете запускать сервер, создавать миграции баз данных и создавать новые приложения. Вы не должны редактировать этот файл.

2. Папка config/ (пакет конфигурации)

Это «сердце» вашего проекта.

* __init__.py: Пустой файл, который говорит Python, что эта папка является пакетом. * settings.py: Самый важный файл. Здесь хранятся все настройки: подключение к базе данных, список установленных приложений, настройки безопасности, языковые параметры и многое другое. * urls.py: «Оглавление» вашего сайта. Здесь вы описываете, какой URL (адрес страницы) соответствует какой функции обработки. Например, /about/ -> показать страницу «О нас». * wsgi.py и asgi.py: Точки входа для веб-серверов (таких как Gunicorn или Uvicorn), которые будут обслуживать ваш сайт в продакшене (на реальном хостинге).

Запуск сервера разработки

Django поставляется с легким веб-сервером для разработки, чтобы вы могли видеть результаты своей работы без настройки сложного ПО.

Убедитесь, что вы находитесь в папке с файлом manage.py, и выполните:

Вы увидите вывод, похожий на этот:

Теперь откройте браузер и перейдите по адресу http://127.0.0.1:8000/. Вы должны увидеть приветственную страницу с ракетой, которая сообщает: «The install worked successfully! Congratulations!».

Создание первого приложения (App)

Как мы говорили ранее, проект состоит из приложений. Давайте создадим наше первое приложение, например, для управления задачами. Назовем его tasks.

Остановите сервер (нажмите Ctrl+C в терминале) и введите:

Появится новая папка tasks со своей структурой:

* migrations/ — папка для хранения истории изменений базы данных. * admin.py — настройки админ-панели для этого приложения. * apps.py — метаданные приложения. * models.py — здесь описываются структуры данных (таблицы БД). * tests.py — место для написания тестов. * views.py — здесь пишется логика обработки запросов (что показать пользователю).

Регистрация приложения

Просто создать папку недостаточно. Нужно «сообщить» проекту config, что у него появилось новое приложение tasks. Для этого откройте файл config/settings.py, найдите список INSTALLED_APPS и добавьте туда название вашего приложения:

Теперь Django знает о существовании tasks и будет учитывать его при работе.

Заключение

Сегодня мы заложили фундамент для будущей разработки. Мы научились:

Изолировать зависимости с помощью виртуального окружения.

Устанавливать Django.

Создавать проект и запускать локальный сервер.

Понимать разницу между проектом и приложением.

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

Для более глубокого изучения вы всегда можете обратиться к официальной документации Django, которая считается одной из лучших в мире Open Source.

Работа с данными: проектирование моделей, миграции, ORM и панель администратора

В предыдущей статье мы подготовили почву: установили Django, создали проект config и заготовку приложения tasks. Однако пока наше приложение — это просто пустая оболочка. Оно не умеет хранить информацию. Если мы перезагрузим сервер, любые данные, которые мы могли бы передать, исчезнут.

Чтобы приложение стало полезным, ему нужна память. В веб-разработке роль памяти выполняет база данных (БД). В этой статье мы разберем, как Django работает с базами данных, не заставляя вас писать сложные SQL-запросы.

Философия моделей Django

В классической разработке вам часто приходится дублировать логику: сначала вы создаете таблицу в базе данных с помощью SQL (например, CREATE TABLE tasks...), а затем описываете класс в коде, который соответствует этой таблице. Django решает эту проблему с помощью подхода DRY (Don't Repeat Yourself).

В Django Модель (Model) — это единственный и достоверный источник информации о ваших данных. Она содержит поля и поведение данных, которые вы храните. Обычно одна модель отображается в одну таблицу базы данных.

ORM: Мост между Python и SQL

Django использует мощный механизм, называемый ORM (Object-Relational Mapping). Это технология, которая связывает объекты в коде (на Python) с реляционными таблицами в базе данных (SQL).

!Визуализация того, как ORM преобразует объекты Python в записи базы данных.

Благодаря ORM вам не нужно знать диалект SQL конкретной базы данных (PostgreSQL, MySQL, SQLite). Вы пишете на Python, а Django переводит это на язык базы данных.

Создание первой модели

Давайте откроем файл tasks/models.py. Сейчас он почти пуст. Мы создадим модель для хранения задач. Наша задача должна иметь заголовок, описание, статус (выполнена или нет) и дату создания.

Добавьте следующий код в tasks/models.py:

Разбор полей модели

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

models.CharField: Поле для хранения коротких строк. Обязательный аргумент max_length ограничивает длину строки (в нашем случае 200 символов).

models.TextField: Поле для длинного текста без ограничений по размеру. Параметр blank=True означает, что поле может быть пустым (задача может быть без описания).

models.BooleanField: Логическое поле (Истина/Ложь). default=False задает значение по умолчанию: новая задача считается невыполненной.

models.DateTimeField: Поле для хранения даты и времени. auto_now_add=True автоматически подставит текущее время в момент создания записи. Больше вам не нужно заботиться об этом поле вручную.

Магический метод __str__

Метод __str__ определяет, как объект будет отображаться в виде строки (например, в панели администратора). Если его не переопределить, вы увидите безликое Task object (1). Мы же хотим видеть заголовок задачи.

Миграции: Управление изменениями БД

Мы написали код модели, но база данных об этом еще не знает. Если вы сейчас посмотрите в БД, таблицы tasks_task там не будет. Чтобы синхронизировать наш код с базой данных, используются миграции.

Миграции — это файлы, которые хранят историю изменений вашей схемы данных. Это как Git, но для структуры базы данных.

Шаг 1: Создание миграций

Выполните команду в терминале (убедитесь, что виртуальное окружение активировано):

Вы увидите сообщение:

Django просканировал ваши модели, увидел, что появилась новая модель Task, и создал файл-инструкцию 0001_initial.py о том, как создать соответствующую таблицу.

Шаг 2: Применение миграций

Теперь нужно выполнить эту инструкцию:

Django выполнит необходимые SQL-команды, и таблица будет создана. Вы увидите список примененных миграций (включая системные миграции для админки и аутентификации, если вы запускаете это впервые).

> Важно: Каждый раз, когда вы меняете что-то в models.py (добавляете поле, меняете тип), вы должны выполнять пару команд: makemigrations (создать план) -> migrate (применить план).

Django Shell: Работа с данными через консоль

Прежде чем строить веб-страницы, давайте научимся управлять данными напрямую через Python. Django предоставляет интерактивную консоль (shell).

Запустите её командой:

Теперь мы находимся внутри окружения нашего проекта. Давайте поработаем с нашей моделью.

Создание записей (Create)

Сначала импортируем модель:

Создадим новую задачу:

Метод save() выполняет SQL-запрос INSERT и сохраняет запись в базу. Есть и более короткий способ, который сразу сохраняет объект:

Чтение записей (Read)

Чтобы получить все задачи, используется менеджер objects:

Обратите внимание, что вывод содержит заголовки задач — это работает наш метод __str__.

Чтобы найти конкретную задачу по условию, используется filter или get:

Обновление и удаление (Update & Delete)

Для выхода из консоли введите exit().

Панель администратора Django

Одна из самых сильных сторон Django — автоматически генерируемая админ-панель. Она позволяет менеджерам и администраторам управлять контентом сайта без написания кода.

Создание суперпользователя

Чтобы попасть в админку, нам нужен аккаунт с правами администратора. Создадим его:

Введите имя пользователя (например, admin), email (можно оставить пустым) и пароль. Пароль при вводе не будет отображаться — это нормально.

Регистрация модели в админке

По умолчанию наша модель Task не видна в админ-панели. Мы должны явно сказать Django отображать её. Откройте файл tasks/admin.py и добавьте:

Что мы сделали:

Импортировали модель Task.

Создали класс TaskAdmin, который наследуется от admin.ModelAdmin.

list_display указывает, какие поля показывать в общем списке задач.

list_filter добавляет боковую панель для фильтрации (например, показать только выполненные).

search_fields добавляет строку поиска по заголовку и описанию.

Проверка результата

Запустите сервер разработки:

Перейдите по адресу http://127.0.0.1:8000/admin/ и войдите под созданным суперпользователем.

!Интерфейс панели администратора Django после регистрации модели Task.

Теперь вы можете создавать, редактировать и удалять задачи через удобный графический интерфейс. Это именно то, что называют "Batteries included" — функционал, на разработку которого в других фреймворках ушли бы дни, здесь доступен за 5 минут.

Заключение

В этой статье мы сделали огромный шаг вперед:

Спроектировали структуру данных с помощью Моделей.

Научились применять изменения через Миграции.

Попробовали управлять данными через Python-консоль (ORM).

Настроили профессиональную Панель администратора.

Теперь у нас есть данные, но они доступны только администратору. В следующей статье мы займемся тем, чтобы вывести эти данные обычным пользователям: разберем Views (Представления) и Templates (Шаблоны), чтобы создать HTML-страницы нашего списка задач.

Для более глубокого погружения в типы полей и возможности ORM рекомендуем изучить официальную документацию по моделям.

Архитектура приложения: маршрутизация URL, представления (Views) и работа с шаблонами

В предыдущих статьях мы создали надежный фундамент: настроили проект Django и спроектировали базу данных с помощью моделей. Мы даже научились управлять данными через административную панель. Однако для обычного пользователя наш сайт все еще недоступен. Если вы попытаетесь зайти на главную страницу, вы увидите либо стандартную заглушку Django, либо ошибку 404.

В этой статье мы свяжем все компоненты воедино. Мы разберем архитектурный паттерн MVT (Model-View-Template), настроим маршрутизацию URL, напишем логику отображения данных и создадим HTML-страницы.

Архитектура MVT: Как Django обрабатывает запросы

Django следует паттерну проектирования, который называется MVT (Model-View-Template). Это вариация классического MVC (Model-View-Controller), но с некоторыми особенностями в терминологии.

!Схема обработки веб-запроса в архитектуре Django MVT

Разберем каждый компонент:

URL Dispatcher (Маршрутизатор): «Швейцар» вашего сайта. Он смотрит на адрес строки (например, /tasks/) и решает, какую функцию Python нужно вызвать.

View (Представление): «Мозг» приложения. Это функция или класс, который получает запрос, запрашивает данные из базы (через Модель) и решает, какой шаблон показать пользователю.

Template (Шаблон): «Лицо» сайта. Это HTML-файл, который содержит разметку и специальные теги Django для вставки данных.

Шаг 1: Маршрутизация URL (urls.py)

Когда пользователь вводит адрес сайта, Django ищет совпадение в файле config/urls.py. Это глобальное оглавление проекта.

Однако, хорошей практикой считается децентрализация: каждое приложение (app) должно само управлять своими адресами. Поэтому мы подключим маршруты нашего приложения tasks к главному проекту.

Откройте config/urls.py и измените его следующим образом:

Теперь создайте новый файл urls.py внутри папки вашего приложения tasks/ (изначально его там нет). Добавьте в него следующий код:

Разберем функцию path: * Первый аргумент — строковый шаблон URL. Пустая строка '' означает главную страницу приложения. * Второй аргумент — ссылка на функцию во views.py, которая будет обрабатывать запрос. * Третий аргумент name — уникальное имя маршрута, которое позволит нам ссылаться на него из кода, не прописывая жесткие ссылки.

Шаг 2: Представления (Views)

Теперь Django знает, что при заходе на главную страницу нужно вызвать функцию task_list из модуля views. Но этой функции еще не существует. Давайте напишем её.

Откройте файл tasks/views.py. Наша задача — получить все задачи из базы данных и передать их в шаблон.

Разбор кода View:

* request: Каждый view-функция обязана принимать первым аргументом объект request. Он содержит всю информацию о запросе (IP-адрес пользователя, данные браузера, параметры GET/POST). * Task.objects.all(): Мы используем ORM, изученный в прошлой статье, для получения данных. * render(): Эта функция объединяет статический HTML-шаблон и динамические данные (context), возвращая готовый ответ (HttpResponse) браузеру.

Шаг 3: Шаблоны (Templates)

Теперь нам нужно создать HTML-файл. По умолчанию Django ищет шаблоны в папке templates внутри каждого приложения.

Создайте следующую структуру папок внутри tasks: tasks/templates/tasks/

> Важно: Обратите внимание на вложенность templates/tasks/. Это необходимо для пространства имен, чтобы Django не перепутал шаблоны с одинаковыми именами из разных приложений.

Создайте файл task_list.html в этой папке:

Язык шаблонов Django (DTL)

Django Template Language (DTL) позволяет внедрять логику прямо в HTML. Он использует два основных типа синтаксиса:

Переменные {{ variable }}: Выводят значение переменной на экран. Например, {{ page_title }} выведет строку "Список всех задач", которую мы передали из views.py.

Теги {% tag %}: Управляют логикой отображения (циклы, условия).

В нашем примере мы использовали: * {% for task in tasks %} — цикл, который проходит по списку задач. * {% if task.is_completed %} — условие для проверки статуса задачи. * {% empty %} — специальный блок, который сработает, если список tasks пуст.

Теперь, если вы запустите сервер (python manage.py runserver) и перейдете на http://127.0.0.1:8000/, вы увидите список ваших задач, созданных ранее.

Наследование шаблонов: принцип DRY в HTML

Представьте, что на вашем сайте 10 страниц. На каждой из них есть одинаковая «шапка» (меню) и «подвал» (контакты). Копировать этот код в каждый файл — плохая идея. Если нужно будет изменить пункт меню, придется править 10 файлов.

Django решает это через наследование шаблонов.

Создание базового шаблона

Создайте папку templates в корне проекта (рядом с manage.py), а в ней файл base.html. Чтобы Django увидел эту папку, нужно добавить настройку в config/settings.py:

Теперь наполним base.html:

Тег {% block name %} определяет места, которые дочерние шаблоны могут перезаписывать.

Обновление списка задач

Теперь перепишем наш tasks/templates/tasks/task_list.html, используя наследование:

Код стал намного чище. Мы просто говорим: «Возьми base.html и вставь внутрь блока content вот этот список».

Динамические URL и детальный просмотр

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

1. Настройка URL

Добавим новый маршрут в tasks/urls.py:

Запись <int:pk> означает: «Ожидай здесь целое число и передай его в функцию view под именем pk (primary key)». Например, адрес task/5/ вызовет функцию с pk=5.

2. Создание View

В tasks/views.py добавим функцию:

Функция get_object_or_404 — это удобный шорткат. Вместо того чтобы писать конструкцию try...except для поиска объекта, мы используем эту функцию. Она либо находит объект, либо автоматически генерирует страницу «Страница не найдена».

3. Создание шаблона

Создайте tasks/templates/tasks/task_detail.html:

Обратите внимание на использование фильтров (символ |): * date:"d M Y" форматирует дату. * yesno:"..." преобразует булево значение в текст. * linebreaks преобразует переносы строк в тексте в HTML-теги <p> и <br>.

Тег {% url 'task_list' %} генерирует ссылку автоматически, используя имя маршрута, которое мы задали в urls.py. Это позволяет менять структуру URL в одном месте, не ломая ссылки по всему сайту.

Заключение

Сегодня мы превратили наш backend-код в полноценное веб-приложение. Мы разобрали:

Как маршрутизатор направляет запросы к функциям.

Как представления (Views) получают данные из моделей.

Как шаблоны (Templates) отображают эти данные пользователю.

Как использовать наследование шаблонов для чистоты кода.

Теперь у нас есть работающий каталог задач. В следующей статье мы научимся не только читать данные, но и создавать их через веб-интерфейс, используя Django Forms.

Взаимодействие с пользователем: формы, валидация данных и система аутентификации

В предыдущих статьях мы построили фундамент нашего приложения: спроектировали базу данных, настроили административную панель и научились выводить информацию на страницы. Однако наш сайт пока работает в режиме «только для чтения». Пользователи могут смотреть на список задач, но не могут создавать новые, не имея доступа к админке.

В этой статье мы превратим наше приложение в полноценный интерактивный сервис. Мы разберем три ключевых столпа веб-разработки:

Формы (Forms) — механизм ввода данных.

Валидация (Validation) — проверка корректности этих данных.

Аутентификация (Authentication) — система регистрации и входа пользователей.

Django Forms: мост между пользователем и базой данных

HTML-формы — это основа взаимодействия в вебе. Однако ручная обработка <form> (получение данных из запроса, проверка типов, защита от атак) — это рутинная и опасная работа. Django берет эту работу на себя.

ModelForm: автоматическое создание форм

Поскольку у нас уже есть модель Task, нам не нужно описывать форму с нуля. Django позволяет создать форму, которая «знает» о структуре модели. Это называется ModelForm.

Создайте новый файл tasks/forms.py и добавьте туда следующий код:

Что здесь происходит: * Мы наследуемся от forms.ModelForm. * В классе Meta мы указываем, с какой моделью работаем (Task). * В fields мы перечисляем поля, которые хотим доверить пользователю. Обратите внимание, что мы не включили is_completed и created_at, так как эти поля должны устанавливаться автоматически или позже.

Обработка формы во View

Теперь нам нужно создать представление (View), которое будет работать в двух режимах:

GET-запрос: Показать пользователю пустую форму.

POST-запрос: Принять данные, проверить их и сохранить.

!Схема жизненного цикла обработки формы: от получения запроса до сохранения данных или вывода ошибок.

Добавим новую функцию в tasks/views.py:

Шаблон с защитой CSRF

Создайте файл шаблона tasks/templates/tasks/task_form.html:

Ключевые моменты: * method="post": Данные отправляются скрыто, а не в адресной строке. * {% csrf_token %}: Обязательный тег безопасности Django. Он генерирует уникальный токен, защищающий от атак типа Cross-Site Request Forgery (подделка межсайтовых запросов). Без него Django отклонит запрос. * {{ form.as_p }}: Магический метод, который рендерит все поля формы, обернутые в теги параграфов <p>. Также существуют .as_table и .as_ul.

Не забудьте добавить маршрут в tasks/urls.py:

Валидация данных

Валидация — это процесс проверки данных на соответствие требованиям. Django выполняет базовую валидацию автоматически: * Если поле title пустое, форма не отправится (так как в модели оно обязательное). * Если в поле даты ввести текст, Django вернет ошибку.

Пользовательская валидация

Допустим, мы хотим запретить создание задач с названием «Скука». Для этого добавим метод очистки (cleaning method) в наш класс формы в tasks/forms.py:

Метод должен называться clean_<имя_поля>. Если данные некорректны, мы выбрасываем исключение ValidationError, и Django автоматически покажет эту ошибку рядом с полем в HTML.

Система аутентификации

Теперь, когда мы умеем создавать задачи, возникает проблема: любой посетитель сайта может создать задачу. Нам нужно ограничить доступ.

Django поставляется с мощной системой аутентификации «из коробки». Нам нужно лишь подключить её.

Настройка URL для входа и выхода

Откройте глобальный файл config/urls.py и добавьте пути аутентификации:

Эта одна строка include('django.contrib.auth.urls') добавляет маршруты для входа, выхода и сброса пароля. По умолчанию Django будет искать шаблоны в папке registration.

Создание шаблона входа

Создайте папку templates/registration (в корне проекта, там же, где base.html) и файл login.html внутри:

Теперь при переходе на /accounts/login/ вы увидите форму входа. Используйте логин и пароль суперпользователя, который вы создали ранее.

Настройка перенаправления

После успешного входа Django должен знать, куда направить пользователя. Добавьте в config/settings.py:

Регистрация новых пользователей

Для регистрации нам понадобится собственное представление, так как Django не предоставляет готового View для регистрации (только форму). Мы используем встроенную форму UserCreationForm.

В tasks/views.py:

Не забудьте добавить маршрут в tasks/urls.py (path('register/', views.register, name='register')) и создать шаблон registration/register.html (аналогичный login.html).

Защита доступа

Теперь у нас есть пользователи, но они все еще могут заходить на страницу создания задачи без авторизации. Исправим это с помощью декоратора.

Декоратор — это «обертка» для функции, которая меняет её поведение.

В tasks/views.py:

Теперь, если неавторизованный пользователь попытается зайти на страницу создания задачи, Django автоматически перенаправит его на страницу входа.

Адаптация интерфейса

Давайте изменим наш base.html, чтобы показывать разные ссылки для гостей и пользователей:

> Обратите внимание: Начиная с Django 5.0, выход из системы (logout) рекомендуется делать через POST-запрос (форму), а не через обычную ссылку, ради безопасности.

Заключение

Мы проделали большую работу. Наше приложение стало по-настоящему динамичным:

Мы научились принимать данные от пользователей через ModelForms.

Реализовали защиту от некорректных данных с помощью валидации.

Внедрили систему аутентификации, разделив права доступа.

Теперь вы можете создавать, просматривать и защищать данные. Это базовый цикл работы любого веб-приложения. Для более глубокого изучения форм рекомендуем обратиться к официальной документации Django Forms.

В следующей части курса мы займемся «полировкой» нашего проекта: добавим стили (CSS), улучшим дизайн и подготовим проект к публикации в интернете.

Продвинутая разработка: создание API с Django REST Framework и подготовка к деплою

Мы прошли долгий путь: от установки Django и создания первых моделей до разработки полноценного веб-приложения с формами и авторизацией. На данном этапе у нас есть работающий сайт, где сервер отдает браузеру готовые HTML-страницы. Такой подход называется Monolithic Architecture (Монолитная архитектура).

Однако современная веб-разработка часто требует иного подхода. Что если мы хотим создать мобильное приложение для нашего списка задач? Или сделать динамичный фронтенд на React или Vue.js? Мобильные приложения не понимают HTML-верстку, им нужны «сырые» данные.

В этой статье мы трансформируем наш проект, добавив к нему API (Application Programming Interface), и подготовим его к публикации в интернете (деплою).

Часть 1: Создание API с Django REST Framework

Чтобы наш сервер мог общаться с другими программами (мобильными приложениями, сторонними сервисами), он должен отдавать данные в универсальном формате. Стандартом де-факто сейчас является JSON.

Для Django существует мощный инструмент, который стал стандартом индустрии — Django REST Framework (DRF).

Установка и настройка

Первым делом установим библиотеку. Убедитесь, что ваше виртуальное окружение активировано:

Теперь подключим его в config/settings.py в список установленных приложений:

Сериализаторы: переводчик для данных

База данных хранит информацию в таблицах. Python работает с объектами классов. А внешнему миру нужен JSON (текст). Чтобы преобразовать сложные объекты Python (например, Task) в JSON и обратно, используются Сериализаторы (Serializers).

!Сериализатор преобразует объекты базы данных в формат JSON, понятный фронтенду и мобильным приложениям.

Создайте файл tasks/serializers.py:

Этот код очень похож на ModelForm, который мы изучали ранее. ModelSerializer автоматически анализирует модель и создает логику для превращения её полей в JSON.

ViewSets: логика обработки запросов

В классическом Django мы писали функции views, которые возвращали render (HTML). В DRF мы используем специальные классы, которые возвращают данные.

Самый быстрый способ создать API — использовать ModelViewSet. Он автоматически реализует операции CRUD (Create, Read, Update, Delete).

Откройте tasks/views.py и добавьте:

Всего три строки кода, и мы создали контроллер, который умеет показывать список задач, создавать новые, редактировать и удалять их.

Маршрутизация (Routers)

Для API маршруты строятся немного иначе. DRF предоставляет Router, который автоматически создает URL-адреса для нашего ViewSet.

Создайте (или измените) файл tasks/urls.py:

Проверка работы

Запустите сервер (python manage.py runserver) и перейдите по адресу http://127.0.0.1:8000/api/tasks/.

Вы увидите не просто текст, а красивый веб-интерфейс Browsable API. Это одна из киллер-фич DRF: вы можете тестировать свое API прямо в браузере, отправлять POST-запросы и видеть ответы.

Часть 2: Подготовка к деплою (Deploy)

Наш проект работает локально. Но как показать его миру? Процесс переноса кода с компьютера разработчика на публичный сервер называется деплоем.

Запускать python manage.py runserver на реальном сервере — категорически запрещено. Этот сервер предназначен только для разработки, он не выдержит нагрузки и небезопасен.

1. Переменные окружения

В вашем файле settings.py есть секретный ключ SECRET_KEY. Если злоумышленник узнает его, он сможет взломать сессии пользователей. Хранить такие данные в коде нельзя, особенно если вы выкладываете код на GitHub.

Мы будем использовать библиотеку python-dotenv для хранения секретов в отдельном файле.

Установите её:

Создайте в корне проекта файл .env (без имени, только расширение) и перенесите туда секреты:

Теперь изменим config/settings.py:

> Важно: Файл .env никогда не должен попадать в репозиторий Git. Обязательно добавьте его в .gitignore.

2. WSGI-сервер: Gunicorn

Вместо встроенного сервера разработки нам нужен промышленный сервер приложений. Для Linux-серверов стандартом является Gunicorn.

Установка:

Запуск проекта через Gunicorn выглядит так (локально это работать не будет на Windows без дополнительных настроек, но на сервере Linux это основная команда):

3. Статические файлы и WhiteNoise

Django не умеет эффективно отдавать картинки и CSS-файлы в продакшене. Обычно для этого ставят отдельный сервер (Nginx), но есть более простой способ для Python — библиотека WhiteNoise.

Установка:

Настройка в settings.py:

Теперь при деплое вы будете выполнять команду:

Эта команда соберет все файлы стилей и скриптов из всех приложений в одну папку staticfiles, откуда WhiteNoise сможет их раздавать.

4. Фиксация зависимостей

Сервер должен знать, какие библиотеки нужно установить. Для этого создается файл requirements.txt.

Этот файл содержит список всех установленных пакетов и их версий. На сервере вы просто запустите pip install -r requirements.txt, и окружение восстановится.

Заключение курса

Поздравляем! Вы прошли путь от создания пустой папки до архитектуры профессионального веб-сервиса.

Мы изучили:

Структуру Django: проекты и приложения.

ORM: управление базой данных без SQL.

MVT: создание страниц и шаблонов.

Forms & Auth: взаимодействие с пользователем.

DRF: создание современного API.

Deploy: основы подготовки к продакшену.

Backend-разработка — это огромный мир. Дальше вас ждут изучение Docker, настройка CI/CD, работа с очередями задач (Celery) и кэшированием (Redis). Но фундамент, заложенный в этом курсе, позволит вам уверенно двигаться дальше. Удачи в коде!