CRUD — одна из базовых вещей в веб-разработке. Практически любой сайт или сервис работает именно вокруг этих операций: создание данных, просмотр, изменение и удаление. Блог публикует статьи, интернет-магазин добавляет товары, CRM хранит клиентов, админ-панель редактирует записи — всё это построено на CRUD-логике.
В Django эти операции реализуются особенно удобно благодаря встроенному ORM, формам и системе шаблонов. Фреймворк берёт на себя большую часть рутинной работы: взаимодействие с базой данных, валидацию форм и обработку запросов. Именно поэтому Django часто используют для быстрого создания внутренних сервисов, админок, MVP и полноценных веб-приложений.
Чтобы понять, как работает CRUD в Django, проще всего разобрать небольшой практический пример. Ниже будет простое приложение со списком заметок, где можно создавать, редактировать и удалять записи.
Что такое CRUD в Django
CRUD расшифровывается как:
- Create — создание записи.
- Read — получение и отображение данных.
- Update — редактирование существующей записи.
- Delete — удаление записи.
Практически любое приложение использует эти четыре действия. Django реализует их через модели, формы, views и шаблоны.
Основная логика выглядит так:
- Пользователь отправляет запрос.
- View обрабатывает действие.
- Django ORM работает с базой данных.
- Шаблон отображает результат.
- Пользователь получает обновлённую страницу.
Именно такая структура делает Django удобным для создания CRUD-приложений.
Создание проекта и приложения
Сначала нужно создать проект и приложение.
django-admin startproject myproject cd myproject python manage.py startapp notes
После этого приложение нужно подключить в settings.py.
INSTALLED_APPS = [
...
'notes',
]
Теперь Django будет видеть новое приложение и подключать его модели и маршруты.
Создание модели для заметок
Любой CRUD начинается с модели. Именно модель определяет структуру данных, которые будут храниться в базе.
Создадим простую модель заметки в models.py.
from django.db import models
class Note(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
def __str__(self):
return self.title
Здесь всё максимально просто:
- title — заголовок заметки.
- content — основной текст.
- __str__ — удобное отображение объекта в админке.
После создания модели нужно выполнить миграции.
python manage.py makemigrations python manage.py migrate
Теперь таблица появится в базе данных.
Создание формы для работы с данными
В Django формы обычно создают через ModelForm. Такой подход автоматически связывает форму с моделью и избавляет от лишнего кода.
Создадим файл forms.py.
from django import forms
from .models import Note
class NoteForm(forms.ModelForm):
class Meta:
model = Note
fields = ['title', 'content']
Теперь Django сам создаст HTML-форму на основе модели.
Как работает создание записи
Для создания новой заметки понадобится view.
В views.py добавим функцию:
from django.shortcuts import render, redirect
from .forms import NoteForm
def create_note(request):
if request.method == 'POST':
form = NoteForm(request.POST)
if form.is_valid():
form.save()
return redirect('note_list')
else:
form = NoteForm()
return render(request, 'create_note.html', {'form': form})
Логика здесь очень простая:
| Что происходит | Для чего нужно |
|---|---|
| Проверка POST-запроса | Определяет отправку формы |
| NoteForm(request.POST) | Получает данные пользователя |
| form.is_valid() | Проверяет корректность данных |
| form.save() | Сохраняет запись в базе |
| redirect() | Перенаправляет после сохранения |
Именно через такую схему обычно работают Create-операции в Django.
После этого создаётся шаблон create_note.html.
<h1>Создать заметку</h1>
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Сохранить</button>
</form>
Тег {% csrf_token %} обязателен для защиты формы от CSRF-атак.
Отображение списка записей
Теперь нужно показать все заметки.
Добавим view:
from .models import Note
def note_list(request):
notes = Note.objects.all()
return render(request, 'note_list.html', {
'notes': notes
})
Шаблон note_list.html:
<h1>Все заметки</h1>
{% for note in notes %}
<h3>{{ note.title }}</h3>
<p>{{ note.content }}</p>
<a href="{% url 'update_note' note.id %}">
Редактировать
</a>
<a href="{% url 'delete_note' note.id %}">
Удалить
</a>
<hr>
{% endfor %}
Так реализуется Read-операция — получение и вывод данных из базы.
Как работает редактирование записи
Update в Django почти полностью повторяет создание записи. Главное отличие — форма получает существующий объект через instance.
Добавим view:
from django.shortcuts import get_object_or_404
def update_note(request, id):
note = get_object_or_404(Note, id=id)
if request.method == 'POST':
form = NoteForm(request.POST, instance=note)
if form.is_valid():
form.save()
return redirect('note_list')
else:
form = NoteForm(instance=note)
return render(request, 'update_note.html', {
'form': form
})
Здесь Django сначала получает объект из базы, а затем подставляет его данные в форму.
Шаблон почти не отличается от создания:
<h1>Редактировать заметку</h1>
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Обновить</button>
</form>
Такой подход считается стандартным для Update-операций в Django.
Как работает удаление записи
Delete — самая простая часть CRUD.
Добавим view:
def delete_note(request, id):
note = get_object_or_404(Note, id=id)
if request.method == 'POST':
note.delete()
return redirect('note_list')
return render(request, 'delete_note.html', {
'note': note
})
Шаблон подтверждения удаления:
<h2>Удалить заметку?</h2>
<p>{{ note.title }}</p>
<form method="post">
{% csrf_token %}
<button type="submit">
Удалить
</button>
</form>
Подтверждение удаления считается хорошей практикой, потому что защищает от случайного удаления данных.
Подключение маршрутов
Теперь нужно связать views с URL.
В urls.py приложения:
from django.urls import path
from . import views
urlpatterns = [
path('', views.note_list, name='note_list'),
path('create/', views.create_note, name='create_note'),
path('update/<int:id>/', views.update_note, name='update_note'),
path('delete/<int:id>/', views.delete_note, name='delete_note'),
]
После этого маршруты подключаются в основном urls.py.
from django.urls import include, path
urlpatterns = [
path('', include('notes.urls')),
]
Теперь CRUD полностью работает.
Почему Django удобно использовать для CRUD
Главное преимущество Django — количество готовых инструментов. Фреймворк уже содержит ORM, формы, систему маршрутов, шаблоны и встроенную админку. Благодаря этому CRUD-приложение можно собрать очень быстро.
Особенно удобно, что Django автоматически:
- Генерирует SQL-запросы.
- Валидирует данные.
- Работает с формами.
- Защищает от CSRF-атак.
- Управляет миграциями.
- Упрощает работу с базой данных.
Именно поэтому Django часто выбирают для внутренних сервисов, панелей управления, CRM-систем и MVP-проектов.
Когда лучше использовать class-based views
В примере выше использовались function-based views, потому что они проще для понимания новичкам. Но Django также поддерживает class-based views, где CRUD можно реализовать ещё быстрее.
Например:
from django.views.generic import ListView
from .models import Note
class NoteListView(ListView):
model = Note
template_name = 'note_list.html'
Такой подход уменьшает количество кода, особенно в крупных проектах.
Однако function-based views лучше подходят для обучения, потому что помогают понять внутреннюю логику работы Django.
Какие ошибки чаще всего делают новички
Одна из самых распространённых проблем — попытка писать слишком сложный CRUD сразу. Многие начинают добавлять авторизацию, AJAX, API, Bootstrap и сложную бизнес-логику ещё до понимания базовой структуры.
Сначала важно понять саму механику:
- Как работают модели.
- Как Django сохраняет данные.
- Как форма передаёт информацию.
- Как view обрабатывает запрос.
- Как шаблон отображает результат.
Когда базовый CRUD становится понятным, всё остальное добавляется значительно проще.
Вторая частая ошибка — отсутствие разделения логики. Иногда новички пытаются писать SQL вручную или смешивают HTML и Python-код в одном месте. Django как раз создан для того, чтобы разделять модели, views и шаблоны.
Почему CRUD остаётся основой Django-разработки
Практически любое веб-приложение строится вокруг CRUD-операций. Даже сложные сервисы в основе всё равно создают, читают, обновляют и удаляют данные.
Поэтому понимание CRUD в Django — это фундамент для дальнейшей разработки. После него становится намного проще изучать:
- Django REST Framework.
- Авторизацию пользователей.
- Админ-панели.
- API.
- AJAX и JavaScript.
- Сложные ORM-запросы.
- Асинхронную обработку данных.
Именно через простые CRUD-приложения большинство разработчиков начинают понимать, как устроена логика полноценного веб-сервиса.