Первый сайт с помощью Django Python

Что такое Django простыми словами?

Представь, что ты решил построить дом. Конечно, можно создать всё самому — от фундамента до крыши. Но это долго, сложно, да и опыта может не хватить. Гораздо проще взять готовые детали и собрать из них дом быстро и без ошибок.

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

Зачем нужен Django и почему он так популярен?

Разработчики любят Django, потому что он решает много стандартных проблем, с которыми все сталкиваются при создании сайтов:

• Экономия времени и сил: Django придерживается правила DRY («Don’t Repeat Yourself» или «Не повторяй себя»). Это значит, что тебе не нужно писать один и тот же код несколько раз. Представь, что ты печёшь торт и каждый раз должен бы был заново изобретать рецепт — звучит странно, правда? С Django у тебя уже есть проверенный рецепт, нужно просто добавлять свои «ингредиенты».
• Безопасность по умолчанию: Django заботится о том, чтобы твой сайт не был взломан. Это как установить хорошие замки на двери твоего дома — спокойно и надежно.
• Легкая работа с базами данных: Django использует ORM (Object-Relational Mapping) — это как удобный переводчик между языком Python и базой данных. Тебе не нужно знать SQL, чтобы хранить и получать данные из базы, Django сделает это за тебя.
• Большое сообщество и крутая документация: Django пользуется огромной популярностью, и если у тебя возник вопрос, всегда есть кто-то, кто уже его решил и может помочь.

Кто использует Django в реальном мире?

Django настолько хорош, что на нём построены очень известные сайты, которыми ты точно пользуешься или хотя бы слышал о них:

• Instagram — одна из крупнейших соцсетей, в которой ты наверняка делишься фотками и сторис с друзьями.
• Pinterest — классная площадка для поиска вдохновения, от рецептов до идей интерьера.
• Spotify — популярный сервис для прослушивания музыки, который знают и любят по всему миру.

Это примеры того, как Django подходит для проектов разного масштаба, от небольших блогов до огромных платформ с миллионами пользователей.

Что нужно знать, чтобы начать изучать Django?

Чтобы уверенно начать изучение Django, тебе нужно:

• Уметь писать простой код на Python (например, создавать переменные, использовать циклы и функции).
• Иметь базовое представление о HTML и CSS. Но даже если этих знаний пока нет, их можно получить параллельно с Django.

Как выглядит проект на Django? Быстрая экскурсия

Типичный Django-проект выглядит примерно так:

myproject/
├── manage.py (управляет проектом, вроде пульта от телевизора)
└── myproject/
    ├── __init__.py (показывает Python, что здесь находится пакет)
    ├── settings.py (здесь живут все настройки проекта)
    ├── urls.py (список адресов страниц сайта, как оглавление в книге)
    ├── wsgi.py (нужен для запуска сайта на сервере)
    └── asgi.py (для запуска сайта в асинхронном режиме, пока для нас просто красивое слово)

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

Давай проверим себя!

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

• Можешь своими словами рассказать, что такое Django?
• Какие проблемы помогает решить Django?
• Почему Django считается безопасным?
• Знаешь ли ты сайты, созданные на Django?
• Что такое ORM и почему это удобно?

Задание 1. Хочешь попробовать сам?

Вот небольшое упражнение для уверенности (по желанию):

• Установи Django командой:

pip install django

• Создай проект:

django-admin startproject myproject

• Запусти сервер и проверь, что всё получилось:

cd myproject
python manage.py runserver

• Теперь открой браузер и перейди по ссылке:

http://127.0.0.1:8000/

Готово! Ты только что сделал свой первый маленький шаг в Django. Круто, правда?

Отлично! Теперь переходим к следующему разделу. Вот как можно подробно и доступно раскрыть тему «Архитектура Django» для новичков:

Архитектура Django

Что такое архитектура MTV?

Архитектура Django называется MTV — это сокращение от английских слов Model, Template и View. Если перевести на понятный язык, это означает, что Django разделяет сайт на три главные части:

• Model (Модель) – это данные сайта, которые хранятся в базе данных. Например, статьи, комментарии, профили пользователей — всё это данные.
• Template (Шаблон) – это то, как твой сайт выглядит для пользователя. Грубо говоря, это HTML-страницы с картинками, текстом и стилями.
• View (Представление) – это логика сайта, то есть функции, которые решают, какие данные из модели нужно взять и какой шаблон показать пользователю.

Представь ресторан:

• Модель – это кухня и холодильник с продуктами.
• Шаблон – это сервировка блюд и интерьер ресторана.
• Представление – это официант, который принимает заказ, забирает блюдо из кухни и приносит тебе.

Теперь становится понятнее, правда?

Как Django обрабатывает запросы?

Когда пользователь открывает страницу сайта, происходит вот что:

запрос → URL → View → Model → Template → ответ

Разберём на примере:

1. Ты открываешь страницу по ссылке mysite.com/articles.
2. Django смотрит в файл с адресами (urls.py) и проверяет, какая функция (View) должна выполнить этот запрос.
3. Функция-представление (View) получает нужные данные из базы через модель (Model). Например, последние статьи.
4. Затем View выбирает подходящий шаблон (Template) и передает в него полученные данные.
5. Шаблон формирует страницу и Django отправляет её тебе обратно.

Основные компоненты Django:

Вот главные компоненты, которые важно запомнить:

• Models (Модели) – работают с данными, сохраняют их и достают из базы.
• Views (Представления) – содержат логику работы сайта, решают, какие данные нужно получить и какой шаблон использовать.
• Templates (Шаблоны) – формируют HTML-страницы, которые видит пользователь.
• URL (Маршруты) – определяют, какая View должна запуститься в ответ на конкретный запрос.
• Middleware (Промежуточный слой) – промежуточный слой обработки запросов, например, для проверки авторизации или записи действий пользователя.

Закрепляем материал (устный опрос):

Ответь своими словами на эти вопросы:

• Что такое MTV-архитектура Django?
• За что отвечает модель в Django?
• В чём разница между View и Template?
• Как Django понимает, какая именно View должна обработать запрос?

Задание 2. Мини-практика (по желанию):

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

1. Нарисуй простую схему на бумаге, показывающую, как Django обрабатывает запросы.
   (Подсказка: запрос → URL → View → Model → Template → ответ)
2. Определи, к какому компоненту (Model, View или Template) относится каждый из примеров:

• HTML-файл с дизайном страницы.
• Функция, которая берет данные из базы и отправляет их в шаблон.
• Структура данных, хранящая информацию о пользователях.

Так ты закрепишь знания и будешь лучше понимать, как всё устроено в Django! 😊

Фреймворк Django — это высокоуровневый Python фреймворк, который позволяет создавать быстрые и масштабируемые веб-приложения. Django основан на шаблонной модели проектирования и имеет множество встроенных функций и библиотек, которые значительно упрощают процесс разработки веб-приложений. Django также предоставляет мощную систему ORM (Object-Relational Mapping) для взаимодействия с базами данных.

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

Настройка проекта Django (виртуальное окружение и конфигурация)

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

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

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

• venv — уже встроен в Python (рекомендуется новичкам)
• virtualenv — отдельная библиотека, требует отдельной установки

Советую использовать venv, так как он уже есть у тебя вместе с Python, и не требует ничего дополнительно устанавливать.

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

Давай создадим виртуальное окружение для нашего Django-проекта:

python -m venv env

После выполнения этой команды у тебя появится папка env. Теперь её нужно активировать:

• На Windows:

.\env\Scripts\activate

• На Linux и macOS:

source env/bin/activate

Когда окружение активно, ты увидишь (env) в командной строке — значит, всё получилось!

Устанавливаем Django и другие зависимости

Теперь установим сам Django:

pip install django

Если хочешь сохранить список всех зависимостей (это хорошая практика!), то создай файл requirements.txt:

pip freeze > requirements.txt

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

pip install -r requirements.txt

Создание и базовая настройка Django-проекта

Теперь создадим сам проект. Для этого вводим команду:

django-admin startproject mysite

У тебя появится папка с таким содержимым:

mysite/
├── manage.py (главный управляющий проектом, запускает сервер и другие задачи)
└── mysite/
    ├── __init__.py (делает папку Python-пакетом)
    ├── settings.py (настройки проекта)
    ├── urls.py (маршруты твоего сайта)
    ├── wsgi.py (для запуска проекта на сервере)
    └── asgi.py (для асинхронного запуска, позже расскажем подробнее)

Теперь немного настроим проект в файле settings.py:

• База данных (DATABASES): Django по умолчанию использует SQLite, он прост и подходит для обучения и небольших проектов.
• Язык и часовой пояс:

  LANGUAGE_CODE = 'ru-ru'
  TIME_ZONE = 'Europe/Moscow'
  

• Статические файлы (картинки, CSS, JavaScript):

  STATIC_URL = '/static/'
  STATIC_ROOT = BASE_DIR / 'static/'
  

• Отладочный режим (показывает ошибки, но в продакшене лучше выключить):

  DEBUG = True
  

Вот и всё! Наш базовый Django-проект готов к работе.

Закрепляем материал (устный опрос):

Попробуй ответить на вопросы:

• Что такое виртуальное окружение и зачем оно нужно?
• Как создать виртуальное окружение в Python?
• Как установить Django в виртуальном окружении?
• Для чего нужен файл requirements.txt?
• Какие важные параметры нужно настроить в Django-проекте сразу после его создания?

Задание 3. Мини-практика (обязательно):

Самое время попробовать самому!

1. Создай и активируй виртуальное окружение.
2. Установи Django.
3. Создай новый Django-проект и запусти его:

cd mysite
python manage.py runserver

Перейди в браузере по адресу:

http://127.0.0.1:8000/

Если увидишь стандартную приветственную страницу Django — поздравляю! Ты успешно выполнил все шаги!

Создание первого приложения на Django (views, urls)

Что такое приложение в Django и чем оно отличается от проекта?

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

Например, один проект может включать:

• приложение для ведения блога,
• приложение для интернет-магазина,
• приложение для регистрации пользователей.

Каждое из них можно создавать, подключать или отключать независимо друг от друга.

Как создать приложение в Django?

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

python manage.py startapp myapp

После этой команды появится папка myapp с файлами:

myapp/
├── migrations/ (для отслеживания изменений в базе)
├── __init__.py (делает папку Python-пакетом)
├── admin.py (настройка админки Django)
├── apps.py (конфигурация приложения)
├── models.py (модели данных)
├── tests.py (для тестирования)
└── views.py (логика отображения страниц)

Теперь нужно сообщить Django, что у нас появилось новое приложение. Для этого открываем файл settings.py и добавляем наше приложение в список:

INSTALLED_APPS = [
    # ... уже существующие приложения
    'myapp',
]

Создаём свою первую View-функцию

View-функция в Django — это небольшая функция, которая решает, что будет происходить при запросе пользователя. Она принимает запрос (HttpRequest) и возвращает ответ (HttpResponse).

Давай создадим простую View-функцию в файле views.py нашего приложения:

from django.http import HttpResponse

def hello(request):
    return HttpResponse("Привет, это моё первое приложение на Django!")

Здесь HttpRequest — запрос от пользователя, а HttpResponse — то, что пользователь увидит в браузере.

Настраиваем URL-адреса

Теперь нужно сообщить Django, по какому адресу можно увидеть результат работы нашей View-функции.

В папке приложения создай новый файл urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello, name='hello'),
]

Затем подключи эти адреса в главный файл проекта (mysite/urls.py):

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

Теперь, если ты перейдёшь по адресу http://127.0.0.1:8000/hello/, то увидишь сообщение:

Привет, это моё первое приложение на Django!

Круто, правда?

Закрепляем знания (устный опрос):

• Чем отличается приложение от проекта в Django?
• Какой командой можно создать новое приложение?
• Что делает View-функция?
• Почему и для чего нужны URL-адреса в Django?

Задание 4. Практическое задание (обязательно):

Попробуй самостоятельно сделать следующее:

1. Создай новое приложение в своём Django-проекте.
2. Создай простую View-функцию, которая возвращает текст.
3. Настрой URL, чтобы эту страницу можно было открыть в браузере.
4. Проверь, что всё работает, открыв нужный URL.

Так ты получишь опыт и сразу увидишь результат своей работы! 😊

Работа с моделями и базами данных (ORM, миграции)

Что такое база данных (БД)?

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

Какие бывают базы данных?

Базы данных бывают двух основных типов:

• Реляционные (SQL) – это традиционные базы данных, похожие на таблицы в Excel. Самые популярные: SQLite, PostgreSQL, MySQL.
• Нереляционные (NoSQL) – хранят данные в формате документов или пар ключ-значение, например, MongoDB.

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

Что такое ORM в Django?

ORM (Object Relational Mapping) — это механизм, благодаря которому можно работать с базой данных, не изучая специальный язык запросов (SQL).

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

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

• Удобство (ты пишешь простой и понятный код)
• Возможность легко сменить тип базы данных
• Защита от ошибок и взломов (например, SQL-инъекций)

Что такое модель в Django?

Модель в Django — это описание того, какие данные мы будем хранить в нашей базе данных.

В каждой модели мы указываем:

• название модели (например, «Книга» или «Автор»),
• поля с типами данных (текст, число, дата и т.п.).

Вот пример простейшей модели:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()

Эта модель автоматически создаёт таблицу в базе данных с полями: название книги, автор и дата публикации.

Типы полей моделей Django и примеры

В Django есть несколько основных типов полей, которые ты будешь использовать:

• CharField — короткие текстовые данные (название статьи, имя пользователя).
• TextField — длинный текст (описания, комментарии).
• IntegerField, FloatField — числа (цена, рейтинг).
• DateField, DateTimeField — даты (дата рождения, дата публикации).
• BooleanField — логическое значение (да или нет).
• ForeignKey, ManyToManyField, OneToOneField — связи между моделями (например, автор книги).

Пример использования связи (автор и книга):

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

Что такое миграции?

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

Основные команды для работы с миграциями:

python manage.py makemigrations  # Создание миграций
python manage.py migrate         # Применение миграций

Что такое Django Shell?

Django Shell — это интерактивный режим работы с моделями. Его можно запустить командой:

python manage.py shell

Пример работы в Django Shell:

from myapp.models import Book

# Создание новой книги
book = Book(title='Мастер и Маргарита', author='М. Булгаков', published_date='1929-01-01')
book.save()

# Просмотр всех книг
Book.objects.all()

Закрепляем теорию (устный опрос):

• Что такое база данных и зачем она нужна?
• Что такое модель в Django и для чего она используется?
• Что такое ORM и какие у него преимущества?
• Что такое миграции и как с ними работать в Django?
• Какие типы полей бывают в Django и как ими пользоваться?
• Какие связи между моделями можно создавать в Django?

Задание 5. Практическое задание (обязательно):

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

1. Создай новое приложение (например, «Книжный магазин»).
2. Создай две связанные модели: «Автор» и «Книга» с разными типами полей.
3. Выполни миграции и проверь, что таблицы создались.
4. Через Django Shell добавь несколько авторов и книг и посмотри, как они сохраняются и извлекаются.

Это поможет тебе почувствовать себя увереннее и увидеть реальные результаты своей работы!

Работа с Django Shell

Что такое Django Shell простыми словами?

Django Shell — это специальный инструмент для работы с проектом Django прямо из командной строки.

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

Это как лаборатория, где ты можешь попробовать всё, что угодно, не боясь что-то сломать!

Зачем нужен Django Shell?

• Быстрая проверка и отладка моделей: проверяй, правильно ли работают твои модели, и исправляй ошибки мгновенно.
• Работа с данными без дополнительных скриптов: легко добавляй, изменяй или удаляй данные напрямую.
• Изучение ORM: лучшее место, чтобы понять, как ORM общается с твоей базой данных.

Как запустить Django Shell?

Запустить Django Shell очень просто. Выполни команду в папке проекта:

python manage.py shell

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

Что можно делать в Django Shell?

Основные возможности:

• Создание объектов
• Запросы к базе данных (через удобные методы ORM)
• Изменение и удаление объектов

Типичные примеры работы в Django Shell:

Импортируем модели:

from myapp.models import Book, Author

Создаём объект и сохраняем его:

author = Author(name="Джордж Оруэлл")
author.save()

book = Book(title="1984", author=author)
book.save()

Получаем все объекты:

books = Book.objects.all()
print(books)

Фильтрация объектов:

books_by_orwell = Book.objects.filter(author__name="Джордж Оруэлл")
print(books_by_orwell)

Удаление объекта:

book_to_delete = Book.objects.get(title="1984")
book_to_delete.delete()

Почему Django Shell — это классно?

• Быстрое тестирование и отладка: экономишь много времени.
• Простота изучения ORM: сразу видишь, как работают запросы и модели.
• Минимум лишних действий: не нужно создавать специальные страницы или шаблоны, чтобы проверить свой код.

Устный опрос (для закрепления):

• Что такое Django Shell и зачем он нужен?
• Как запустить Django Shell?
• Как создать и сохранить объект модели в Django Shell?
• Как получить данные из базы через Django Shell?

Задание 6. Практическое задание (обязательно):

Чтобы закрепить навыки, выполни простые шаги:

1. Создай модели «Автор» (Author) и «Книга» (Book) с несколькими полями.
2. Сделай миграции и примени их.
3. Запусти Django Shell.
4. Создай и сохрани несколько объектов (авторов и книг).
5. Сделай простые запросы:
   • выведи все книги,
   • найди книги конкретного автора,
   • удали одну из книг.

Это задание даст тебе уверенность и покажет, насколько удобно использовать Django Shell для работы с данными! 😊

Работа с формами и валидацией данных в Django

Что такое формы в Django и зачем они нужны?

Формы в Django — это инструмент, который позволяет пользователям отправлять данные на твой сайт.

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

Типы форм в Django

В Django есть два основных типа форм:

• Простые формы (Form) — используются, когда не нужна связь с моделью напрямую.
• Модельные формы (ModelForm) — автоматически создаются на основе моделей данных. Удобны, когда нужно сохранять данные в базу.

Как создать простую форму (Form)?

Простая форма определяется так:

from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()
    message = forms.CharField(widget=forms.Textarea)

Здесь ты явно задаёшь поля и их типы.

Как создать модельную форму (ModelForm)?

Модельная форма создаётся автоматически на основе модели. Это экономит время и упрощает работу:

from django import forms
from .models import Feedback

class FeedbackForm(forms.ModelForm):
    class Meta:
        model = Feedback
        fields = ['name', 'email', 'message']

Здесь Django сам возьмёт поля из указанной модели.

Что такое валидация и зачем она нужна?

Валидация — это проверка введённых данных на правильность и корректность. Например, проверка email на правильность формата или ограничение длины имени. Это защищает от неправильных данных и ошибок.

В Django уже есть базовая встроенная валидация. Но ты можешь написать свою, если нужно:

class ContactForm(forms.Form):
    name = forms.CharField(max_length=50)

    def clean_name(self):
        name = self.cleaned_data['name']
        if "django" in name.lower():
            raise forms.ValidationError("Имя не должно содержать слово 'django'.")
        return name

Как показать форму в шаблоне?

Django позволяет легко отобразить форму в шаблоне:

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Отправить</button>
</form>

Как обрабатывать формы во view-функциях?

View-функция принимает форму, проверяет данные и сохраняет их, если всё хорошо:

from django.shortcuts import render, redirect
from .forms import FeedbackForm

def feedback_view(request):
    if request.method == 'POST':
        form = FeedbackForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('success')
    else:
        form = FeedbackForm()

    return render(request, 'feedback.html', {'form': form})

Закрепляем теорию (устный опрос):

• Что такое форма в Django и зачем она нужна?
• Чем отличается обычная форма (Form) от модельной (ModelForm)?
• Как проверить, правильные ли данные отправил пользователь?
• Что такое валидация и зачем она нужна?

Задание 7. Практическое задание (обязательно):

Попробуй выполнить следующие шаги:

1. Создай простую модель Feedback с полями: name, email, message.
2. Создай модельную форму FeedbackForm.
3. Реализуй view-функцию, которая принимает форму и сохраняет данные.
4. Отобрази форму на странице и проверь её работу, отправляя разные данные.

Это поможет тебе почувствовать уверенность и научиться быстро создавать формы для приёма и обработки данных в Django! 😊

URL-маршрутизация в Django

Что такое URL-маршрутизация и зачем она нужна?

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

Например:

• пользователь вводит URL /about/, Django запускает функцию, показывающую страницу «О нас».
• вводит /blog/post/5/, запускается функция, показывающая статью №5.

Как устроен файл urls.py?

Файл urls.py — это карта твоего сайта, где описаны все маршруты и указаны функции, которые отвечают за каждый маршрут.

Пример простого файла маршрутов:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home_page, name='home'),
    path('about/', views.about_page, name='about'),
]

Здесь понятно:

• При открытии главной страницы (/) запустится home_page().
• При открытии страницы /about/ — about_page().

Создание URL-шаблонов (с параметрами)

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

Рассмотрим пример:

path('blog/<int:post_id>/', views.blog_post, name='blog_post'),

Что это значит?

• <int:post_id> говорит Django, что URL будет содержать целое число (int), которое нужно передать в view-функцию.
• Если пользователь откроет /blog/3/, Django запустит функцию blog_post(request, post_id=3).
• Внутри функции ты можешь использовать это число, чтобы найти статью в базе данных:

def blog_post(request, post_id):
    post = Post.objects.get(id=post_id)  # Получаем статью из базы
    return render(request, 'blog/post.html', {'post': post})

URL с регулярными выражениями (re_path())

Когда маршруты более сложные, можно использовать регулярные выражения.

Например:

from django.urls import re_path

re_path(r'^article/(?P<slug>[\w-]+)/$', views.article_detail, name='article_detail')

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

• Регулярка (?P<slug>[\w-]+) принимает любое сочетание букв, цифр и дефисов (например: django-intro, hello-world).
• URL типа /article/django-intro/ попадёт под эту регулярку, и Django запустит функцию article_detail(request, slug='django-intro').

Пример view-функции для такого маршрута:

def article_detail(request, slug):
    article = Article.objects.get(slug=slug)
    return render(request, 'article/detail.html', {'article': article})

Включение URL-файлов приложений (include)

В больших проектах URL-адреса удобно делить на отдельные файлы по приложениям.

Пример структуры проекта:

myproject/
├── blog/
│   └── urls.py
├── shop/
│   └── urls.py
└── myproject/
    └── urls.py

Главный файл myproject/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),
    path('shop/', include('shop.urls')),
]

Файл приложения blog/urls.py может выглядеть так:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.blog_home, name='blog_home'),
    path('post/<int:post_id>/', views.blog_post, name='blog_post'),
]

При обращении на /blog/post/10/ Django сначала проверит главный файл urls.py, увидит blog/ и перейдёт в файл blog/urls.py, а уже там найдёт подходящий маршрут (post/<int:post_id>/).

Зачем нужны именованные маршруты (name)?

Именованные маршруты — это удобные ярлыки, чтобы не писать полный URL вручную.

Пример маршрута с именем:

path('contact/', views.contact_page, name='contact')

Теперь ссылаться на него можно так:

• В шаблонах:

<a href="{% url 'contact' %}">Контакты</a>

• В Python-коде:

from django.urls import reverse

url = reverse('contact')

Это удобно, потому что если URL поменяется, то его нужно поменять только в одном месте.

Устный опрос (для закрепления):

• Что такое URL-маршрутизация и для чего она нужна?
• Какая функция используется для задания маршрута?
• Зачем нужны именованные маршруты?
• Как передать параметры через URL и зачем это нужно?

Задание 8. Практическое задание (обязательно):

1. Создай приложение «Калькулятор».
2. Напиши две view-функции:
   • add(request, a, b) — складывает два числа.
   • subtract(request, a, b) — вычитает второе число из первого.
3. Настрой URL с параметрами:

urlpatterns = [
    path('add/<int:a>/<int:b>/', views.add, name='add'),
    path('subtract/<int:a>/<int:b>/', views.subtract, name='subtract'),
]

4. Проверь работу:
   • URL /add/3/5/ → результат: «3 + 5 = 8»
   • URL /subtract/10/4/ → результат: «10 — 4 = 6»

Создание шаблонов и работа с HTML (шаблонизатор Django)

Что такое шаблон (Template) в Django и зачем он нужен?

Шаблон (template) в Django — это HTML-страница с динамическими элементами, которые могут меняться в зависимости от ситуации. Например, когда ты открываешь профиль на сайте соцсети, шаблон профиля один, а данные у всех разные (имя, фото, друзья и т.д.). Django-шаблоны помогают легко объединять статический HTML-код с переменными и логикой на Python.

Где размещать шаблоны?

Шаблоны обычно находятся в специальной папке templates, чтобы Django легко мог их найти:

myproject/
├── templates/
│   ├── base.html
│   ├── home.html
│   └── profile.html

Настройка папки шаблонов делается в settings.py:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],  # указываем папку шаблонов
        'APP_DIRS': True,
        'OPTIONS': {},
    },
]

Как передать данные из view-функции в шаблон?

Данные в шаблон передаются через контекст — это просто словарь Python, который передаётся в функцию render():

def profile(request):
    user_info = {'username': 'Анна', 'age': 25, 'city': 'Москва'}
    return render(request, 'profile.html', {'user': user_info})

Теперь эти данные можно использовать в шаблоне:

<h2>Профиль пользователя</h2>
<p>Имя: {{ user.username }}</p>
<p>Возраст: {{ user.age }}</p>
<p>Город: {{ user.city }}</p>

Основы работы с шаблонизатором Django

Шаблонизатор Django поддерживает два основных элемента:

1. Переменные

Переменные выводят данные из контекста:

{{ variable }}

Например, если в контексте есть user = {'name': 'Дмитрий'}:

<p>Привет, {{ user.name }}!</p> <!-- Выведет: Привет, Дмитрий! -->

2. Теги для логики

Теги управляют логикой и потоком вывода данных. Основные теги:

• {% if %} — условия:

{% if user.age >= 18 %}
    <p>Добро пожаловать, вы совершеннолетний!</p>
{% else %}
    <p>Извините, доступ ограничен.</p>
{% endif %}

• {% for %} — циклы для перебора списков:

<ul>
    {% for post in posts %}
        <li>{{ post.title }} ({{ post.date }})</li>
    {% empty %}
        <li>Постов пока нет.</li>
    {% endfor %}
</ul>

Здесь Django перебирает список постов и выводит каждый. Если список пуст, выводится сообщение «Постов пока нет».

Наследование шаблонов

Наследование позволяет избежать повторения кода и создать базовый шаблон для всех страниц сайта.

Пример базового шаблона base.html:

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Мой сайт{% endblock %}</title>
</head>
<body>
    <header>
        <h1>Мой сайт</h1>
    </header>

    <main>
        {% block content %}{% endblock %}
    </main>

    <footer>
        <p>© 2024 Мой сайт</p>
    </footer>
</body>
</html>

Создаём шаблон страницы, наследующий этот базовый:

{% extends 'base.html' %}

{% block title %}Главная страница{% endblock %}

{% block content %}
    <h2>Добро пожаловать!</h2>
    <p>Это главная страница сайта.</p>
{% endblock %}

Подключение статических файлов

Чтобы использовать статические файлы (CSS, JS, изображения), загрузи тег статических файлов:

{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">

Устный опрос (для закрепления):

• Что такое шаблон Django и зачем он нужен?
• Как передать данные из view-функции в шаблон?
• Как использовать условные операторы (if) в шаблоне?
• Для чего используется цикл (for) в шаблоне?
• Как работает наследование шаблонов?

Задание 9. Практическое задание (обязательно):

1. Создай базовый шаблон (base.html) с общей структурой (меню, футер, заголовок).
2. Создай шаблон страницы (home.html), который наследуется от базового.
3. Напиши view-функцию, которая передаёт в шаблон список объектов (например, список статей).

Пример view-функции:

def home(request):
    posts = [
        {'title': 'Что такое Django?', 'date': '2024-01-15'},
        {'title': 'Как создать сайт на Django?', 'date': '2024-01-20'},
    ]
    return render(request, 'home.html', {'posts': posts})

Пример шаблона home.html:

{% extends 'base.html' %}

{% block content %}
    <h2>Последние статьи:</h2>
    <ul>
        {% for post in posts %}
            <li>{{ post.title }} – опубликована {{ post.date }}</li>
        {% empty %}
            <li>Пока статей нет.</li>
        {% endfor %}
    </ul>
{% endblock %}

Это практическое задание позволит тебе самостоятельно понять, как работают шаблоны, наследование и динамическое отображение данных на сайте!

Административная панель Django (admin.py)

Что такое административная панель Django и зачем она нужна?

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

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

Админка особенно полезна:

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

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

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

Например, у тебя есть модель Book:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()

    def __str__(self):
        return self.title

Открой файл admin.py в папке приложения и добавь модель:

from django.contrib import admin
from .models import Book

admin.site.register(Book)

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

Как настроить админ-панель с помощью ModelAdmin?

Стандартного отображения обычно недостаточно, поэтому Django позволяет настраивать админку с помощью классов ModelAdmin. Это позволяет:

• выбрать, какие поля отображать в списке,
• добавить возможность поиска,
• настроить фильтры и сортировку.

Пример более тонкой настройки модели Book:

from django.contrib import admin
from .models import Book

class BookAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'published_date')  # поля для отображения
    search_fields = ('title', 'author')  # поля для поиска
    list_filter = ('published_date',)  # фильтр по дате публикации

admin.site.register(Book, BookAdmin)

Теперь в админке ты увидишь:

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

Доступ в админ-панель (создание суперпользователя)

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

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

python manage.py createsuperuser

Django попросит ввести имя пользователя, почту (можно пропустить) и пароль. Запомни их, потому что они понадобятся для входа.

Затем открой в браузере адрес:

http://127.0.0.1:8000/admin/

Введи логин и пароль суперпользователя и зайди в админ-панель.

Устный опрос (для закрепления):

• Для чего нужна админ-панель Django?
• Как зарегистрировать модель в админ-панели?
• Как создать суперпользователя?
• Какие настройки можно сделать в классе ModelAdmin?

Задание 10. Практическое задание (обязательно):

Давай закрепим навыки работы с админкой на практике:

1. Регистрация модели:
   • В приложении зарегистрируй модель (например, Book или Post) в файле admin.py.
2. Создание суперпользователя:
   • Выполни команду python manage.py createsuperuser и создай суперпользователя.
3. Настройка админки:
   • Создай класс ModelAdmin для своей модели и настрой:
     • какие поля будут отображаться (list_display),
     • по каким полям будет идти поиск (search_fields),
     • добавь хотя бы один фильтр (list_filter).
4. Проверка работы:
   • Открой админку по адресу /admin, убедись, что модель видна, и попробуй создать или изменить записи.

Пример настройки:

class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'created_at')
    search_fields = ('title', 'author')
    list_filter = ('created_at',)

admin.site.register(Post, PostAdmin)

Аутентификация и авторизация пользователей в Django

Что такое аутентификация и авторизация?

Давай сначала разберёмся с понятиями:

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

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

Простым языком: аутентификация отвечает за «Кто ты?», а авторизация за «Что тебе можно делать?».

Стандартная модель пользователя в Django (User)

В Django уже есть готовая модель пользователя (User). Она хранится в модуле:

from django.contrib.auth.models import User

Стандартная модель содержит поля:

• username (логин)
• password (пароль)
• email (почта)
• first_name (имя)
• last_name (фамилия)
• is_staff (доступ к админ-панели)
• is_superuser (суперпользователь, с полным доступом)

Суперпользователь (админ) — это специальный пользователь с правами на всё, включая доступ к админ-панели Django.

Как создавать пользователей в Django?

Через админ-панель:

Самый простой способ:

1. Зайди в админку /admin.
2. Открой раздел «Users» и нажми «Add user».

Через Django Shell:

Можно создавать и через код:

from django.contrib.auth.models import User

user = User.objects.create_user(username='ivan', email='ivan@example.com', password='securepassword123')
user.first_name = 'Иван'
user.save()

Теперь пользователь Иван создан и может заходить на сайт.

Права (Permissions) и группы (Groups)

• Права (Permissions) — это разрешения на определённые действия (например, «может добавлять статьи», «может удалять статьи»).
• Группы (Groups) — это наборы пользователей с одинаковыми правами. Удобно, чтобы не настраивать каждому пользователю права отдельно.

Создать группы и назначить права можно в админке:

1. Зайди в раздел «Groups».
2. Создай группу (например, «Редакторы»), добавь нужные права.
3. Добавь пользователей в группу через раздел «Users».

Регистрация и авторизация в Django

Django предоставляет готовые классы и формы для регистрации и авторизации пользователей:

• LoginView (для входа)
• LogoutView (для выхода)
• PasswordChangeView (смена пароля)

Пример реализации входа и выхода через готовые view:

# urls.py
from django.contrib.auth.views import LoginView, LogoutView

urlpatterns = [
    path('login/', LoginView.as_view(template_name='login.html'), name='login'),
    path('logout/', LogoutView.as_view(), name='logout'),
]

Ограничение доступа к страницам

Можно легко ограничивать доступ к страницам:

• Декоратор @login_required — страница доступна только авторизованным:

from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

• Проверка прав пользователя с помощью @permission_required:

from django.contrib.auth.decorators import permission_required

@permission_required('blog.add_post')
def create_post(request):
    return render(request, 'create_post.html')

Устный опрос (закрепление):

• Для чего нужна аутентификация?
• Чем отличаются права от групп пользователей?
• Как создать нового пользователя и назначить ему права?
• Как сделать страницу доступной только авторизованным пользователям?

Задание 11. Практическое задание (обязательно):

Создадим простую систему регистрации и авторизации:

Минимальный набор действий:

1. Создай URL и view-функции для входа и выхода пользователей:

from django.contrib.auth.views import LoginView, LogoutView

urlpatterns = [
    path('login/', LoginView.as_view(template_name='login.html'), name='login'),
    path('logout/', LogoutView.as_view(), name='logout'),
]

2. Сделай защищённую страницу, доступную только авторизованным пользователям:

@login_required
def secret_page(request):
    return render(request, 'secret.html')

3. Создай две группы (например, «Читатели» и «Редакторы») с разными правами через админ-панель.
4. Добавь пользователей в эти группы через админку и проверь доступ к защищённым страницам.

Это задание поможет тебе на практике разобраться с механизмом регистрации, авторизации и разграничения прав пользователей в Django!

Управление статическими файлами в Django

Что такое статические файлы в Django?

Статические файлы — это файлы, которые не меняются во время работы сайта. К ним относятся CSS-стили, JavaScript-скрипты, картинки, шрифты и другие ресурсы, которые не зависят от данных в базе данных. Проще говоря, статические файлы делают твой сайт красивым и интерактивным.

Как Django работает со статическими файлами?

В Django статические файлы принято хранить в специальной папке static. Типичная структура проекта выглядит так:

myproject/
├── static/
│   ├── css/
│   ├── js/
│   └── images/
├── templates/
├── manage.py
└── myproject/

Настройка работы со статическими файлами делается в файле settings.py:

• STATIC_URL — URL-адрес, по которому будет доступна статика:

STATIC_URL = '/static/'

• STATICFILES_DIRS — папки, в которых Django ищет статику в процессе разработки:

STATICFILES_DIRS = [BASE_DIR / 'static']

• STATIC_ROOT — папка, куда Django соберёт все статические файлы перед загрузкой на сервер (в продакшене):

STATIC_ROOT = BASE_DIR / 'staticfiles'

Как подключать статические файлы в шаблонах?

Для подключения статических файлов в шаблонах Django используется специальный тег {% load static %}:

Пример подключения CSS-файла:

{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">

Пример подключения изображения:

{% load static %}
<img src="{% static 'images/logo.png' %}" alt="Логотип сайта">

Что делает команда collectstatic?

Когда ты готовишь сайт к публикации (размещению на сервере), Django собирает все статические файлы в одну папку, указанную в настройке STATIC_ROOT. Делается это командой:

python manage.py collectstatic

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

Особенности работы с файлами на разработке и продакшене

Есть важное различие в работе с файлами в зависимости от того, разрабатываешь ли ты сайт или уже выкладываешь его на сервер:

• В режиме разработки (DEBUG = True) Django автоматически находит и показывает файлы из STATICFILES_DIRS. Тебе не нужно запускать collectstatic.
• В рабочем режиме (DEBUG = False) нужно обязательно использовать команду collectstatic, иначе статика не будет доступна.

Устный опрос (для закрепления):

• Что такое статические файлы в Django?
• Как добавить картинку или CSS-файл на HTML-страницу?
• Что делает команда collectstatic и когда её нужно использовать?
• В чём разница между настройками STATIC_ROOT и STATICFILES_DIRS?

Задание 12. Практическое задание (обязательно):

Закрепим навыки работы со статикой:

1. Создай в проекте папку static.
2. Добавь туда:
   • папку css с файлом style.css (с простыми стилями, например, меняющими цвет текста);
   • папку images с любым изображением.
3. Подключи эти файлы в шаблоне (base.html или другом):

{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<img src="{% static 'images/logo.png' %}" alt="Логотип">

4. Запусти сервер и убедись, что стили и изображения загружаются корректно.
5. Выполни команду:

python manage.py collectstatic

Убедись, что все файлы были успешно собраны в папке, указанной в STATIC_ROOT (staticfiles).

Развертывание Django-приложения

Что такое развертывание (деплой)?

Развертывание (или деплой) — это процесс переноса твоего веб-приложения с локального компьютера на удалённый сервер, чтобы оно было доступно всем пользователям через интернет. Если сравнить с жизнью, это похоже на переезд из своей квартиры в публичное место, где все могут увидеть твоё творчество.

Где размещать Django-приложение?

Есть несколько основных способов:

• Виртуальный сервер (VPS) — это отдельный сервер, полностью под твоим контролем (например, DigitalOcean).
• Облачные платформы — простые и удобные сервисы для размещения (например, Heroku, Render).

Новичкам обычно удобнее начать с Heroku или Render, потому что там меньше сложных настроек и быстрее получается результат.

Как подготовить Django-приложение к развертыванию?

Перед размещением приложения на сервер нужно правильно его настроить:

Файл settings.py:

• Отключи отладочный режим:

DEBUG = False

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

• Настрой допустимые адреса (например, твой домен):

ALLOWED_HOSTS = ['example.com', 'www.example.com']

• Настрой статические файлы:

STATIC_URL = '/static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'

Создай файл с зависимостями (requirements.txt):

pip freeze > requirements.txt

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

Подготовка базы данных

На этапе разработки Django обычно использует базу данных SQLite. Это удобно, но для серьёзного сайта лучше использовать PostgreSQL — она быстрее, безопаснее и стабильнее.

Для подключения PostgreSQL в settings.py сделай следующее:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Подготовка статических файлов

Перед запуском приложения нужно собрать все статические файлы (CSS, JS, картинки):

python manage.py collectstatic

Команда собирает файлы в папку, указанную в STATIC_ROOT.

Развертывание с помощью WSGI-сервера и веб-сервера

• WSGI (Web Server Gateway Interface) — это стандарт, позволяющий запускать Python-приложения на веб-серверах.

Популярные WSGI-серверы:

• Gunicorn (простой, надежный и удобный для новичков)
• uWSGI (более сложный, но мощный)
• Веб-серверы (например, Nginx) — принимают запросы от пользователей и передают их WSGI-серверу. Они также раздают статические файлы и эффективно обрабатывают большое количество запросов.

Схема работы:

Пользователь → Nginx → Gunicorn (WSGI-сервер) → Django-приложение
                        ↓
                  Статические файлы

Устный опрос (для закрепления):

• Что значит «развернуть приложение»?
• Зачем нужно отключать режим отладки перед публикацией?
• Что такое WSGI-сервер и зачем он нужен?
• Что делает команда collectstatic?

Задание 13. Практическое задание (обязательно):

Подготовь своё Django-приложение к размещению на сервере:

1. Отключи режим отладки:

DEBUG = False

2. Укажи адреса в ALLOWED_HOSTS:

ALLOWED_HOSTS = ['127.0.0.1', 'localhost']

3. Создай файл зависимостей:

pip freeze > requirements.txt

4. Собери статические файлы:

python manage.py collectstatic

5. Запусти приложение локально с помощью Gunicorn (для тренировки):

gunicorn myproject.wsgi

Проверь, что приложение запускается и работает корректно.

Кэширование и оптимизация производительности в Django

Что такое кэширование?

Кэширование — это способ ускорения работы сайта за счёт сохранения промежуточных результатов.

Представь, что каждый раз, когда ты хочешь сделать бутерброд, тебе нужно идти в магазин за хлебом и колбасой. Это долго и неудобно. Намного проще сразу купить всё необходимое и хранить в холодильнике. Точно так же и кэширование — оно хранит уже готовые данные, чтобы каждый раз не формировать их заново.

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

Типы кэширования в Django

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

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

Настройка кэша в Django

Django умеет работать с разными типами кэша:

• Локальный кэш (удобен для разработки).
• Файловый кэш (сохраняет данные в файлах).
• Memcached и Redis (более мощные решения для серьёзных проектов).

Настроить простой файловый кэш очень легко:

# settings.py

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': BASE_DIR / 'django_cache',
    }
}

Теперь кэш будет сохраняться в папке проекта в папке django_cache.

Как использовать кэширование страниц?

Самый простой способ ускорить страницу — использовать декоратор cache_page. Например, чтобы страница кэшировалась на 60 секунд:

from django.views.decorators.cache import cache_page

@cache_page(60)
def home(request):
    # какая-то долгая логика
    return render(request, 'home.html')

Теперь Django будет сохранять эту страницу и отдавать её из кэша следующие 60 секунд.

Базовая оптимизация производительности

Для анализа производительности Django-приложения существует удобный инструмент — Django Debug Toolbar. Он помогает увидеть:

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

Как установить и настроить Django Debug Toolbar?

Установи пакет:

pip install django-debug-toolbar

Добавь его в настройки проекта (settings.py):

INSTALLED_APPS = [
    # ...
    'debug_toolbar',
]

MIDDLEWARE = [
    'debug_toolbar.middleware.DebugToolbarMiddleware',
    # ...
]

INTERNAL_IPS = [
    '127.0.0.1',
]

И подключи в файл URL-маршрутов (urls.py):

from django.urls import path, include

urlpatterns = [
    path('__debug__/', include('debug_toolbar.urls')),
    # твои остальные маршруты
]

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

Устный опрос (закрепление):

• Что такое кэширование и для чего оно нужно?
• Какие типы кэширования поддерживает Django?
• Как включить кэш в Django-проекте?
• Что показывает Django Debug Toolbar?

Задание 14. Практическое задание (обязательно):

1. Установи и настрой Django Debug Toolbar:
   • Убедись, что панель появилась и показывает запросы к базе данных и скорость загрузки.
2. Настрой кэширование страницы:

Используй декоратор:

from django.views.decorators.cache import cache_page

@cache_page(120)  # кэшируем на 2 минуты
def slow_page(request):
    # реализуй рендеринг страницы с паузой
    return render(request, 'slow_page.html')

3. Проверь, как работает кэш:

• Сначала открой страницу без кэша, заметь время загрузки.
• Затем обнови страницу, чтобы увидеть разницу во времени загрузки (с кэшем должно быть значительно быстрее).

Тестирование Django-приложений (pytest, unittest, Django тестовый клиент)

Зачем нужно тестирование?

Тестирование — это процесс проверки твоего приложения на ошибки и проблемы. Представь, что ты построил мост: прежде чем запускать по нему машины, обязательно нужно проверить, насколько он крепкий и безопасный. То же самое и с твоим приложением. Тесты помогают убедиться, что приложение работает правильно и стабильно, даже когда ты что-то изменяешь в коде.

Основные причины писать тесты:

• Проверить, что всё работает как задумано.
• Быстро выявить ошибки, если ты меняешь код.
• Упростить процесс добавления новых функций.

Какие бывают виды тестирования?

В Django-приложениях используют:

• Unit-тесты (модульные) — проверяют отдельные функции или методы, например, создание объекта модели.
• Интеграционные тесты — проверяют, как несколько компонентов приложения работают вместе, например, view-функция с запросом в базу данных.

Инструменты тестирования Django

Основные инструменты для написания тестов:

• unittest — встроенный в Django и Python модуль. Подходит для простых и быстрых тестов.
• pytest — популярный, удобный и более гибкий инструмент, часто используется профессионалами.
• Django Test Client — встроенный в Django клиент, который может имитировать запросы (GET, POST и другие) к твоему приложению.

Как писать тесты в Django?

Тесты обычно хранятся в файле tests.py внутри приложения:

from django.test import TestCase
from .models import Post

class PostModelTest(TestCase):

    def test_post_creation(self):
        post = Post.objects.create(title="Тестовый пост", content="Привет, это тест")
        self.assertEqual(post.title, "Тестовый пост")
        self.assertTrue(isinstance(post, Post))

Здесь:

• Создаётся объект модели и проверяется, что он успешно создан и имеет правильные значения.

Использование Django Test Client:

class PostViewTest(TestCase):

    def test_home_page_status_code(self):
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)

    def test_post_list_page_content(self):
        response = self.client.get('/posts/')
        self.assertContains(response, "Список постов")

Здесь:

• Делается HTTP GET-запрос к приложению.
• Проверяется, что страница открывается корректно (код 200).
• Проверяется содержание страницы (наличие текста).

Как запустить тесты?

Запуск тестов простой:

python manage.py test

Django выполнит все тесты и покажет результат.

Устный опрос (закрепление):

• Зачем нужно писать тесты?
• Какие виды тестирования есть в Django?
• Какие инструменты для тестирования можно использовать в Django?
• Что такое Django Test Client и как его применять?

Задание 15. Практическое задание (обязательно):

Создай небольшое приложение с моделью и view-функцией и напиши тесты для них:

1. Создай простую модель, например:

# models.py
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)

2. Создай view-функцию, которая возвращает список книг:

# views.py
def book_list(request):
    books = Book.objects.all()
    return render(request, 'books.html', {'books': books})

3. Напиши тесты:

# tests.py
from django.test import TestCase
from .models import Book

class BookModelTest(TestCase):

    def test_book_creation(self):
        book = Book.objects.create(title="Война и мир", author="Л.Н. Толстой")
        self.assertEqual(book.title, "Война и мир")

class BookViewTest(TestCase):

    def test_book_list_status(self):
        response = self.client.get('/books/')
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Война и мир")

4. Запусти тесты:

python manage.py test

Убедись, что тесты успешно проходят.

Введение в Django Rest Framework (DRF)

Что такое Django Rest Framework (DRF)?

Django Rest Framework — это мощный и удобный инструмент, который позволяет легко создавать REST API на Django. А что такое REST API? Это интерфейс, через который твое приложение может обмениваться данными с другими программами, сайтами или мобильными приложениями. Например, мобильное приложение может брать данные из твоего Django-приложения через REST API.

REST API используется:

• в мобильных приложениях,
• в SPA (одностраничных приложениях на React, Vue или Angular),
• для интеграции нескольких сервисов друг с другом.

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

Установить DRF очень просто:

pip install djangorestframework

После установки добавь его в INSTALLED_APPS в settings.py:

INSTALLED_APPS = [
    # другие приложения
    'rest_framework',
]

Создание простого REST API с DRF

Создание API происходит в несколько шагов:

1. Создание модели

Допустим, у тебя есть модель заметок (Note):

# models.py
from django.db import models

class Note(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

2. Сериализаторы (Serializers)

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

# serializers.py
from rest_framework import serializers
from .models import Note

class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = '__all__'

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

3. ViewSets и Routers

ViewSets упрощают создание CRUD (создание, чтение, обновление, удаление) операций. Routers автоматически создают маршруты (URL).

# views.py
from rest_framework import viewsets
from .models import Note
from .serializers import NoteSerializer

class NoteViewSet(viewsets.ModelViewSet):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer

Настрой маршрутизацию:

# urls.py
from django.urls import path, include
from rest_framework import routers
from .views import NoteViewSet

router = routers.DefaultRouter()
router.register(r'notes', NoteViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

Теперь у тебя автоматически появились маршруты:

• GET /notes/ — список заметок
• POST /notes/ — создать заметку
• GET /notes/{id}/ — получить конкретную заметку
• PUT /notes/{id}/ — обновить заметку
• DELETE /notes/{id}/ — удалить заметку

Устный опрос (для закрепления):

• Что такое REST API и зачем он нужен?
• Для чего нужен Django Rest Framework?
• Что делает сериализатор в DRF?
• Чем отличаются обычные Django Views от DRF ViewSets?

Задание 16. Практическое задание (обязательно):

Создадим простое REST API для работы с заметками:

1. Установи DRF и подключи его (pip install djangorestframework).
2. Создай модель Note (или другую простую модель на выбор):

class Note(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

3. Создай сериализатор:

class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = '__all__'

4. Создай ViewSet и маршрутизатор (DefaultRouter()):

class NoteViewSet(viewsets.ModelViewSet):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer

5. Проверь API через браузер или Postman:

• Сделай GET-запрос на /notes/, чтобы увидеть список заметок.
• Сделай POST-запрос, чтобы создать новую заметку.

Это задание позволит тебе быстро и легко понять, как работает Django Rest Framework и для чего он нужен в современных проектах!

Django или WordPress. В чем разница и что выбрать?

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

1. Целевая аудитория: Django — это мощный фреймворк для разработки веб-приложений, который предоставляет инструменты для создания сложных и кастомизированных веб-сайтов. WordPress, с другой стороны, предназначен для создания блогов и небольших сайтов с минимальным вмешательством в код.
2. Архитектура: Django разработан как фреймворк с открытым исходным кодом для быстрой разработки сложных веб-приложений, включая CRM, ERP, социальные сети и др. Он предоставляет гибкость и контроль над всеми аспектами приложения. WordPress — это система управления контентом, специально предназначенная для управления содержимым сайта, такого как статьи, страницы, изображения и т.д.
3. Использование: Django позволяет разработчикам создавать собственные веб-приложения с уникальными функциональными возможностями и дизайном. WordPress в первую очередь предоставляет готовые темы и плагины для быстрой установки и запуска простых блогов или сайтов с базовыми возможностями управления содержимым.
4. Уровень сложности: Django может быть сложнее для новичков, так как он предоставляет больше гибкости и требует более глубокого понимания программирования и веб-разработки. WordPress, напротив, спроектирован так, чтобы быть более простым в использовании, даже для пользователей без опыта веб-разработки.

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

Пример реализации проекта на Django. Учет IT оборудования.

Шаг 1: Создание и настройка проекта

Создадим новый проект Django для учета IT-оборудования в компании. Этот пример поможет тебе научиться делать CRUD-операции (создание, чтение, изменение и удаление данных) в Django.

1. Создание нового Django-проекта

В командной строке перейди в папку, где будет твой проект, и выполни команду:

django-admin startproject inventory_project

Это создаст структуру проекта:

inventory_project/
├── inventory_project/
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
│   └── asgi.py
└── manage.py

2. Создание приложения

Теперь перейдём в папку проекта и создадим новое приложение, которое будет управлять учётом оборудования:

cd inventory_project
python manage.py startapp inventory

После этого твоя структура проекта будет выглядеть так:

inventory_project/
├── inventory/
│   ├── migrations/
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── views.py
│   ├── tests.py
│   └── models.py
├── inventory_project/
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

3. Регистрация приложения в проекте

Чтобы проект Django увидел твоё новое приложение, необходимо добавить его в файл settings.py:

# settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'inventory',  # добавляем своё приложение
]

После этого Django сможет взаимодействовать с приложением inventory.

Результаты шага 1

После выполнения этих действий у тебя должен быть:

• Новый проект Django (inventory_project).
• Создано и зарегистрировано приложение (inventory).
• Готовая структура для дальнейшей реализации CRUD-функционала.

Шаг 2: Создание и настройка моделей

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

Продумываем структуру моделей

Для нашего проекта понадобится три основные модели:

• Категория оборудования (Category) — будет описывать тип оборудования (например, ноутбуки, мониторы, принтеры и т.д.).
• Сотрудники (Employee) — кому принадлежит оборудование.
• Само оборудование (Equipment) — детали конкретного устройства.

Создание моделей в файле models.py

Открой файл models.py в приложении inventory и добавь туда следующий код:

from django.db import models

# Модель категорий оборудования
class Category(models.Model):
    name = models.CharField(max_length=50, unique=True)

    def __str__(self):
        return self.name


# Модель сотрудников
class Employee(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    department = models.CharField(max_length=100)

    def __str__(self):
        return f"{self.first_name} {self.last_name} ({self.department})"


# Модель оборудования
class Equipment(models.Model):
    STATUS_CHOICES = [
        ('active', 'Активно'),
        ('in_repair', 'На ремонте'),
        ('decommissioned', 'Списано'),
    ]

    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    serial_number = models.CharField(max_length=50, unique=True)
    employee = models.ForeignKey(Employee, on_delete=models.SET_NULL, null=True, blank=True)
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='active')
    purchase_date = models.DateField()

    def __str__(self):
        return f"{self.name} ({self.serial_number})"

Что значит этот код?

• Мы создали три модели:
  • Category – категории оборудования (например, ноутбук, монитор).
  • Employee – данные сотрудников, которые используют оборудование.
  • Equipment – конкретные устройства с названием, категорией и серийным номером.
• Поля типа ForeignKey связывают модели между собой. Например, у каждого оборудования есть своя категория и сотрудник.
• У поля serial_number стоит параметр unique=True, чтобы не было двух устройств с одинаковыми серийными номерами.
• on_delete=models.CASCADE – если удалится категория, удалится всё оборудование этой категории.

Выполнение миграций

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

python manage.py makemigrations
python manage.py migrate

Результаты шага 2

После этого шага у тебя есть:

• Четко описанные модели для сотрудников, категорий и оборудования.
• База данных настроена и готова для работы с твоими моделями.

Шаг 3: Регистрация моделей в административной панели Django

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

Регистрация моделей в файле admin.py

Чтобы модели были доступны в админ-панели, необходимо зарегистрировать их в файле admin.py внутри твоего приложения (inventory). Открой файл и добавь следующий код:

from django.contrib import admin
from .models import Category, Employee, Equipment

admin.site.register(Category)
admin.site.register(Employee)
admin.site.register(Equipment)

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

Для доступа к административной панели Django нужно создать суперпользователя. Выполни команду в терминале:

python manage.py createsuperuser

Django попросит ввести:

• Username (логин)
• Email (можно оставить пустым)
• Пароль

Запомни введённые данные — они понадобятся для входа в админ-панель.

Запуск сервера и вход в админ-панель

Теперь запускаем сервер командой:

python manage.py runserver

Открой браузер и перейди по адресу:

http://127.0.0.1:8000/admin/

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

Добавление тестовых данных

Теперь можешь добавлять тестовые данные прямо из административной панели:

1. Перейди в разделы Category, Employee и Equipment и добавь записи:
   • Добавь несколько категорий оборудования (например, «Ноутбук», «Монитор», «Принтер»).
   • Добавь несколько сотрудников.
   • Добавь несколько единиц оборудования, указав категории и сотрудников.

Это позволит быстро наполнить базу данных и проверить, как всё работает.

Результаты шага 3

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

• Полностью настроенная административная панель Django.
• Возможность добавлять и редактировать данные моделей через удобный интерфейс.
• Готовые тестовые данные для дальнейшей разработки приложения.

Теперь мы подошли к самому интересному этапу — созданию полноценного CRUD-приложения.

Шаг 4. Создание View-функций и форм для CRUD-приложения Django

На предыдущих шагах мы создали приложение и настроили модели для учёта IT-оборудования. Сейчас будем реализовывать возможность создавать, читать, редактировать и удалять записи (CRUD).

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

CRUD (Create, Read, Update, Delete) — это базовые операции работы с любой информацией в приложении:

• Create — создание новой записи.
• Read — просмотр уже существующих записей.
• Update — изменение информации.
• Delete — удаление данных.

На нашем примере (учёт IT-оборудования):

• Create — добавить новый ноутбук или монитор в базу.
• Read — посмотреть список оборудования или информацию по конкретному устройству.
• Update — изменить статус или сотрудника, отвечающего за устройство.
• Delete — удалить запись, если устройство списано.

1. Создание модельных форм (ModelForm)

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

Создадим файл forms.py внутри папки приложения equipment (там же, где models.py):

📌 equipment/forms.py

from django import forms
from .models import Equipment

class EquipmentForm(forms.ModelForm):
    class Meta:
        model = Equipment
        fields = ['name', 'category', 'status', 'purchase_date', 'responsible_person']
        # можешь перечислить здесь поля, которые нужны в форме

Простыми словами:
Здесь мы создаём форму, основанную на уже существующей модели Equipment. Django сам сгенерирует HTML-поля, соответствующие полям модели. Удобно, правда?

2. Создание View-функций для CRUD-операций

Далее нужно создать функции в файле views.py приложения, которые будут обрабатывать запросы от пользователя.

В приложении equipment открой файл views.py и напиши:

from django.shortcuts import render, get_object_or_404, redirect
from .models import Equipment
from .forms import EquipmentForm

# Список всего оборудования
def equipment_list(request):
    equipments = Equipment.objects.all()
    return render(request, 'equipment/equipment_list.html', {'equipments': equipments})

# Подробно о конкретном оборудовании
def equipment_detail(request, pk):
    equipment = get_object_or_404(Equipment, pk=pk)
    return render(request, 'equipment/equipment_detail.html', {'equipment': equipment})

# Создание нового оборудования
def equipment_create(request):
    if request.method == "POST":
        form = EquipmentForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('equipment_list')
    else:
        form = EquipmentForm()
    return render(request, 'equipment/equipment_form.html', {'form': form})

# Редактирование существующего оборудования
def equipment_update(request, pk):
    equipment = get_object_or_404(Equipment, pk=pk)
    if request.method == "POST":
        form = EquipmentForm(request.POST, instance=equipment)
        if form.is_valid():
            form.save()
            return redirect('equipment_detail', pk=equipment.pk)
    else:
        form = EquipmentForm(instance=equipment)
    return render(request, 'equipment/equipment_form.html', {'form': form})

# Удаление оборудования
def equipment_delete(request, pk):
    equipment = get_object_or_404(Equipment, pk=pk)
    if request.method == "POST":
        equipment.delete()
        return redirect('equipment_list')
    return render(request, 'equipment/equipment_confirm_delete.html', {'equipment': equipment})

Что здесь происходит, простыми словами:

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

3. Настройка URL-маршрутов

Создай файл urls.py в папке приложения (equipment/urls.py) и напиши:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.equipment_list, name='equipment_list'),
    path('equipment/<int:pk>/', views.equipment_detail, name='equipment_detail'),
    path('equipment/new/', views.equipment_create, name='equipment_create'),
    path('equipment/<int:pk>/edit/', views.equipment_update, name='equipment_update'),
    path('equipment/<int:pk>/delete/', views.equipment_delete, name='equipment_delete'),
]

И подключи этот файл в основной urls.py проекта:

# urls.py (проекта it_inventory)
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('equipment.urls')),
]

4. Создание шаблонов (templates)

Сейчас у нас есть view-функции и маршруты. Но для полноценного отображения и взаимодействия нам необходимы HTML-шаблоны. Разберём подробно, как их создать и как они работают.

Для удобства, создай папку templates/equipment в своём приложении:

it_inventory/
│
└── equipment/
     └── templates/
         └── equipment/
             - equipment_list.html
             - equipment_detail.html
             - equipment_form.html
             - equipment_confirm_delete.html

Важно! Убедись, что у тебя настроены шаблоны в settings.py:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],  # Проверь этот путь!
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.template.context_processors.csrf',
                'django.template.context_processors.static',
            ],
        },
    ]

1) Базовый шаблон (base.html)

Сначала создадим общий базовый шаблон, от которого будут наследоваться другие страницы.

📌 templates/base.html

<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <title>Учёт оборудования</title>
    {% load static %}
    <link rel="stylesheet" href="{% static 'css/style.css' %}">
</head>
<body>
    <header>
        <h1>Учёт IT-оборудования предприятия</h1>
        <nav>
            <a href="{% url 'equipment_list' %}">Главная страница</a>
            <a href="{% url 'admin:index' %}">Админка</a>
        </nav>
    </header>

    <main>
        {% block content %}
        <!-- Здесь будет контент страницы -->
        {% endblock %}
    </main>

    <footer>
        <p>© 2025 Учебный проект Django</p>
    </footer>
</body>
</html>

Здесь указано место, куда будет вставляться содержимое всех остальных страниц с помощью {% block content %}.

2) Список оборудования (equipment_list.html)

📌 templates/equipment/equipment_list.html

{% extends "base.html" %}

{% block content %}
<h2>Список оборудования</h2>

<a href="{% url 'equipment_create' %}">➕ Добавить новое оборудование</a>

<ul>
    {% for item in equipments %}
        <li>
            <a href="{% url 'equipment_detail' pk=item.pk %}">
                {{ item.name }} ({{ item.category.name }}) — Статус: {{ item.status }}
            </a>
        </li>
    {% empty %}
        <li>Пока нет ни одного оборудования.</li>
    {% endfor %}
</ul>
{% endblock %}

Здесь:

• используется цикл {% for %} для вывода списка оборудования.
• ссылка на детальную страницу с информацией о каждом оборудовании.
• блок {% empty %} показывается, если в БД нет записей.

3) Детали оборудования (equipment_detail.html)

📌 templates/equipment/equipment_detail.html

{% extends "base.html" %}

{% block content %}
<h2>{{ equipment.name }}</h2>

<ul>
    <li><strong>Категория:</strong> {{ equipment.category.name }}</li>
    <li><strong>Серийный номер:</strong> {{ equipment.serial_number }}</li>
    <li><strong>Статус:</strong> {{ equipment.status }}</li>
    <li><strong>Дата покупки:</strong> {{ equipment.purchase_date }}</li>
    <li><strong>Сотрудник:</strong> {{ equipment.employee.full_name }}</li>
</ul>

<a href="{% url 'equipment_update' pk=equipment.pk %}">Редактировать</a> | 
<a href="{% url 'equipment_confirm_delete' pk=equipment.pk %}">Удалить</a> | 
<a href="{% url 'equipment_list' %}">Вернуться к списку</a>
{% endblock %}

Здесь детально выводится информация о конкретном оборудовании и ссылки на редактирование и удаление.

3) Форма для создания и редактирования оборудования (equipment_form.html)

📌 templates/equipment/equipment_form.html

{% extends "base.html" %}

{% block content %}
<h2>{% if form.instance.pk %}Редактировать{% else %}Добавить{% endif %} оборудование</h2>

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Сохранить</button>
</form>

<a href="{% url 'equipment_list' %}">Отменить и вернуться назад</a>
{% endblock %}

Обрати внимание:

• {% csrf_token %} — защита от атак через формы.
• {{ form.as_p }} автоматически создаёт HTML-поля на основе формы.

4) Подтверждение удаления (equipment_confirm_delete.html)

📌 templates/equipment/equipment_confirm_delete.html

{% extends "base.html" %}

{% block content %}
<h2>Подтверждение удаления</h2>

<p>Вы точно хотите удалить оборудование «{{ equipment.name }}» ({{ equipment.serial_number }})?</p>

<form method="post">
    {% csrf_token %}
    <button type="submit">Удалить</button>
    <a href="{% url 'equipment_detail' pk=equipment.pk %}">Отмена</a>
</form>
{% endblock %}

Проверка работы приложения:

1. Запусти сервер командой:

python manage.py runserver

2. Открой браузер и перейди по адресу:

http://127.0.0.1:8000/

Отлично! Давай подробно и доступно реализуем Шаг 4: URL-маршрутизацию для нашего CRUD-приложения по учёту IT-оборудования.

На этом этапе мы свяжем URL-адреса с нашими view-функциями, чтобы Django понимал, какое действие пользователь хочет выполнить, переходя по определённому адресу.

⚙️ Шаг 4. Настройка URL-маршрутизации

📌 Шаг 4.1: Создание и настройка файла urls.py в приложении

Создадим файл маршрутов URL (urls.py) внутри приложения equipment, если он ещё не создан.

Итак, структура выглядит так:

it_inventory/
│
├── equipment/
│   ├── migrations/
│   ├── templates/
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── views.py
│   ├── urls.py <-- создаём сейчас!
│   └── tests.py
│
├── it_inventory/
│   ├── settings.py
│   ├── urls.py
│   ├── wsgi.py
│   └── asgi.py
│
└── manage.py

🔹 Настройка файла equipment/urls.py

Добавим в него маршруты для всех CRUD-операций:

from django.urls import path
from . import views

urlpatterns = [
    # Список всего оборудования
    path('', views.equipment_list, name='equipment_list'),

    # Добавление нового оборудования
    path('equipment/new/', views.equipment_create, name='equipment_create'),

    # Детальный просмотр оборудования
    path('equipment/<int:pk>/', views.equipment_detail, name='equipment_detail'),

    # Редактирование существующего оборудования
    path('equipment/<int:pk>/edit/', views.equipment_update, name='equipment_update'),

    # Удаление оборудования
    path('equipment/<int:pk>/delete/', views.equipment_delete, name='equipment_delete'),
]

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

• Пустой путь ('') — это главная страница со списком всего оборудования.
• URL вида equipment/5/ показывает детальную страницу оборудования с id (pk = primary key) равным 5.
• edit и delete — это отдельные URL-ы, позволяющие редактировать и удалять конкретные записи.

Примеры работы таких URL-ов:

• /equipment/ → список всего оборудования.
• /equipment/new/ → создание нового оборудования.
• /equipment/3/ → детальная информация про оборудование с ID 3.
• /equipment/3/edit/ → редактировать оборудование с номером 3.
• /equipment/3/delete/ → удалить оборудование с номером 3.

🔹 Подключение маршрутов приложения к общему проекту

Теперь подключим файл маршрутов нашего приложения к главному конфигу проекта.

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

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),

    # Подключаем маршруты приложения equipment
    path('', include('equipment.urls')),
]

Теперь Django будет знать, что все запросы, пришедшие на адрес сайта (http://127.0.0.1:8000/), нужно передавать на обработку в наше приложение.

🛠 Проверка настроенных маршрутов

Запусти сервер, если он ещё не запущен:

python manage.py runserver

Теперь проверь в браузере:

• Главная страница со списком оборудования:

http://127.0.0.1:8000/

• Создание нового оборудования:

http://127.0.0.1:8000/equipment/new/

• Страница оборудования (например, для оборудования с ID=1):

http://127.0.0.1:8000/equipment/1/

• Страница редактирования:

http://127.0.0.1:8000/equipment/1/edit/

• Удаление записи:

http://127.0.0.1:8000/equipment/1/delete/

Таким образом, мы получили полноценную рабочую маршрутизацию для CRUD-приложения по учёту оборудования!

🎯 Чему мы научились:

✅ Создавать маршруты с параметрами.
✅ Связывать URL-ы с view-функциями.
✅ Включать URL-файл приложения в общий конфиг Django-проекта.

Индивидуальное и групповое обучение «Python Junior»
Если вы хотите научиться программировать на Python, могу помочь. Запишитесь на мой курс «Python Junior» и начните свой путь в мир ИТ уже сегодня!

Контакты
Для получения дополнительной информации и записи на курсы свяжитесь со мной:

Телеграм: https://t.me/Vvkomlev
Email: victor.komlev@mail.ru

Объясняю сложное простыми словами. Даже если вы никогда не работали с ИТ и далеки от программирования, теперь у вас точно все получится! Проверено десятками примеров моих учеников.

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

Практическая направленность. 80%: практики, 20% теории. У меня множество авторских заданий, которые фокусируются на практике. Вы не просто изучаете теорию, а сразу применяете знания в реальных проектах и задачах.

Разнообразие учебных материалов: Теория представлена в виде текстовых уроков с примерами и видео, что делает обучение максимально эффективным и удобным.

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