What are views in Django?

Question

Accepted Answer

A **view** is the logic layer of Django — a function or class that takes an HTTP **request**, performs logic (querying models, processing input), and returns an HTTP **response**. Views are where you handle what happens when a URL is accessed.

## Function-based views (FBVs)

```python
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse, HttpResponse

def article_list(request):
    articles = Article.objects.all()                    # query models
    return render(request, "articles.html", {"articles": articles})  # render a template

def article_detail(request, pk):
    article = get_object_or_404(Article, pk=pk)         # 404 if not found
    return render(request, "detail.html", {"article": article})

def api_articles(request):
    data = list(Article.objects.values("title", "body"))
    return JsonResponse(data, safe=False)               # return JSON instead of HTML
```

A function-based view receives the `request` (plus any URL parameters), does its work, and returns a response — `render()` for HTML, `JsonResponse` for JSON, `HttpResponse` for raw output.

## Handling different HTTP methods and input

```python
def create_article(request):
    if request.method == "POST":
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect("article_list")             # redirect after a successful POST
    else:
        form = ArticleForm()
    return render(request, "create.html", {"form": form})
```

Views inspect `request.method` (GET, POST, etc.) and access input via `request.POST`, `request.GET`, `request.user`, etc.

## Class-based views (CBVs) — reusable, less boilerplate

```python
from django.views.generic import ListView, DetailView

# generic CBVs handle common patterns with minimal code
class ArticleListView(ListView):
    model = Article                                     # automatically lists all articles
    template_name = "articles.html"

class ArticleDetailView(DetailView):
    model = Article
```

Django also offers **class-based views** — including generic views (`ListView`, `DetailView`, `CreateView`) that implement common patterns (listing, detail, CRUD) with very little code, reducing boilerplate.

## The view's role in the request flow

```text
Request → URL routing → VIEW (logic) → queries models, renders template → Response
The view is the orchestrator: it connects the URL, the data (models), and the
presentation (template) to produce a response.
```

## Why it matters

Views are the logic layer of Django (the "V" in MVT, equivalent to MVC's controller) — they're where you handle every request, making them fundamental to building any Django application.

Understanding views is essential because they're the orchestrators that tie everything together: receiving the request, applying business logic, querying models for data, processing user input (forms), and returning the appropriate response (HTML via templates, or JSON for APIs).

Knowing how to write **function-based views** (explicit, flexible — good for custom logic), handle different HTTP methods and access request data, and use **class-based/generic views** (which dramatically reduce boilerplate for common patterns like listing and CRUD) covers the practical spectrum of building Django endpoints.

Views are where most of an application's request-handling logic lives, so mastering them — the request/response cycle, the choice between function-based and class-based approaches, and how views connect URLs to models and templates — is core, everyday knowledge for any Django developer and central to how the framework processes requests.