Основы веб-разработки на Django

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

Добро пожаловать в курс «Основы веб-разработки на Django». Это первая статья, с которой начнется ваше погружение в один из самых популярных и мощных веб-фреймворков в мире Python. Мы не будем тратить время на долгие теоретические рассуждения, а сразу перейдем к практике, попутно разбирая фундаментальные концепции.

Что такое Django и почему его выбирают?

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

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

Шаг 1: Подготовка и виртуальное окружение

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

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

Представьте, что вы строите два разных дома. Для одного вам нужен цемент марки М500, а для другого — М300. Если вы свалите весь цемент в одну кучу, начнется путаница.

В программировании так же: один проект может требовать Django версии 3.2, а другой — новейшую версию 5.0. Если устанавливать всё в глобальную систему Python, возникнет конфликт версий. Виртуальное окружение — это изолированная папка («ящик с инструментами»), в которую устанавливаются библиотеки только для конкретного проекта.

!Иллюстрация принципа изоляции зависимостей с помощью виртуальных окружений

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

Откройте терминал (командную строку) и создайте папку для вашего нового проекта, а затем перейдите в неё:

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

Если вы используете macOS или Linux, команда может выглядеть как python3 -m venv venv.

Активация окружения

Создать окружение мало, в него нужно «войти» (активировать).

Для Windows:

Для macOS и Linux:

После активации в начале строки вашего терминала появится надпись (venv). Это знак того, что теперь все команды pip install будут устанавливать библиотеки именно в эту изолированную папку.

Шаг 2: Установка Django

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

После завершения установки вы можете проверить, всё ли прошло успешно, запросив версию Django:

Шаг 3: Создание первого проекта

В терминологии Django есть важное различие между проектом (Project) и приложением (App).

* Проект — это глобальная конфигурация вашего веб-сайта. Это как фундамент и несущие стены здания. * Приложение — это отдельный модуль, выполняющий конкретную функцию (например, блог, форум, магазин). Проект может состоять из множества приложений.

Сейчас мы создадим сам проект. Назовем его config (это популярная практика, чтобы сразу понимать, где лежат настройки, но вы можете назвать его mysite).

Выполните команду:

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

Шаг 4: Структура проекта

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

Разберем назначение каждого файла. Это критически важно для понимания того, как работает Django.

1. manage.py

Это ваш пульт управления. С помощью этого скрипта вы будете запускать сервер, создавать миграции баз данных и создавать новые приложения. Это обертка вокруг системной утилиты django-admin, настроенная специально для вашего проекта.

2. Папка config/

Это сердце вашего проекта. Имя этой папки совпадает с тем именем, которое мы указали при создании проекта.

* settings.py: Самый важный файл. Здесь хранятся все настройки: подключение к базе данных, список установленных приложений, настройки безопасности, языковые параметры и часовые пояса. * urls.py: Это «оглавление» вашего сайта. Здесь вы описываете маршруты (URL-адреса). Например, вы указываете, что при переходе по адресу /about/ нужно показать страницу «О нас». * wsgi.py и asgi.py: Это точки входа для веб-серверов. Когда вы будете выкладывать сайт в интернет (деплоить), именно через эти файлы веб-серверы (например, Nginx или Apache) будут общаться с вашим Django-кодом. WSGI — старый стандарт, ASGI — новый, асинхронный. * __init__.py: Пустой файл, который говорит Python, что эта папка является пакетом и из неё можно импортировать модули.

!Визуализация ролей ключевых файлов в проекте Django

Шаг 5: Первый запуск сервера

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

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

Если всё прошло успешно, вы увидите вывод, похожий на этот:

Теперь откройте ваш браузер и перейдите по адресу http://127.0.0.1:8000/.

Вы должны увидеть приветственную страницу с ракетой и надписью «The install worked successfully! Congratulations!».

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

Резюме

Виртуальное окружение обязательно для изоляции зависимостей проекта.

Django устанавливается через pip внутри активированного окружения.

Команда django-admin startproject создает базовую структуру.

Файл settings.py отвечает за настройки, а urls.py — за маршрутизацию ссылок.

Сервер разработки запускается через python manage.py runserver.

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

В предыдущей статье мы установили Django, создали проект config и запустили сервер разработки. Теперь у нас есть работающий «двигатель», но наш сайт пока пуст. Любому современному веб-приложению — будь то блог, интернет-магазин или социальная сеть — необходимо хранить и обрабатывать данные.

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

Что такое ORM и зачем она нужна?

Традиционно для работы с базами данных (например, PostgreSQL, MySQL или SQLite) используется язык SQL. Это мощный инструмент, но он требует изучения отдельного синтаксиса и усложняет перенос проекта с одной базы данных на другую.

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

Простыми словами, ORM — это переводчик. Вы говорите на языке Python (классы, объекты, методы), а Django автоматически переводит это в SQL-запросы, понятные базе данных.

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

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

Безопасность: Django автоматически защищает от SQL-инъекций.

Скорость разработки: Вам не нужно писать длинные SQL-запросы вручную.

Переносимость: Вы можете начать разработку на простой SQLite (идет в комплекте), а затем переключиться на мощную PostgreSQL, изменив всего пару строк в настройках.

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

В прошлой статье мы говорили, что проект состоит из приложений. Давайте создадим наше первое приложение, которое будет отвечать за функционал блога. Назовем его blog.

Остановите сервер (если он запущен), нажав Ctrl+C в терминале, и выполните команду:

Теперь в папке проекта появилась новая директория blog. Но Django пока не знает о её существовании. Чтобы «активировать» приложение, нужно добавить его в настройки.

Откройте файл config/settings.py, найдите список INSTALLED_APPS и добавьте туда строку 'blog':

> Важно: Не забывайте ставить запятую после каждого элемента списка, даже последнего. Это хорошая практика в Python.

Шаг 2: Проектирование модели

Модель в Django — это класс Python, который описывает структуру хранимых данных. Каждая модель обычно соответствует одной таблице в базе данных, а атрибуты класса — полям этой таблицы.

Откройте файл blog/models.py. Сейчас он почти пуст. Давайте создадим модель для поста в блоге. Нам понадобятся заголовок, текст статьи и дата публикации.

Разбор кода:

* class Post(models.Model): — объявляем модель. Наследование от models.Model сообщает Django, что этот класс нужно сохранить в базе данных. * models.CharField — поле для короткого текста (требует указания max_length). * models.TextField — поле для длинного текста неограниченной длины. * models.DateTimeField — поле для даты и времени. * def __str__(self): — этот «магический» метод определяет, как объект будет отображаться в виде строки (например, в админ-панели). Мы хотим видеть заголовок поста, а не безликое Post object (1).

Шаг 3: Миграции — изменение структуры БД

Мы написали код модели, но база данных об этом еще не знает. Процесс внесения изменений в структуру БД в Django делится на два этапа:

Создание миграции (makemigrations): Django сканирует ваши модели, сравнивает их с текущим состоянием и создает файл-инструкцию (чертеж) о том, что нужно изменить.

Применение миграции (migrate): Django берет этот чертеж и выполняет реальные SQL-команды в базе данных.

!Иллюстрация двухэтапного процесса обновления базы данных в Django.

Выполните в терминале:

Вы увидите сообщение: Migrations for 'blog': blog/migrations/0001_initial.py - Create model Post. Это значит, что Django создал файл с инструкциями.

Теперь применим их:

Django применит не только нашу миграцию, но и встроенные миграции для системы аутентификации и админки (так как мы запускаем это впервые). Теперь в вашей базе данных (файл db.sqlite3) создана таблица для постов.

Шаг 4: Django Shell и запросы (Queries)

Чтобы проверить работу, нам не обязательно сразу создавать HTML-страницы. Мы можем воспользоваться интерактивной консолью Django — Shell. Она похожа на обычный Python-интерпретатор, но в неё уже загружены настройки вашего проекта.

Запустите оболочку:

Создание объектов (Create)

Импортируем нашу модель и создадим первый пост:

Если вы увидите <Post: Мой первый пост>, значит объект успешно сохранен в базе.

Чтение объектов (Read)

Для получения данных используется менеджер objects.

Получить все записи:

Фильтрация данных: Давайте найдем посты, где в заголовке есть слово "Django".

Обратите внимание на двойное подчеркивание __. Это специальный синтаксис Django для фильтрации полей.

Получение одной конкретной записи: Если мы знаем уникальный ID записи:

> Важно: Метод get() вернет ошибку, если запись не найдена или если найдено больше одной записи. Метод filter() всегда возвращает список (QuerySet), даже если он пустой.

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

Изменим текст поста:

Удалим пост:

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

Резюме

Сегодня мы сделали огромный шаг вперед:

Узнали, что ORM позволяет работать с базой данных, используя классы Python.

Создали приложение blog и зарегистрировали его в settings.py.

Описали структуру данных в файле models.py.

Научились создавать и применять миграции (makemigrations, migrate).

Попробовали CRUD-операции (Create, Read, Update, Delete) через консоль Django.

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

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

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

В этой статье мы свяжем данные с интерфейсом. Мы разберем, как Django обрабатывает входящие запросы, кто решает, какую страницу показать, и как превратить сухие данные из базы в красивую HTML-страницу.

Архитектура MVT (Model-View-Template)

Большинство веб-фреймворков используют архитектуру MVC (Model-View-Controller). Django использует похожий, но немного отличающийся подход, который называется MVT.

Давайте разберем эту аббревиатуру:

M (Model) — Модель: Это то, что мы делали в прошлой статье. Описание данных и работа с базой данных.

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

T (Template) — Шаблон: Это внешний вид. HTML-файл, в который подставляются данные.

!Схематичное изображение потока данных: от запроса пользователя через URL и View к базе данных и шаблону, и обратно.

Аналогия с рестораном

Чтобы проще понять MVT, представьте ресторан:

* Пользователь — это голодный клиент. * URL (Адрес) — это строчка в меню, на которую указывает клиент. * View (Представление) — это официант. Он принимает заказ, идет на кухню (в базу данных), забирает еду и несет её клиенту, сервируя на тарелке. * Model (Модель) — это кладовая с продуктами (база данных) и повар, который их готовит. * Template (Шаблон) — это чистая тарелка и способ сервировки. Официант (View) кладет еду (данные) на тарелку (Template) перед подачей.

В Django роль «Контроллера» (из классического MVC) берет на себя сам фреймворк, управляя маршрутизацией запросов. Поэтому разработчику остается написать только Модель, Представление и Шаблон.

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

Когда пользователь вводит адрес сайта, например mysite.com/blog/, Django должен понять, какую функцию запустить. За это отвечает файл urls.py.

В нашем проекте есть главный файл config/urls.py. Но хорошей практикой считается создавать отдельный файл urls.py для каждого приложения, чтобы поддерживать порядок.

Создание urls.py в приложении

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

Разберем этот код: * path('', ...): Пустая строка означает, что это главная страница приложения blog. * views.post_list: Это ссылка на функцию post_list, которую мы напишем чуть позже в файле views.py. * name='post_list': Уникальное имя маршрута. Это очень важно: в будущем мы будем ссылаться на этот URL по имени, а не писать жестко /blog/.

Подключение к главному проекту

Теперь нужно сказать главному проекту, что у нас есть маршруты в приложении blog. Откройте config/urls.py и измените его:

Функция include работает как переключатель на железной дороге. Она говорит Django: «Всё, что приходит на главную страницу, отправляй разбираться в файл blog/urls.py».

Шаг 2: Создание Представления (View)

Мы указали в urls.py, что хотим вызывать функцию views.post_list. Но этой функции еще нет, и если запустить сервер, мы получим ошибку. Давайте её создадим.

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

Что здесь происходит?

def post_list(request):: Любая view-функция первым аргументом всегда принимает request (объект запроса), который содержит информацию о пользователе, браузере и т.д.

Post.objects.all(): Мы используем ORM, чтобы забрать все посты. Метод .order_by('-created_date') сортирует их по дате создания (знак минус означает обратный порядок — от новых к старым).

return render(...): Функция render собирает всё вместе. Она берет запрос request, шаблон blog/post_list.html и словарь данных {'posts': posts}. Ключ этого словаря ('posts') станет именем переменной, доступной в HTML-шаблоне.

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

Теперь у нас есть данные, но нет «тарелки», на которой их подать. Нам нужно создать HTML-файл.

По умолчанию Django ищет шаблоны в папке templates внутри каждого приложения. Структура папок должна быть такой:

blog/templates/blog/post_list.html

> Почему такая вложенность blog/templates/blog? Это сделано для избежания конфликтов имен, если у вас будет несколько приложений с одинаковыми названиями файлов шаблонов (например, index.html).

Создайте эти папки и файл post_list.html. Напишем простой HTML-код с использованием Django Template Language (DTL).

Синтаксис шаблонизатора Django

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

{{ variable }} — Двойные фигурные скобки используются для вывода значения переменной. В нашем случае {{ post.title }} выведет заголовок поста.

{% tag %} — Фигурные скобки с процентами используются для логических операций (циклы, условия).

В примере выше мы использовали цикл {% for post in posts %}. Переменная posts пришла к нам из views.py (помните словарь {'posts': posts}?). Внутри цикла мы обращаемся к каждому отдельному посту как к переменной post.

Обязательно нужно закрывать цикл тегом {% endfor %}.

!Процесс превращения шаблона с переменными в готовый HTML-код с данными.

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

Теперь, когда все три компонента MVT готовы, давайте проверим работу.

Убедитесь, что сервер запущен: python manage.py runserver.

Откройте браузер и перейдите по адресу http://127.0.0.1:8000/.

Вы должны увидеть список ваших постов, которые вы создавали в предыдущем уроке через консоль. Если вы видите посты — поздравляю! Вы только что создали свой первый динамический веб-сайт.

Резюме

Сегодня мы замкнули круг работы веб-приложения:

URLconf (urls.py) перехватывает адрес, введенный пользователем, и направляет его в нужное представление.

View (views.py) принимает запрос, запрашивает данные у Модели и передает их в Шаблон.

Template (.html) получает данные и отображает их пользователю, используя специальные теги {{ }} и {% %}.

В следующей статье мы займемся улучшением внешнего вида нашего блога, подключив CSS-стили и Bootstrap, чтобы он выглядел как современный веб-продукт, а не как документ из 90-х.

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

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

Настоящий веб-сервис начинается там, где пользователь может влиять на контент: писать комментарии, регистрироваться, создавать посты или оформлять заказы. Для этого нам нужны формы.

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

Основы HTTP: GET против POST

Прежде чем писать код, нужно понять, как браузер общается с сервером. Протокол HTTP (язык, на котором они говорят) имеет несколько методов, но чаще всего вы будете использовать два:

GET (Получить) — используется для запроса данных. Когда вы вводите адрес в строку браузера или переходите по ссылке, вы отправляете GET-запрос. Параметры могут передаваться прямо в адресной строке (например, ?search=django). GET-запросы не должны менять состояние сервера (ничего не удаляют и не создают).

POST (Отправить) — используется для отправки данных на сервер для обработки (создание новой записи, вход в систему). Данные передаются в «теле» запроса и скрыты от глаз пользователя в адресной строке. Этот метод безопаснее для передачи паролей и текстов.

!Визуальная метафора различий между открытым GET-запросом и защищенным POST-запросом, меняющим состояние сервера.

Django Forms: зачем они нужны?

Вы можете создать HTML-форму вручную, используя теги <input> и <form>. Но тогда вам придется: * Самостоятельно проверять данные (валидация). * Защищаться от хакерских атак (XSS, CSRF). * Следить, чтобы данные соответствовали типам в базе данных.

Django берет эту рутину на себя. Система форм в Django умеет:

Генерировать HTML-код формы автоматически.

Проверять данные на лету (например, убедиться, что в поле email введен именно email).

Сохранять очищенные данные сразу в модель.

Шаг 1: Создание формы (ModelForm)

В нашем приложении blog мы хотим создавать объекты модели Post. Django позволяет не дублировать код и создать форму прямо на основе модели. Это называется ModelForm.

Создайте новый файл forms.py внутри папки вашего приложения blog (на одном уровне с models.py и views.py).

Разбор кода:

* Мы импортируем модуль forms и нашу модель Post. * class Meta — это конфигурация формы. Мы говорим Django: «Построй форму на основе модели Post и включи в неё только поля title (заголовок) и text (текст)». * Мы не включили created_date и published_date, так как дата создания ставится автоматически, а дату публикации мы можем проставить позже.

Шаг 2: Логика представления (View)

Теперь самое интересное. Нам нужно создать представление, которое умеет делать две вещи:

Показывать пустую форму, когда пользователь только зашел на страницу (GET-запрос).

Принимать заполненную форму, проверять её и сохранять, если пользователь нажал кнопку «Сохранить» (POST-запрос).

Откройте blog/views.py и добавьте новую функцию post_new. Не забудьте импортировать PostForm и redirect.

!Логическая схема обработки формы в Django View, показывающая разделение потоков для GET и POST запросов.

Что такое form.is_valid()?

Это метод, который запускает механизм валидации. Если вы указали в модели, что поле title не может быть длиннее 200 символов, а пользователь ввел 300 — is_valid() вернет False, и Django автоматически добавит описание ошибки в объект формы, чтобы мы могли показать его пользователю.

Шаг 3: Шаблон и CSRF-защита

Теперь создадим файл blog/templates/blog/post_edit.html.

Ключевые моменты:

method="POST": Мы явно указываем браузеру отправлять данные методом POST.

{% csrf_token %}: Это критически важно! Django имеет встроенную защиту от Cross-Site Request Forgery (межсайтовой подделки запроса). Если вы не добавите этот тег, Django заблокирует отправку формы и выдаст ошибку 403. Этот тег генерирует скрытое поле с секретным ключом, который проверяет сервер.

{{ form.as_p }}: Эта магическая команда берет вашу форму и рендерит каждое поле, обернутое в тег параграфа <p>. Это самый быстрый способ вывести форму. Также существуют .as_table и .as_ul.

Шаг 4: Маршрутизация (URL)

Осталось связать адрес страницы с нашим представлением. Откройте blog/urls.py и добавьте строку:

Теперь, если вы запустите сервер (python manage.py runserver) и перейдете по адресу http://127.0.0.1:8000/post/new/, вы увидите форму создания поста.

Валидация в действии

Попробуйте нажать кнопку «Сохранить», оставив поля пустыми. Вы увидите, что браузер (или сам Django) попросит заполнить поля. Это работает атрибут required, который Django добавил в HTML автоматически, потому что в модели эти поля обязательны.

Если вы заполните форму и нажмете «Сохранить», вас перенаправит на главную страницу, где вверху списка появится ваш новый пост.

Резюме

Работа с формами в Django строится на трех китах:

ModelForm (forms.py): Описывает, какие поля модели мы хотим дать пользователю для редактирования.

View (views.py): Обрабатывает два сценария — отображение пустой формы (GET) и сохранение данных (POST).

Template (.html): Выводит форму с помощью {{ form.as_p }} и обязательно включает {% csrf_token %} для безопасности.

В следующей статье мы поговорим о том, как сделать наш блог красивым, подключив CSS и статические файлы, чтобы уйти от скучного черно-белого текста.

Администрирование и безопасность: настройка админ-панели, регистрация и аутентификация пользователей

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

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

Сегодня мы разберем две мощнейшие возможности Django, которые идут «из коробки»:

Административная панель — готовый интерфейс для управления данными.

Система аутентификации — механизмы входа, выхода и регистрации пользователей.

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

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

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

Чтобы попасть в админку, нам нужен пользователь с максимальными правами — суперпользователь (superuser).

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

Система задаст вам несколько вопросов: * Username: введите имя (например, admin). * Email address: можно оставить пустым (нажмите Enter). * Password: введите пароль. Внимание: при вводе пароля курсор не будет двигаться, символы не будут отображаться. Это мера безопасности. Просто введите пароль и нажмите Enter. * Password (again): повторите пароль.

Если пароль слишком простой, Django предупредит об этом, но вы можете согласиться, нажав y.

Вход в админку

Запустите сервер:

Перейдите в браузере по адресу http://127.0.0.1:8000/admin/. Вы увидите красивую форму входа. Введите данные созданного суперпользователя.

!Страница авторизации в панели администратора Django

После входа вы увидите разделы «Groups» и «Users». Это встроенные модели Django. Но где же наши посты?

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

Django не добавляет ваши модели в админку автоматически, потому что не все модели нужно там показывать. Мы должны явно «зарегистрировать» их.

Откройте файл blog/admin.py и измените его:

Обновите страницу админки в браузере. Теперь вы видите раздел Blog и таблицу Posts. Вы можете зайти туда, создавать новые посты, удалять старые и редактировать существующие. И всё это без написания HTML-кода!

Настройка отображения

Сейчас список постов выглядит скучно: просто перечисление названий (благодаря методу __str__, который мы добавили ранее). Если постов будет тысяча, найти нужный станет сложно. Давайте улучшим интерфейс.

Изменим blog/admin.py, создав класс конфигурации:

Обновите страницу. Теперь у вас есть полноценная таблица с датами, фильтр справа и поиск сверху. Это профессиональный инструмент управления контентом.

Часть 2: Аутентификация и Авторизация

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

Аутентификация (Authentication) — проверка того, кто вы такой. (Пример: ввод логина и пароля).

Авторизация (Authorization) — проверка того, что вам разрешено делать. (Пример: обычный пользователь может читать статьи, а редактор — удалять их).

Django берет на себя большую часть работы по обоим направлениям.

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

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

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

Эта строка accounts/ подключает набор готовых URL-адресов: login, logout, сброс пароля и другие.

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

Если вы сейчас перейдете по адресу http://127.0.0.1:8000/accounts/login/, Django выдаст ошибку: TemplateDoesNotExist. Он ожидает найти шаблон в папке registration/login.html.

Давайте создадим его. В папке blog/templates/ создайте новую папку registration, а в ней файл login.html.

Полный путь: blog/templates/registration/login.html.

Обратите внимание на <input type="hidden" name="next" value="{{ next }}">. Это важный механизм. Если пользователь пытался зайти на защищенную страницу, Django запомнит этот адрес в переменной next. После успешного входа пользователь будет перенаправлен именно туда, куда хотел попасть изначально.

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

Куда перенаправлять пользователя после входа, если переменная next пуста? По умолчанию Django отправляет в профиль, которого у нас нет. Давайте скажем ему отправлять всех на главную страницу.

Откройте config/settings.py и добавьте в самый конец файла:

Теперь попробуйте зайти по адресу http://127.0.0.1:8000/accounts/login/. Введите данные суперпользователя. Если всё настроено верно, вас перебросит на главную страницу со списком постов.

Часть 3: Защита представлений (Views)

Мы научились входить в систему, но кнопка «Создать пост» и страница /post/new/ всё еще доступны любому прохожему. Исправим это.

Мы будем использовать декоратор @login_required. Декоратор — это «обертка» для функции, которая добавляет ей новую способность. В нашем случае — способность проверять, вошел ли пользователь в систему.

Откройте blog/views.py:

Мы добавили @login_required прямо перед объявлением функции post_new.

!Принцип работы защиты доступа к страницам

Теперь попробуйте сделать следующее:

Выйдите из системы (перейдите по http://127.0.0.1:8000/accounts/logout/ или удалите куки).

Попробуйте зайти на http://127.0.0.1:8000/post/new/.

Django автоматически перехватит ваш запрос и перенаправит вас на страницу входа: /accounts/login/?next=/post/new/. Видите параметр ?next=? Именно он поможет вернуть вас к созданию поста после того, как вы введете пароль.

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

У нас есть вход, но нет регистрации. Для этого нам нужно создать собственное представление и форму. К счастью, у Django есть готовая форма UserCreationForm.

Создадим файл blog/views.py (добавим новую функцию):

Теперь добавим маршрут в blog/urls.py:

И создадим простой шаблон blog/templates/registration/register.html:

Теперь любой желающий может создать аккаунт на вашем сайте!

Резюме

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

Админ-панель: Мы активировали мощный интерфейс для управления контентом и настроили его отображение через admin.ModelAdmin.

Аутентификация: Подключили встроенные URL-адреса Django для входа в систему.

Шаблоны: Создали страницу входа login.html в папке registration.

Безопасность: Защитили страницу создания поста с помощью декоратора @login_required.

Регистрация: Реализовали возможность создания новых пользователей через UserCreationForm.

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