Django Forms and ModelForms: Form Handling, Validation, and Database Integration

Introduction

Django Forms provide a structured way to collect, validate, and process user input in web applications. They help developers build forms for tasks such as user registration, contact inquiries, student enrollment, and data submission.

Django provides two important approaches to form handling: Form and ModelForm. The Form class allows developers to define custom form fields, while ModelForm automatically generates form fields based on an existing Django model.

In this module, you will learn how to create forms, validate user input, display validation errors, process submitted data, and save information to a database using Django's built-in form features.

What You Will Learn

1. Understanding Django Forms and ModelForms.

2. Creating forms using the forms.Form class.

3. Creating database forms using forms.ModelForm.

4. Understanding GET and POST requests.

5. Displaying forms in Django templates.

6. Validating user input using built-in validators.

7. Implementing custom form validation.

8. Displaying validation errors in templates.

9. Saving form data to the database.

10. Using save() and commit=False.

11. Editing existing database records with ModelForms.

12. Applying Bootstrap styling to Django forms.

13. Understanding CSRF protection.

14. Handling invalid submissions and successful form submissions.

1. Understanding Django Forms

A Django Form is a Python class that defines the fields and validation rules for user input.

Django Forms help developers:

• Collect data from users.

• Validate submitted information.

• Display useful error messages.

• Convert valid input into appropriate Python data types.

• Reduce repetitive form-processing code.

• Improve consistency in form handling.

For example, a student registration form may contain fields such as Name, Email, Phone, Course, and City.

2. Creating a Django Form

First, create a file named forms.py inside your Django application folder.

For example, if your application is named students, the structure will look like this:

students/
    __init__.py
    admin.py
    apps.py
    forms.py
    models.py
    views.py

Add the following code to students/forms.py:

from django import forms


class StudentForm(forms.Form):
    name = forms.CharField(
        max_length=100,
        label="Full Name"
    )

    email = forms.EmailField(
        label="Email Address"
    )

    phone = forms.CharField(
        max_length=15,
        label="Phone Number"
    )

    course = forms.CharField(
        max_length=100,
        label="Course"
    )

    city = forms.CharField(
        max_length=100,
        label="City"
    )

Explanation:

• forms.Form creates a custom Django form.

• CharField accepts text input.

• EmailField validates the basic email format.

• max_length limits the accepted text length.

• label defines the field's displayed label.

At this stage, the form defines and validates input fields, but it does not automatically save records to a database.

3. Creating a Model for Student Data

To store student information in the database, define a model in students/models.py.

from django.db import models


class Student(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    phone = models.CharField(max_length=15)
    course = models.CharField(max_length=100)
    city = models.CharField(max_length=100)

    def __str__(self):
        return self.name

Explanation:

• models.Model defines a database-backed model.

• Each model field represents a database field.

• __str__() returns a readable representation of a student.

After creating or modifying the model, run the following commands:

python manage.py makemigrations
python manage.py migrate

These commands create and apply database migrations for the model.

Important: If your project already contains a Student model, use the existing model instead of creating a duplicate. Adapt the form fields to match your actual model.

4. Understanding ModelForm

A ModelForm creates form fields based on a Django model.

It reduces the need to define every form field manually and provides a convenient way to create or update database records.

Create or update students/forms.py:

from django import forms
from .models import Student


class StudentModelForm(forms.ModelForm):

    class Meta:
        model = Student

        fields = [
            'name',
            'email',
            'phone',
            'course',
            'city',
        ]

Explanation:

• forms.ModelForm connects a form to a model.

• model = Student specifies the model to use.

• fields defines which model fields appear in the form.

• Django derives suitable form fields and validation rules from the model fields.

Using an explicit field list helps prevent unintended model fields from being exposed through the form.

5. Displaying a Form in a Django View

Create a view in students/views.py:

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


def student_create(request):

    if request.method == 'POST':
        form = StudentModelForm(request.POST)

        if form.is_valid():
            form.save()
            return redirect('student_list')

    else:
        form = StudentModelForm()

    return render(
        request,
        'students/student_form.html',
        {'form': form}
    )

How the process works:

1. When the user opens the page, Django creates an empty form.

2. When the user submits the form, Django receives the POST data.

3. form.is_valid() checks whether the submitted information passes validation.

4. If the form is valid, form.save() creates the student record.

5. Django redirects the user to the student listing page.

6. If validation fails, the form is rendered again with its error messages.

This pattern is commonly used for registration and data-entry pages.

6. Creating the Form Template

Create templates/students/student_form.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Student Registration</title>
</head>
<body>

    <h2>Student Registration Form</h2>

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

        {{ form.as_p }}

        <button type="submit">Save Student</button>
    </form>

</body>
</html>

Important concepts:

• method="post" submits form data through a POST request.

• {% csrf_token %} provides Django's CSRF protection token for the form.

• {{ form.as_p }} renders the form fields inside paragraph elements.

• The submit button sends the form data to the server.

For production applications, configure templates, styling, and form error presentation according to the project's design requirements.

7. Configuring the URL

Open students/urls.py. If the file does not exist, create it.

from django.urls import path
from . import views

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

Then include the application URLs in the project's main urls.py:

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

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

If the project already has URL patterns for student management, integrate the new route into the existing configuration rather than duplicating routes.

The registration page will be available at:

http://127.0.0.1:8000/students/add/

8. Understanding Form Validation

Form validation ensures that submitted data meets the expected requirements before it is processed or saved.

Django automatically performs several types of validation, including required-field checks, data-type conversion, maximum-length checks, and email-format validation.

For example:

from django import forms


class ContactForm(forms.Form):

    name = forms.CharField(max_length=100)

    email = forms.EmailField()

    message = forms.CharField(
        widget=forms.Textarea,
        min_length=10
    )

In this example:

• name must satisfy the field's required and length rules.

• email must satisfy the email field's validation rules.

• message must contain at least 10 characters.

Note: Email validation checks the address format; it does not guarantee that the email account exists.

9. Adding Custom Validation

Sometimes an application requires validation beyond Django's built-in rules.

For example, suppose a student name must not contain only whitespace.

from django import forms


class StudentForm(forms.Form):

    name = forms.CharField(max_length=100)
    email = forms.EmailField()

    def clean_name(self):
        name = self.cleaned_data['name'].strip()

        if not name:
            raise forms.ValidationError(
                "Name cannot be empty."
            )

        return name

Explanation:

• clean_name() validates the name field.

• self.cleaned_data contains field values that have passed their individual field validation.

• forms.ValidationError provides a user-friendly validation error.

• Returning the cleaned value allows Django to use it in subsequent processing.

Django also supports a clean() method for validating relationships between multiple fields.

10. Displaying Validation Errors

When validation fails, Django stores error information in the form.

Update the template:

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

    {{ form.non_field_errors }}

    {% for field in form %}
        <div>
            <label for="{{ field.id_for_label }}">
                {{ field.label }}
            </label>

            {{ field }}

            {% for error in field.errors %}
                <p class="error">{{ error }}</p>
            {% endfor %}
        </div>
    {% endfor %}

    <button type="submit">Submit</button>
</form>

Explanation:

• form.non_field_errors displays errors that do not belong to a specific field.

• field.errors displays validation errors for an individual field.

• field.id_for_label provides the appropriate field ID for its label.

Displaying errors beside the relevant fields makes forms easier to understand and correct.

11. Saving Data with ModelForm

When a ModelForm is connected to a model, valid data can be saved using save().

form = StudentModelForm(request.POST)

if form.is_valid():
    student = form.save()

This creates a new student record when the form is not bound to an existing instance.

If you need to modify the object before saving it, use commit=False.

if form.is_valid():
    student = form.save(commit=False)

    # Apply additional trusted server-side values here.

    student.save()

Important: commit=False creates an unsaved model instance. It does not save the record until student.save() is called.

If the form includes many-to-many model fields, call form.save_m2m() after saving the instance when required.

12. Updating Existing Records with ModelForm

ModelForms can also be used to edit existing database records.

Add this view to students/views.py:

from django.shortcuts import get_object_or_404, redirect, render
from .models import Student
from .forms import StudentModelForm


def student_update(request, student_id):

    student = get_object_or_404(
        Student,
        id=student_id
    )

    if request.method == 'POST':
        form = StudentModelForm(
            request.POST,
            instance=student
        )

        if form.is_valid():
            form.save()
            return redirect('student_list')

    else:
        form = StudentModelForm(instance=student)

    return render(
        request,
        'students/student_form.html',
        {'form': form}
    )

How updating works:

• get_object_or_404() retrieves the student or returns a 404 response.

• instance=student connects the form to the existing record.

• On a GET request, the form displays the student's current values.

• On a valid POST request, form.save() updates that record.

Unlike creating a new form without an instance, providing an existing instance allows Django to update the selected object.

13. Applying Bootstrap Styling

Bootstrap can make Django forms more professional and responsive.

Include Bootstrap CSS in your template and add classes to form fields.

For example:

from django import forms
from .models import Student


class StudentModelForm(forms.ModelForm):

    class Meta:
        model = Student

        fields = [
            'name',
            'email',
            'phone',
            'course',
            'city',
        ]

        widgets = {
            'name': forms.TextInput(
                attrs={'class': 'form-control'}
            ),
            'email': forms.EmailInput(
                attrs={'class': 'form-control'}
            ),
            'phone': forms.TextInput(
                attrs={'class': 'form-control'}
            ),
            'course': forms.TextInput(
                attrs={'class': 'form-control'}
            ),
            'city': forms.TextInput(
                attrs={'class': 'form-control'}
            ),
        }

You can then use Bootstrap's grid system and spacing utilities to create a responsive form layout.

Note: Bootstrap classes work only when the Bootstrap stylesheet is included in the page.

14. GET vs POST in Django Forms

GET requests are generally used to retrieve pages or search results. Their parameters appear in the URL.

POST requests are commonly used to submit data that creates or updates records.

Feature	GET	POST
Common purpose	Search and retrieve	Submit or modify data
Parameters	Usually included in URL	Included in request body
Bookmarking results	Convenient	Not intended for this purpose
CSRF protection	Generally not required for safe reads	Required for protected form submissions
Typical example	Student search	Student registration

Important: POST is not encryption. Use HTTPS to protect data in transit, and implement appropriate authentication, authorization, and validation.

15. Common Mistakes to Avoid

1. Forgetting {% csrf_token %} in a POST form.

2. Saving form data without checking form.is_valid().

3. Forgetting to import the correct form or model.

4. Using field names that do not exist in the model.

5. Using fields = '__all__' when only specific fields should be editable.

6. Forgetting to pass instance=student when updating an existing record.

7. Failing to display validation errors.

8. Forgetting to create or include the appropriate URL pattern.

9. Assuming that a valid email format guarantees a real email account.

10. Trusting client-submitted values for permissions, prices, or other sensitive fields.

Frequently Asked Questions (FAQs)

Q1. What is a Django Form?

A Django Form is a Python class used to define input fields, validate submitted data, and process user input.

Q2. What is a ModelForm?

A ModelForm is a form class that derives fields and validation rules from a Django model and can create or update model instances.

Q3. What is the difference between Form and ModelForm?

A Form is suitable for custom input that may not directly correspond to a model. A ModelForm is useful when form data maps to an existing model.

Q4. What does is_valid() do?

It validates the bound form and makes cleaned field values available through cleaned_data when validation succeeds.

Q5. What does form.save() do?

For a valid ModelForm, it creates a new database record or updates an existing model instance, depending on whether an instance was supplied.

Q6. Why is commit=False used?

It allows developers to obtain an unsaved model instance, modify appropriate server-controlled fields, and save it afterward.

Q7. What is CSRF protection?

Cross-Site Request Forgery protection helps prevent unauthorized requests made through a user's authenticated browser. Django provides CSRF middleware and template tags to support this protection.

Q8. Can a ModelForm update an existing record?

Yes. Pass the existing model object through the instance argument when creating the form.

Interview Questions and Answers

Q1. What is the purpose of forms.py?

It is a conventional location for defining form classes in a Django application.

Q2. What is cleaned_data?

It is a dictionary containing field values that have passed the form's field-level validation and cleaning process.

Q3. What is the purpose of clean_<fieldname>()?

It performs custom validation and cleaning for a specific form field.

Q4. What is the purpose of clean()?

It allows developers to validate multiple fields together or enforce conditions involving the entire form.

Q5. What is the difference between form.save() and form.save(commit=False)?

form.save() saves the model instance immediately. form.save(commit=False) returns an unsaved instance for additional processing.

Q6. How do you display form errors in a template?

Use form.errors, form.non_field_errors, or each field's errors attribute.

Q7. How do you update a database record using ModelForm?

Retrieve the existing model instance and pass it to the form using instance=existing_object.

Practical Assignment

Build a Student Registration and Update System using Django Forms and ModelForms.

Requirements:

1. Create a student model with name, email, phone, course, and city fields.

2. Create a ModelForm using explicit model fields.

3. Display a registration form in a Django template.

4. Validate required fields and email format.

5. Add custom validation for student names.

6. Display validation errors beside the relevant fields.

7. Save valid form submissions to the database.

8. Display registered students on a listing page.

9. Add an edit feature using ModelForm.

10. Apply Bootstrap styling to the forms.

11. Include CSRF protection in POST forms.

12. Test both valid and invalid submissions.

Expected Outcome: You should be able to create, validate, save, and update database records using Django Forms and ModelForms.

Conclusion

Django Forms and ModelForms simplify the process of collecting, validating, and saving user data. By understanding form fields, validation methods, CSRF protection, and database integration, developers can build secure and maintainable data-entry features.

These concepts are essential for registration systems, contact forms, admin dashboards, student management applications, and other database-driven projects.

In the next module, you will learn about Django File Uploads and Media Handling, including how to upload images and documents, configure media settings, and display uploaded files in templates.