Formsets in a Django is an advanced way of handling multiple forms on a single webpage. In other words, Formsets are a group of forms in Django. One might want to initialize multiple forms on a single page all of which may involve multiple POST requests, for example
from django import forms
class GeeksForm(forms.Form):
title = forms.CharField()
pub_date = forms.DateField()
Now one might want to permit the user to create articles at once, so if thought in a conventional manner one uses multiple forms and different names for each form to handle data on a single page but this would complicate the code as well as functionality. A formset is a layer of abstraction to work with multiple forms on the same page. It can be best compared to a data grid.
Now to create a formset of this
GeeksForm,
from django.forms import formset_factory
GeeksFormSet = formset_factory(GeeksForm)
Creating and using Django Formsets
Illustration of
Rendering Django Forms Manually using an Example. Consider a project named
geeksforgeeks
having an app named
geeks
.
Refer to the following articles to check how to create a project and an app in Django.
In your geeks app make a new file called forms.py where you would be making all your forms. To create a Django form you need to use
Django Form Class. Let's demonstrate how,
In your
forms.py
Enter the following,
Python3 1==
from django import forms
# create a form
class GeeksForm(forms.Form):
title = forms.CharField()
description = forms.CharField()
Let's explain what exactly is happening, left side denotes the name of the field and to right of it, you define various functionalities of an input field correspondingly. A field's syntax is denoted as
Syntax :
Field_name = forms.FieldType(attributes)
Now to create a simple formset of this form, move to views.py and create a
formset_view
as below.
Python3 1==
from django.shortcuts import render
# relative import of forms
from .forms import GeeksForm
# importing formset_factory
from django.forms import formset_factory
def formset_view(request):
context ={}
# creating a formset
GeeksFormSet = formset_factory(GeeksForm)
formset = GeeksFormSet()
# Add the formset to context dictionary
context['formset']= formset
return render(request, "home.html", context)
To render the formset through HTML, create a html file "home.html". Now let's edit
templates > home.html
html
<form method="POST" enctype="multipart/form-data">
{% csrf_token %}
{{ formset.as_p }}
<input type="submit" value="Submit">
</form>
All set to check if our formset is working or not let's visit
http://localhost:8000/.

.
Our formset is working completely. Let's learn how to modify this formset to use extra features of this formset.
How to create Multiple forms using Django Formsets
Django formsets are used to handle multiple instances of a form. One can create multiple forms easily using
extra
attribute of Django Formsets. In
geeks/views.py,
Python3 1==
from django.shortcuts import render
# relative import of forms
from .forms import GeeksForm
# importing formset_factory
from django.forms import formset_factory
def formset_view(request):
context ={}
# creating a formset and 5 instances of GeeksForm
GeeksFormSet = formset_factory(GeeksForm, extra = 5)
formset = GeeksFormSet()
# Add the formset to context dictionary
context['formset']= formset
return render(request, "home.html", context)
The keyword argument
extra
makes multiple copies of same form. If one wants to create 5 forms enter
extra = 5
and similarly for others. Visit
http://localhost:8000/ to check if 5 forms are created.
Handling Multiple forms using Django Formsets
Creating a form is much easier than handling the data entered into those fields at the back end. Let's try to demonstrate how one can easily use the data of a formset in a view. When trying to handle formset, Django formsets required one extra argument
{{ formset.management_data }}. To know more about Management data, visit
Understanding the ManagementForm.
In
templates/home.html
,
html
<form method="POST" enctype="multipart/form-data">
<!-- Management data of formset -->
{{ formset.management_data }}
<!-- Security token -->
{% csrf_token %}
<!-- Using the formset -->
{{ formset.as_p }}
<input type="submit" value="Submit">
</form>
Now to check how and what type of data is being rendered edit
formset_view to print the data. In
geeks/view.py
,
Python3 1==
from django.shortcuts import render
# relative import of forms
from .forms import GeeksForm
# importing formset_factory
from django.forms import formset_factory
def formset_view(request):
context ={}
# creating a formset and 5 instances of GeeksForm
GeeksFormSet = formset_factory(GeeksForm, extra = 3)
formset = GeeksFormSet(request.POST or None)
# print formset data if it is valid
if formset.is_valid():
for form in formset:
print(form.cleaned_data)
# Add the formset to context dictionary
context['formset']= formset
return render(request, "home.html", context)
Now let's try to enter data in the formset through
http://localhost:8000/

Hit submit and data will be display in command line where server is running. One can use this data in any manner conveniently now.

Formset is advanced stuff which can be used to resolve a number of problems but should be used with correct syntax and field validations otherwise conflicts and errors will disrupt the normal functioning. To know more about Formsets, Visit
Official Documentation for Formsets.
Similar Reads
Django Form
When one creates a Form class, the most important part is defining the fields of the form. Each field has custom validation logic, along with a few other hooks. This article revolves around various fields one can use in a form along with various features and techniques concerned with Django Forms. D
6 min read
How to create a form using Django Forms ?
Django forms are an advanced set of HTML forms that can be created using python and support all features of HTML forms in a pythonic way. This post revolves around how to create a basic form using various Form Fields and attributes. Creating a form in Django is completely similar to creating a model
3 min read
Django ModelFormSets
ModelFormsets in a Django is an advanced way of handling multiple forms created using a model and use them to create model instances. In other words, ModelFormsets are a group of forms in Django. One might want to initialize multiple forms on a single page all of which may involve multiple POST requ
4 min read
Django ModelForm
ModelForm is a class that automatically generates a "form" from a Django model. It reduces boilerplate code by linking your form fields directly to your model fields, making form creation faster, cleaner, and less error-prone. It also provides built-in methods and validation to streamline form proce
3 min read
Render Django Forms as table
Django forms are an advanced set of HTML forms that can be created using python and support all features of HTML forms in a pythonic way. Rendering Django Forms in the template may seem messy at times but with proper knowledge of Django Forms and attributes of fields, one can easily create excellent
2 min read
Render Django Forms as paragraph
Django forms are an advanced set of HTML forms that can be created using python and support all features of HTML forms in a pythonic way. Rendering Django Forms in the template may seem messy at times but with proper knowledge of Django Forms and attributes of fields, one can easily create excellent
2 min read
Render Django Forms as list
Django forms are an advanced set of HTML forms that can be created using python and support all features of HTML forms in a pythonic way. Rendering Django Forms in the template may seem messy at times but with proper knowledge of Django Forms and attributes of fields, one can easily create excellent
2 min read
Render HTML Forms (GET & POST)
Django is often called a "Batteries Included Framework" because it provides built-in settings and features that help developers build websites rapidly and efficiently. One of the essential components in web development is handling HTML forms, a way for users to send data to the server for processing
3 min read
Django form field custom widgets
A widget is Djangoâs representation of an HTML input element. The widget handles the rendering of the HTML, and the extraction of data from a GET/POST dictionary that corresponds to the widget. Whenever you specify a field on a form, Django will use a default widget that is appropriate to the type o
3 min read
Initial form data _ Django Forms
When using Django forms, we may want to automatically fill in some fields with default values. This is called initial data and it's different from placeholders because it actually fills the fields. When the form is submitted, this data is treated just like anything the user types in.Django offers mu
3 min read