Form class definition in Django - Step-by-Step Execution

Concept Flow - Form class definition

Define Form class

↓

Add fields as class attributes

↓

Set field types and options

↓

Use form in views/templates

↓

Render form and handle input

This flow shows how to create a Django form class by defining fields, then use it to render and process user input.

Execution Sample

Django

from django import forms

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

Defines a simple contact form with name, email, and message fields.

Execution Table

Step	Action	Evaluation	Result
1	Import forms module	from django import forms	forms module ready
2	Define ContactForm class	class ContactForm(forms.Form):	ContactForm class created
3	Add 'name' field	name = forms.CharField(max_length=100)	name field added with max_length=100
4	Add 'email' field	email = forms.EmailField()	email field added with email validation
5	Add 'message' field	message = forms.CharField(widget=forms.Textarea)	message field added with textarea widget
6	Use form in view/template	form = ContactForm()	form instance created for rendering/input
7	Render form in template	form.as_p()	HTML form rendered with fields
8	Handle form submission	form = ContactForm(request.POST)	form instance with submitted data
9	Validate form	form.is_valid()	True if data valid, else False
10	Process valid data	form.cleaned_data	Access cleaned input values
11	Exit	Form class definition and usage complete	End of flow

💡 All form fields defined and form usage steps completed

Variable Tracker

Variable	Start	After Step 6	After Step 8	After Step 9	Final
ContactForm	Not defined	Class defined	Class defined	Class defined	Class defined
form	None	Instance with empty fields	Instance with POST data	Validated form instance	Validated form instance
form.cleaned_data	None	None	None	Dictionary of cleaned data	Dictionary of cleaned data

Key Moments - 3 Insights

Why do we define fields as class attributes inside the form class?

Fields are defined as class attributes so Django can automatically create form inputs and validations, as shown in execution_table steps 3-5.

What happens when we call form.is_valid()?

Calling form.is_valid() runs validation on all fields and sets cleaned_data if valid, as shown in execution_table step 9.

How does the form class relate to the HTML form rendered?

The form class defines the structure and validation; calling form.as_p() renders HTML inputs matching those fields, as in step 7.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'form' after step 6?

A An instance with submitted POST data

B An instance with empty fields ready for rendering

C A class definition, not an instance

D A dictionary of cleaned data

💡 Hint

Check the 'form' variable in variable_tracker after step 6

At which step does the form validate the submitted data?

A Step 9

B Step 4

C Step 7

D Step 11

💡 Hint

Look for form.is_valid() in execution_table

If we add a new field 'phone = forms.CharField()', which step would change?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Adding a new field is similar to adding 'message' field in step 5

Concept Snapshot

Define a Django form by creating a class inheriting from forms.Form
Add fields as class attributes with field types and options
Use form instances in views to render and process input
Call form.is_valid() to validate and access cleaned_data
Rendering uses methods like form.as_p() for HTML output

Full Transcript

In Django, you create a form by defining a class that inherits from forms.Form. Inside this class, you add fields as class attributes, specifying their types like CharField or EmailField. This tells Django what inputs to create and how to validate them. When you use the form in your view, you create an instance of this class. You can render it in your template to show the form to users. When users submit data, you create a form instance with that data and call is_valid() to check if the input meets all rules. If valid, you access cleaned_data to get safe input values. This process helps you handle user input easily and safely.