Class Based vs Function Based Views (original) (raw)

Last Updated : 11 May, 2026

A core feature of Django is views, which define how data is presented to users. Views can be implemented in two main ways: Function-Based Views (FBVs) and Class-Based Views (CBVs).

Function-Based Views (FBVs)

FBVs are simple Python functions that receive a request, process it and return a response. They provide a straightforward way to handle HTTP requests.

**Pros of FBVs:

• Easy to understand, especially for beginners.
• Explicit code flow for each HTTP method.
• Flexible and quick to implement.
• Simple decorator usage (e.g., @login_required).

**Cons of FBVs:

• Code duplication in larger projects.
• Conditional branching for multiple HTTP methods can get messy.

**Example: Creating a function-based view

Python `

from django.http import HttpResponseRedirect from django.urls import reverse from django.shortcuts import render from .forms import MyForm

def example_create_view(request): template_name = 'form.html' form_class = MyForm

form = form_class()

if request.method == 'POST': form = form_class(request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(reverse('list-view'))

return render(request, template_name, {'form': form})

`

**In this example:

• Renders a form using template_name and form_class.
• On POST, validates and saves the form.
• Redirects if successful; re-renders with errors if invalid.

Class-Based Views (CBVs)

CBVs are Python classes that handle requests using object-oriented principles such as inheritance and mixins. They promote reusable and organized view logic, making it easier to manage complex views and avoid code duplication.

**Pros of CBVs:

• Promotes DRY (Don’t Repeat Yourself) principle.
• Better code organization via methods like get(), post().
• Supports inheritance and mixins for modularity.
• Built-in generic views (CreateView, UpdateView, DeleteView).

**Cons of CBVs:

• More abstract, harder for beginners to grasp.
• Less explicit code flow (uses dispatch() and as_view()).
• May require extra imports and method overrides.

**Example: Creating a class-based view

Python `

from django.shortcuts import render, redirect from django.urls import reverse from django.views import View from .forms import MyForm

class MyCreateView(View): template_name = 'form.html' form_class = MyForm

def get(self, request, *args, **kwargs):
    form = self.form_class()
    return render(request, self.template_name, {'form': form})

def post(self, request, *args, **kwargs):
    form = self.form_class(request.POST)
    if form.is_valid():
        form.save()
        return redirect(reverse('list-view'))
    return render(request, self.template_name, {'form': form})

`

**Note: Ensure that the template file 'form.html' exists inside your app's templates directory (e.g., templates/form.html), otherwise Django will raise a TemplateDoesNotExist error.

• as_view() is inherited from View and returns a callable to handle requests.
• When a request arrives, as_view() calls dispatch(), which determines the correct method (get(), post(), etc.).

You can override class attributes dynamically when defining URL patterns:

Python `

from django.urls import path from .views import MyCreateView

urlpatterns = [ path('new/', MyCreateView.as_view(), name='original-create-view'), path( 'new_two/', MyCreateView.as_view( template_name='other_form.html', form_class=MyOtherForm ), name='modified-create-view' ), ]

`

• Generic CBVs (like CreateView) allow overriding helper methods such as get_form_class() or get_template_names() to insert custom logic instead of just changing class attributes.
• Example: With ModelFormMixin, you can override form_valid() to modify self.object before saving.

Generic Class-Based View

Django’s generic CBVs provide pre-built views for common tasks like creating, updating, listing and deleting objects. They reduce boilerplate by automatically handling standard operations such as form display, validation, and saving.

Python `

from django.views.generic import CreateView from .models import MyModel from .forms import MyModelForm

class MyCreateView(CreateView): model = MyModel form_class = MyModelForm template_name = 'form.html' success_url = '/success/'

`

**In this example:

• CreateView automatically handles GET and POST requests.
• Only need to specify model, form, template, and success URL.
• Saves time and avoids repetitive code for standard CRUD operations.

FBVs vs CBVs