Returning HTML templates in Django - Step-by-Step Execution

Concept Flow - Returning HTML templates

User sends HTTP request

↓

Django view function called

↓

View prepares data (optional)

↓

View calls render() with template and data

↓

Django loads HTML template

↓

Template rendered with data

↓

HTTP response with HTML sent back to user

This flow shows how a Django view receives a request, prepares data, renders an HTML template, and sends the response back.

Execution Sample

Django

from django.shortcuts import render

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

A Django view function that returns an HTML page 'home.html' with a variable 'name' set to 'Alice'.

Execution Table

Step	Action	Input/State	Output/Result
1	Receive HTTP request	Request object with URL /home	View function 'home' called
2	Prepare context data	Create dict {'name': 'Alice'}	Context ready for template
3	Call render()	render(request, 'home.html', context)	Django loads 'home.html' template
4	Render template	Template with {{ name }} placeholder	HTML with 'Alice' inserted
5	Return HTTP response	Rendered HTML content	Response sent to user browser

💡 Response sent back after template rendering completes

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
request	HTTP request object	Same	Same	Same
context	None	{'name': 'Alice'}	{'name': 'Alice'}	{'name': 'Alice'}
template	Not loaded	Not loaded	Loaded and rendered	Rendered HTML string

Key Moments - 3 Insights

Why do we pass the 'request' object to the render() function?

The 'request' object is needed by Django to build the full HTTP response and to use context processors. See execution_table step 3.

What happens if the template file name is wrong or missing?

Django raises a TemplateDoesNotExist error during step 3 when trying to load the template.

How does the context dictionary affect the rendered HTML?

The context provides values for placeholders in the template, like {{ name }}, which get replaced during rendering in step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after step 4?

A HTML with 'Alice' inserted

B Context dictionary created

C HTTP request received

D Template file loaded but not rendered

💡 Hint

Check the 'Output/Result' column for step 4 in the execution_table

At which step does Django load the HTML template?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column in the execution_table for when render() is called

If the context dictionary was empty, what would change in the execution?

A Template would not load

B Rendered HTML would have placeholders unchanged

C HTTP response would fail

D Request object would be missing

💡 Hint

Refer to variable_tracker and execution_table step 4 about how context affects rendering

Concept Snapshot

Django views return HTML by calling render(request, template_name, context).
The 'request' is needed for response building.
The 'template_name' is the HTML file to load.
The 'context' is a dictionary with data for placeholders.
Render loads the template, fills placeholders, and returns an HTTP response.
If template missing, Django raises an error.

Full Transcript

In Django, when a user sends a request, the corresponding view function is called. The view can prepare data in a context dictionary. Then it calls the render() function, passing the request, the template file name, and the context. Django loads the HTML template file, replaces placeholders with context data, and returns the rendered HTML as an HTTP response. This process allows dynamic HTML pages to be sent to the user's browser. If the template file is missing, Django will raise an error. The request object is essential for building the full response and using context processors.