CodeToLive

Django Views & URL Routing

Views in Django are Python functions or classes that receive web requests and return web responses. URL routing maps URLs to appropriate views.

What are Django Views?

Views are the core of Django applications:

  • Receive an HTTP request
  • Process the request (possibly using models)
  • Return an HTTP response
  • Can be function-based or class-based

Function-Based Views

The simplest type of view is a function that takes a request and returns a response: 


from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello, World!")

URL Configuration

To connect a view to a URL, you need a URLconf (URL configuration) module: 


from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello_world),
]

Basic View Examples

Here are some common view patterns:

Simple Response


from django.http import HttpResponse

def current_time(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

Dynamic URL Parameters


def greet(request, name):
    return HttpResponse(f"Hello, {name}!")

URL pattern: 


path('greet/<str:name>/', views.greet),

Query Parameters


def search(request):
    query = request.GET.get('q', '')
    return HttpResponse(f"You searched for: {query}")

Accessed via /search/?q=django

Common Response Types

Django provides several response classes:

  • HttpResponse - Basic response with any content
  • HttpResponseRedirect - Redirect to another URL
  • JsonResponse - JSON-encoded response
  • FileResponse - Stream a file
  • StreamingHttpResponse - Stream a response

Template Responses

Django makes it easy to return HTML responses using templates: 


from django.shortcuts import render

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

Class-Based Views

Django provides class-based views for common patterns: 


from django.views import View

class GreetView(View):
    def get(self, request, name):
        return HttpResponse(f"Hello, {name}!")

URL pattern: 


path('greet/<str:name>/', views.GreetView.as_view()),

Common Built-in Class-Based Views

Django provides many generic class-based views:

  • TemplateView - Render a template
  • ListView - Display a list of objects
  • DetailView - Display a single object
  • CreateView - Create a new object
  • UpdateView - Update an object
  • DeleteView - Delete an object
  • FormView - Display and process a form

ListView Example


from django.views.generic import ListView
from .models import Book

class BookListView(ListView):
    model = Book
    template_name = 'books/list.html'
    context_object_name = 'books'

DetailView Example


from django.views.generic import DetailView
from .models import Book

class BookDetailView(DetailView):
    model = Book
    template_name = 'books/detail.html'

URL Patterns

Django's URL dispatcher uses these components:

  • path() - For simple paths
  • re_path() - For complex regex patterns
  • include() - To include other URLconfs

Path Converters

Django provides several path converters:

  • str - Matches any non-empty string (default)
  • int - Matches zero or any positive integer
  • slug - Matches any slug string (ASCII letters, numbers, hyphens, underscores)
  • uuid - Matches a formatted UUID
  • path - Matches any non-empty string including path separators

URL Namespaces

Namespaces help avoid URL name collisions: 


# Main urls.py
path('books/', include('books.urls', namespace='books')),
                

# books/urls.py
app_name = 'books'
urlpatterns = [
    path('', views.BookListView.as_view(), name='list'),
]

Then in templates: 


<a href="{% url 'books:list' %}">Book List</a>

Reverse URL Resolution

Generate URLs from view names: 


from django.urls import reverse

def my_view(request):
    url = reverse('books:detail', args=[1])
    # or
    url = reverse('books:detail', kwargs={'pk': 1})

View Decorators

Decorators add functionality to views:

  • @login_required - Restrict to logged-in users
  • @permission_required - Check permissions
  • @require_http_methods - Restrict HTTP methods
  • @cache_control - Set caching headers

Login Required Example


from django.contrib.auth.decorators import login_required

@login_required
def my_profile(request):
    return render(request, 'profile.html')

Request and Response Objects

Key attributes of request objects:

  • request.method - HTTP method (GET, POST, etc.)
  • request.GET - GET parameters
  • request.POST - POST parameters
  • request.FILES - Uploaded files
  • request.user - Current user
  • request.session - Session data

Middleware

Middleware are hooks for processing requests/responses globally: 


class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Code executed on each request before the view
        response = self.get_response(request)
        # Code executed on each response after the view
        return response

Built-in Middleware

Common middleware classes:

  • CommonMiddleware - Adds useful headers
  • SessionMiddleware - Session support
  • AuthenticationMiddleware - Associates users with requests
  • MessageMiddleware - Cookie-based messages
  • CsrfViewMiddleware - CSRF protection

View Best Practices

  • Keep views focused and simple
  • Move business logic to models or services
  • Use class-based views for common patterns
  • Use namespaces for URL names
  • Handle different HTTP methods properly
  • Use appropriate status codes
Next: Templates