Author avatar

Kimaru Thagana

Introduction to Django Views

Kimaru Thagana

  • Oct 28, 2020
  • 7 Min read
  • 72 Views
  • Oct 28, 2020
  • 7 Min read
  • 72 Views
Web Development
Django
Back End Web Development
Server-side Frameworks

Introduction

In the model view controller (MVC) architecture, the view component deals with how data is presented to users for consumption and viewing. In the Django framework, views are Python functions or classes that receive a web request and return a web response. The response can be a simple HTTP response, an HTML template response, or an HTTP redirect response that redirects a user to another page. Views hold the logic that is required to return information as a response in whatever form to the user. As a matter of best practice, the logic that deals with views is held in the views.py file in a Django app.

This guide will explore how to use views in Django as a data display and viewing tool. It will also explore the two major types of views: class-based and function-based views. It assumes that you have at least beginner level knowledge of Django and a general understanding of the Django MVC. An introductory guide to Django can be found here.

Sample App

To better understand views, consider a Django app for a sports inventory. The model has details about the sports items being stored. Below is a snippet for the model.

1
2
3
4
5
6
7
8
from django.db import models

class Inventory(models.Model):
    item = models.CharField(max_length=20)
    item_code = models.IntegerField()
    item_condition = models.CharField(max_length=50)
    def __str__(self):
        return self.item
python

Class-based Views (Generic)

Class-based views allow you to create views from inherited classes, thus making coding the views much easier. Generally, there are five types of common class-based views (generic) that perform the CRUD (create, retrieve, update, delete) operations for any common web app. All of these views involve operating on data via a model instance. At all times, a model instance is provided.

List View

As the name suggests, the list view generates a list of items in the model from the database. Here is a sample list view class for the sports inventory app.

1
2
3
4
5
6
7
from django.views.generic import ListView
from . models import Inventory
class SportsItemListView(ListView):
    model = Inventory
    # a html file that will display a list of all the items in inventory model
    template_name = 'sports/items.html' 
    context_object_name = 'items' # how the list will be referred to in the html template
python

DetailView

The detailview command is used to display the data for a single record from the database. Here is sample code for a detail view to display a single record from the Inventory table in your app.

1
2
3
4
5
6
7
from django.views.generic import DetailView
from . models import Inventory

class SportsItemDetailView(DetailView):
    model = Inventory
    template_name = 'book/detail.html'
    context_object_name = 'item'
python

CreateView

createview creates a new record in the database using the model instance.

1
2
3
4
5
6
7
8
9
from django.views.generic import CreateView
from . models import Inventory
from django.urls import reverse_lazy

class ItemCreateView(CreateView):
    model = Inventory
    template_name = 'sports/create_item.html'
    fields = ('item', 'item_code', 'item_condition', )
    success_url = reverse_lazy('sports-list')
python

UpdateView

The updateview command performs an update operation to an existing record in the database.

1
2
3
4
5
6
7
8
9
10
11
12
13
from django.views.generic import UpdateView
from . models import Inventory
from django.urls import reverse_lazy

class ItemUpdateView(UpdateView):

    model = Inventory
    template_name = 'sports/update.html'
    context_object_name = 'item'
    fields = ('item', 'item_code', 'item_condition', )

    def get_success_url(self):
        return reverse_lazy('item-detail', kwargs={'pk': self.object.id})
python

Delete View

deleteview is used to perform a delete operation on a single record in the database via the specified model.

1
2
3
4
5
6
7
8
from django.views.generic import DeleteView
from . models import Inventory
from django.urls import reverse_lazy

class ItemDeleteView(DeleteView):
    model = Inventory
    template_name = 'sports/delete.html'
    success_url = reverse_lazy('item-list')
python

Function-based Views

Function-based views are functions that return an HTTP response after executing the required business logic of a certain view.

Simple HTTP Response

This is used in cases where the message is very simple—maybe just short text—important, and the presentation does not matter. The code snippet below demonstrates a function-based view returning a simple HTTP response.

1
2
3
4
5
from django.http import HttpResponse

def simple_http_response(request):
    # perform business logic
    return HttpResponse("Hello world from Django !")
python

HTTP Response Redirect

This redirect is used when the logic requires that after execution, the user is redirected to another view. An example would be after deleting a record in a detail view, the page redirects to the home page.

1
2
3
4
5
6
from django.http import HttpResponseRedirect
from django.urls import reverse

def delete_item(request, id):
    #perform delete operation successfully
    return HttpResponseRedirect(reverse('url_name_of_homepage'))
python

Template Response

A template response is used when the response is complex and may require further processing on the HTML side, such as displaying multiple records via looping. This use case also requires proper presentation, so it allows rendering of a HTML file.

1
2
3
4
from django.shortcuts import render
def simple_template(request):
    # perform business logic
    return render(request, "sports/simple_template.html", {})
python

Conclusion

Mastering views is an important aspect of web development, especially using MVC frameworks like Django. This vital skill is beneficial for Python developers holding the role of Django developer, backend engineer, or full-stack engineer in their places of work.

To further build on this guide, research more about the views used in APIs. This will likely involve research on the Django Rest Framework (DRF)—more specifically, the APIView class.

As a challenge, finish up the above app for a sports inventory business. Add appropriate URLs to all the views created and design simple HTML pages for displaying the data. This guide will give you a good idea of how to navigate this task.

0