Django Views and Templates

SR suriya-ravichandran Updated 2 Sep 2026

5 min read · Lesson 6 of 36

« Previous Next »

Preparing your lesson...

In this lesson, we will explore two fundamental components of Django: Views and Templates. Understanding these concepts is crucial for rendering dynamic web pages and creating interactive web applications. By the end of this lesson, you will be equipped with the knowledge to create views and templates that can display data to users in a meaningful way.

Learning Objectives

By the end of this lesson, you will be able to: - Understand the role of views in a Django application. - Create basic views to handle web requests. - Understand the purpose of templates in rendering HTML. - Create and use templates to display dynamic content. - Connect views and templates to create a functional web page.

Understanding Django Views

Views are Python functions or classes that receive web requests and return web responses. They act as a bridge between your models (data) and templates (presentation). When a user accesses a URL mapped to a view, Django invokes that view to process the request and generate an appropriate response.

Types of Views

Function-Based Views (FBVs): These are simple Python functions that take a web request and return a web response. They are easy to understand and suitable for simple applications.
Class-Based Views (CBVs): These are Python classes that provide more structure and reusability. They allow for inheritance and can encapsulate common patterns, making them useful for larger applications.

In this lesson, we will primarily focus on Function-Based Views for simplicity.

Creating a Simple View

Let’s create a simple view that returns a plain text response. First, open your Django app's views.py file and add the following code:

from django.http import HttpResponse

def hello_view(request):
    return HttpResponse('Hello, World!')

In this code: - We import HttpResponse from django.http, which is used to create an HTTP response. - We define a function hello_view that takes request as a parameter. This function returns a simple text response, "Hello, World!".

Mapping the View to a URL

To make this view accessible via a web browser, we need to map it to a URL. Open the urls.py file in your app and add the following code:

from django.urls import path
from .views import hello_view

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

In this code: - We import the path function and our hello_view from views.py. - We define a URL pattern that maps the URL path hello/ to our hello_view function.

Now, if you run your server and navigate to http://127.0.0.1:8000/hello/, you should see the text "Hello, World!" displayed in your browser.

Understanding Django Templates

Templates are HTML files that define the structure and layout of your web pages. They allow you to separate the presentation layer from the business logic of your application. Django uses its own templating language to facilitate dynamic content rendering.

The Purpose of Templates

Templates enable you to: - Reuse HTML code across different web pages. - Insert dynamic data into your HTML files. - Maintain a clean separation of concerns, making your application easier to manage.

Creating a Template

Let’s create a simple template to display a greeting message. First, create a new directory called templates inside your Django app, and create a file named greeting.html inside it:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Greeting</title>
</head>
<body>
    <h1>{{ message }}</h1>
</body>
</html>

In this template: - We define a basic HTML structure with a <h1> tag that will display a dynamic message. - The {{ message }} syntax is a placeholder for dynamic content that will be passed from the view.

Connecting Views and Templates

Now that we have created a view and a template, let’s connect them. Modify the hello_view function in views.py to render the template instead of returning plain text:

from django.shortcuts import render

def hello_view(request):
    context = {'message': 'Hello, World from a Template!'}
    return render(request, 'greeting.html', context)

In this updated code: - We import the render function from django.shortcuts. - We create a context dictionary containing the message we want to display. - We call the render function, passing the request, the template name, and the context.

Now, when you visit http://127.0.0.1:8000/hello/, you should see the message "Hello, World from a Template!" displayed within the structure of your HTML template.

Best Practices for Views and Templates

Keep Views Simple: Views should be responsible for handling requests and delegating tasks to templates. Avoid putting too much logic in your views.
Use Context Dictionaries: Always use context dictionaries to pass data to templates. This keeps your templates clean and easy to read.
Organize Templates: Organize your templates in a consistent directory structure. This makes it easier to manage and locate templates as your project grows.
Template Inheritance: Use template inheritance to create a base template that can be extended by other templates. This promotes reusability and consistency across your application.

Common Mistakes and How to Avoid Them

Forgetting to Map URLs: Always remember to map your views to URLs in urls.py. Without this, your views won't be accessible.
Not Passing Context: Failing to pass a context dictionary to your template will result in errors when trying to access template variables.
Incorrect Template Path: Ensure that the path to your template in the render function is correct. Django will raise an error if it cannot find the specified template.

Key Takeaways

Views are functions or classes that handle web requests and return responses.
Templates are HTML files that define how data is presented to the user.
You can connect views and templates to create dynamic web pages.
Always use context dictionaries to pass data to templates.
Keep your views simple and organized for better maintainability.

In this lesson, we learned how to create views and templates in Django, and how to connect them to render dynamic web pages. With this foundational knowledge, you are now ready to explore Django Models in the next lesson, where we will learn how to interact with databases and manage data in our applications.

Exercises

Hands-on Practice Exercises

Create a New View: Create a new view that returns a simple HTML response with your name. Map it to a URL of your choice.
Dynamic Greeting: Modify the existing hello_view to accept a user's name as a query parameter (e.g., http://127.0.0.1:8000/hello/?name=John) and display a personalized greeting in the template.
Multiple Templates: Create two different templates (e.g., greeting.html and farewell.html) and create two views that render each template. Map them to different URLs.
Template Inheritance: Create a base template with a header and footer. Extend this template in a new template that displays a greeting message. Ensure the header and footer appear in both templates.
Mini-Project: Build a simple web application that has at least three pages: a home page, an about page, and a contact page. Each page should use a separate template and include navigation links to the other pages.

Practical Assignment

Create a Django application that allows users to submit their favorite quotes. The application should have the following features: - A form for users to submit their quotes. - A view that processes the form submission and saves the quote. - A template that displays all submitted quotes in a list format. - Ensure that the quotes are displayed dynamically using templates.

This project will help you solidify your understanding of views and templates while also introducing you to form handling in Django.

Summary

Views are the backbone of Django applications, handling requests and returning responses.
Templates allow for the separation of presentation from business logic, making it easier to manage HTML.
Always use context dictionaries to pass data to templates for dynamic content rendering.
Keep views simple and organized to improve maintainability.
Use template inheritance to promote reusability and consistency in your application.
Remember to map your views to URLs and ensure correct template paths.

Helpful YouTube Videos

{"title": "Django Views Explained", "query": "Django views tutorial"}
{"title": "Django Templates for Beginners", "query": "Django templates tutorial"}
{"title": "Creating Dynamic Web Pages with Django", "query": "Django dynamic web pages"}

Django URL Dispatcher

Working with Django Models