Формы и валидация в Django: полное руководство для разработчиков

# forms.py
from django import forms

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

# views.py
from django.shortcuts import render
from .forms import ContactForm

def contact_view(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
# Обработка данных формы
name = form.cleaned_data['name']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
# Дальнейшая логика (например, отправка email)
return render(request, 'success.html')
else:
form = ContactForm()

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

# models.py
from django.db import models

class Article(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
pub_date = models.DateField(auto_now_add=True)
is_published = models.BooleanField(default=False)
category = models.ForeignKey('Category', on_delete=models.CASCADE)

def __str__(self):
return self.title

# forms.py
from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'content', 'is_published', 'category']
# Альтернатива: fields = '__all__' (все поля) или exclude = ['pub_date']

class ArticleForm(forms.ModelForm):
title = forms.CharField(
max_length=200,
widget=forms.TextInput(attrs={'class': 'form-control', 'placeholder': 'Введите заголовок'})
)
content = forms.CharField(
widget=forms.Textarea(attrs={'rows': 5, 'class': 'form-control'})
)

class Meta:
model = Article
fields = ['title', 'content', 'is_published', 'category']
labels = {
'title': 'Заголовок статьи',
'is_published': 'Опубликовать сразу'
}
help_texts = {
'content': 'Основной текст статьи'
}

# views.py
from django.shortcuts import render, redirect
from .forms import ArticleForm
from .models import Article

def create_article(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
# Вариант 1: сохранение напрямую
article = form.save()

# Вариант 2: сохранение с дополнительной обработкой
# article = form.save(commit=False)
# article.author = request.user
# article.save()

return redirect('article_detail', article.id)
else:
form = ArticleForm()

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

def edit_article(request, article_id):
article = Article.objects.get(id=article_id)

if request.method == 'POST':
# Передаем instance для заполнения формы данными существующей статьи
form = ArticleForm(request.POST, instance=article)
if form.is_valid():
form.save()
return redirect('article_detail', article_id)
else:
form = ArticleForm(instance=article)

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

from django import forms
from django.core.validators import MinLengthValidator, RegexValidator

class RegistrationForm(forms.Form):
username = forms.CharField(
max_length=30,
validators=[
MinLengthValidator(4, 'Имя пользователя должно содержать минимум 4 символа'),
RegexValidator(
r'^[a-zA-Z0-9_]+$',
'Имя пользователя может содержать только буквы, цифры и знак подчеркивания'
)
]
)
password = forms.CharField(
widget=forms.PasswordInput,
validators=[
MinLengthValidator(8, 'Пароль должен содержать минимум 8 символов')
]
)
confirm_password = forms.CharField(widget=forms.PasswordInput)
email = forms.EmailField()

# Валидация отдельного поля
def clean_username(self):
username = self.cleaned_data.get('username')
if User.objects.filter(username=username).exists():
raise forms.ValidationError('Это имя пользователя уже занято')
return username

# Валидация на уровне формы (для связанных полей)
def clean(self):
cleaned_data = super().clean()
password = cleaned_data.get('password')
confirm_password = cleaned_data.get('confirm_password')

if password and confirm_password and password != confirm_password:
self.add_error('confirm_password', 'Пароли не совпадают')

return cleaned_data

from django.core.exceptions import ValidationError

def validate_even(value):
if value % 2 != 0:
raise ValidationError('%(value)s не является четным числом', params={'value': value})

class EvenNumberForm(forms.Form):
number = forms.IntegerField(validators=[validate_even])

# models.py
class Product(models.Model):
name = models.CharField(max_length=100)
price = models.DecimalField(max_digits=10, decimal_places=2)
stock = models.PositiveIntegerField()

def clean(self):
if self.price < 0.01:
raise ValidationError('Цена должна быть больше нуля')
if self.price > 1000 and self.stock > 10:
raise ValidationError('Для дорогих товаров (>1000) запас не может превышать 10 единиц')

# forms.py
class ProductForm(forms.ModelForm):
class Meta:
model = Product
fields = '__all__'

# Дополнительная валидация формы
def clean_name(self):
name = self.cleaned_data.get('name')
if len(name) < 5:
raise forms.ValidationError('Название товара должно содержать минимум 5 символов')
return name

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

<form method="post">
{% csrf_token %}
<div class="form-group">
<label for="{{ form.title.id_for_label }}">{{ form.title.label }}</label>
{{ form.title }}
{% if form.title.errors %}
<div class="error">
{% for error in form.title.errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}
{% if form.title.help_text %}
<small class="help-text">{{ form.title.help_text }}</small>
{% endif %}
</div>

<div class="form-group">
<label for="{{ form.content.id_for_label }}">{{ form.content.label }}</label>
{{ form.content }}
{% if form.content.errors %}
<div class="error">
{% for error in form.content.errors %}
{{ error }}
{% endfor %}
</div>
{% endif %}
</div>

<div class="form-check">
{{ form.is_published }}
<label for="{{ form.is_published.id_for_label }}">
{{ form.is_published.label }}
</label>
</div>

<button type="submit" class="btn btn-primary">Сохранить</button>
</form>

# forms.py
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'content', 'category', 'tags']
widgets = {
'title': forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Введите заголовок'
}),
'content': forms.Textarea(attrs={
'class': 'form-control',
'rows': 5,
'data-markdown-editor': 'true'
}),
'category': forms.Select(attrs={
'class': 'form-select'
}),
'tags': forms.SelectMultiple(attrs={
'class': 'form-select'
})
}

<form method="post">
{% csrf_token %}

{% if form.non_field_errors %}
<div class="alert alert-danger">
{% for error in form.non_field_errors %}
<p>{{ error }}</p>
{% endfor %}
</div>
{% endif %}

{% for field in form %}
<div class="form-group {% if field.errors %}has-error{% endif %}">
<label for="{{ field.id_for_label }}">{{ field.label }}</label>
{{ field }}
{% if field.errors %}
<div class="error-feedback">
{% for error in field.errors %}
<span>{{ error }}</span>
{% endfor %}
</div>
{% endif %}
{% if field.help_text %}
<small class="form-text text-muted">{{ field.help_text }}</small>
{% endif %}
</div>
{% endfor %}

<button type="submit">Отправить</button>
</form>

# forms.py
class ProfileForm(forms.ModelForm):
class Meta:
model = Profile
fields = ['name', 'bio', 'avatar']

# views.py
def edit_profile(request):
if request.method == 'POST':
form = ProfileForm(request.POST, request.FILES, instance=request.user.profile)
if form.is_valid():
form.save()
return redirect('profile')
else:
form = ProfileForm(instance=request.user.profile)
return render(request, 'edit_profile.html', {'form': form})

# template.html
<form method="post" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Сохранить</button>
</form>

# forms.py
class UserForm(forms.ModelForm):
class Meta:
model = User
fields = ['username', 'email', 'first_name', 'last_name']

class ProfileForm(forms.ModelForm):
class Meta:
model = Profile
fields = ['bio', 'location', 'birth_date', 'avatar']

# views.py
def edit_user_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST, instance=request.user)
profile_form = ProfileForm(
request.POST, 
request.FILES, 
instance=request.user.profile
)

if user_form.is_valid() and profile_form.is_valid():
user_form.save()
profile_form.save()
return redirect('profile')
else:
user_form = UserForm(instance=request.user)
profile_form = ProfileForm(instance=request.user.profile)

context = {
'user_form': user_form,
'profile_form': profile_form
}
return render(request, 'edit_profile.html', context)

<form method="post" enctype="multipart/form-data">
{% csrf_token %}

<h3>Основная информация</h3>
{{ user_form.as_p }}

<h3>Профиль</h3>
{{ profile_form.as_p }}

<button type="submit">Сохранить изменения</button>
</form>

# views.py
from django.forms import modelformset_factory, inlineformset_factory

def manage_products(request):
# Создаем фабрику формсетов – набор форм одного типа
ProductFormSet = modelformset_factory(
Product, 
fields=('name', 'price', 'stock'),
extra=2, # Сколько пустых форм добавить
can_delete=True # Разрешить удаление объектов
)

if request.method == 'POST':
formset = ProductFormSet(request.POST)
if formset.is_valid():
formset.save()
return redirect('product_list')
else:
formset = ProductFormSet(queryset=Product.objects.filter(category=1))

return render(request, 'manage_products.html', {'formset': formset})

def edit_article(request, article_id):
article = Article.objects.get(id=article_id)

# Создаем встроенный формсет для связанных объектов
ImageFormSet = inlineformset_factory(
Article, # Родительская модель
Image, # Дочерняя модель
fields=('image', 'caption'),
extra=3,
can_delete=True
)

if request.method == 'POST':
form = ArticleForm(request.POST, instance=article)
formset = ImageFormSet(request.POST, request.FILES, instance=article)

if form.is_valid() and formset.is_valid():
form.save()
formset.save()
return redirect('article_detail', article.id)
else:
form = ArticleForm(instance=article)
formset = ImageFormSet(instance=article)

context = {
'form': form,
'formset': formset
}
return render(request, 'edit_article.html', context)

# views.py
from django.http import JsonResponse

def validate_username(request):
username = request.GET.get('username', None)
data = {
'is_taken': User.objects.filter(username__iexact=username).exists()
}
return JsonResponse(data)

def register_view(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = RegistrationForm()
return render(request, 'register.html', {'form': form})

// В шаблоне register.html
<script>
$(document).ready(function() {
$('#id_username').on('change', function() {
const username = $(this).val();

$.ajax({
url: '{% url "validate_username" %}',
data: {
'username': username
},
dataType: 'json',
success: function(data) {
if (data.is_taken) {
$('#id_username').addClass('is-invalid');
$('#username-feedback').text('Это имя пользователя уже занято.');
} else {
$('#id_username').removeClass('is-invalid').addClass('is-valid');
$('#username-feedback').text('');
}
}
});
});
});
</script>

# serializers.py
from rest_framework import serializers

class RegistrationSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ['username', 'email', 'password']
extra_kwargs = {
'password': {'write_only': True}
}

def validate_username(self, value):
if User.objects.filter(username=value).exists():
raise serializers.ValidationError("Имя пользователя уже занято.")
return value

# views.py
from rest_framework.decorators import api_view
from rest_framework.response import Response

@api_view(['POST'])
def validate_registration(request):
serializer = RegistrationSerializer(data=request.data)
if serializer.is_valid():
return Response({'valid': True})
return Response({'valid': False, 'errors': serializer.errors})