In Django, views are a core part of the Model-View-Template (MVT) architecture. A view takes in a web request and returns a web response. It can access the database, render templates, handle forms, redirect users — essentially, it controls what logic runs when a URL is hit.

Let’s explore what Django views are, their types, and how to implement them with examples and tips.

What is a Django View?

A view in Django is a Python function or class that receives an HTTP request and returns an HTTP response.

It serves as the controller in Django's version of MVC (Model-View-Controller).

Types of Views in Django

There are two main types of views in Django:

1. Function-based views (FBVs)

2. Class-based views (CBVs)

Let’s look at both.

1. Function-Based Views (FBVs)

The simplest way to create a view is by using a Python function.

✅ Example: A Simple View

# views.py
from django.http import HttpResponse

def hello_view(request):
    return HttpResponse("Hello, Django!")

Mapping the URL:

# urls.py
from django.urls import path
from .views import hello_view

urlpatterns = [
    path('hello/', hello_view),
]

Accessing /hello/ in your browser will return a simple plain-text response:
Hello, Django!

✅ Example: Using Templates

# views.py
from django.shortcuts import render

def home_view(request):
    context = {'name': 'Django'}
    return render(request, 'home.html', context)

<!-- templates/home.html -->
<h1>Welcome, {{ name }}!</h1>

2. Class-Based Views (CBVs)

Class-based views provide an object-oriented approach to handling views.

✅ Example: Basic CBV

from django.http import HttpResponse
from django.views import View

class HelloView(View):
    def get(self, request):
        return HttpResponse("Hello from class-based view!")

# urls.py
from django.urls import path
from .views import HelloView

urlpatterns = [
    path('hello/', HelloView.as_view()),  # Don’t forget .as_view()
]

Built-in Generic Views

Django offers pre-built class-based views for common patterns:

✅ Example: Using TemplateView

from django.views.generic import TemplateView

class AboutView(TemplateView):
    template_name = 'about.html'

Using Models in Views

Views often fetch or manipulate data via Django models.

✅ Example: Displaying Data

from django.shortcuts import render
from .models import Book

def book_list(request):
    books = Book.objects.all()
    return render(request, 'books.html', {'books': books})

Adding Logic and Conditions

Views can contain any business logic:

def profile_view(request):
    if not request.user.is_authenticated:
        return redirect('login')
    return render(request, 'profile.html')

✅ Best Practices

• Keep views simple — don’t overload them with business logic.

• Use class-based views for reusability and DRY code.

• Use decorators like @login_required for access control.

• Separate view logic and data access (use forms and services if logic grows).

⚠️ Common Pitfalls

Final Thoughts

Django views are central to handling user interaction and shaping the flow of data between the browser and your database. Whether you go with function-based views for simplicity or class-based views for scalability, understanding views is crucial for effective Django development.