How Django processes a request (URL → View → Template) - Try It Yourself

How Django processes a request (URL → View → Template)

📖 Scenario: You are building a simple Django web app that shows a welcome message on the homepage. You want to understand how Django takes a web address (URL), finds the right code to run (view), and then shows a webpage (template) to the user.

🎯 Goal: Create a Django project with a URL pattern, a view function, and a template that work together to display the text "Welcome to Django!" on the homepage.

📋 What You'll Learn

Create a URL pattern for the homepage ('/')

Create a view function called home_view that returns a rendered template

Create a template file called home.html that displays the welcome message

Connect the URL pattern to the home_view function

💡 Why This Matters

🌍 Real World

Websites use this URL → View → Template flow to show pages to users based on the web address they visit.

💼 Career

Understanding this flow is essential for backend web developers working with Django to build dynamic websites.

1

Set up the URL pattern

In the urls.py file, import path from django.urls. Create a list called urlpatterns with one entry: use path to map the empty string '' (homepage) to a view function called home_view. Do not import or define home_view yet.

Django

from django.urls import path

# Define urlpatterns list with a path for '' mapped to home_view
# Your code here

Hint

Remember, urlpatterns is a list of path calls. The first argument is the URL pattern as a string, the second is the view function name.

2

Create the view function

In the views.py file, import render from django.shortcuts. Define a function called home_view that takes a request parameter. Inside the function, return the result of calling render with request, the template name 'home.html', and no context.

Django

from django.urls import path

urlpatterns = [
    path('', home_view),
]

# In views.py, import render and define home_view(request) that returns render(request, 'home.html')
# Your code here

Hint

The view function must accept request and return render(request, 'home.html').

3

Create the template file

Create a file named home.html inside a folder called templates. Inside home.html, write HTML code that displays the text Welcome to Django! inside an <h1> tag.

Django

from django.urls import path

urlpatterns = [
    path('', home_view),
]

from django.shortcuts import render

def home_view(request):
    return render(request, 'home.html')

Welcome to Django! -->
# Your code here

Hint

The template is a simple HTML file with an <h1> tag containing the welcome text.

4

Connect URL to view and run server

Make sure the home_view function is imported in urls.py from the views module. The urlpatterns list should map the empty string '' to home_view. This completes the connection from URL to view to template.

Django

from django.urls import path
from .views import home_view

urlpatterns = [
    path('', home_view),
]

# Your code here to import home_view and connect URL to view

Hint

Import home_view in urls.py using from .views import home_view.

Practice

1. In Django, what is the first step when a user visits a website URL?

easy

A. Django directly renders the template without processing.

B. Django matches the URL to a view using URL patterns.

C. Django sends data to the database.

D. Django executes JavaScript on the client side.

Solution

1. Step 1: Understand URL routing in Django

   Django uses URL patterns defined in urls.py to find which view should handle the request.

2. Step 2: Identify the first action on a request

   The first action is matching the URL to a view, not rendering or database access.

3. Final Answer:

   Django matches the URL to a view using URL patterns. -> Option B

4. Quick Check:

   URL routing = matching URL to view [OK]

Hint: Remember: URL first matches view, then view handles data [OK]

Common Mistakes:

• Thinking template renders before view runs
• Assuming database is accessed before URL matching
• Confusing client-side JavaScript with Django server process

2. Which of the following is the correct way to define a URL pattern in Django's urls.py?

easy

A. path('home/', views.home_view, name='home')

B. url('home/', views.home_view)

C. route('home/', views.home_view)

D. link('home/', views.home_view)

Solution

1. Step 1: Recall Django URL pattern syntax

   Django 3+ uses path() to define URL patterns, with URL string, view function, and optional name.

2. Step 2: Identify correct function name

   url() is deprecated, and route() or link() are invalid.

3. Final Answer:

   path('home/', views.home_view, name='home') -> Option A

4. Quick Check:

   Use path() for URL patterns [OK]

Hint: Use path() in urls.py, not url() or other names [OK]

Common Mistakes:

• Using deprecated url() instead of path()
• Using non-existent functions like route() or link()
• Omitting the view function argument

3. Given this view function, what will be the rendered output if the template displays {{ message }}?

def hello_view(request):
    context = {'message': 'Hello, Django!'}
    return render(request, 'hello.html', context)

medium

A. Hello, Django!

B. context

C. hello.html

D. request

Solution

1. Step 1: Understand context passing in Django views

   The view passes a dictionary with key 'message' and value 'Hello, Django!' to the template.

2. Step 2: Template renders variable from context

   The template uses {{ message }} to display the value 'Hello, Django!'.

3. Final Answer:

   Hello, Django! -> Option A

4. Quick Check:

   Template variable = context value [OK]

Hint: Template {{ var }} shows context['var'] value [OK]

Common Mistakes:

• Confusing template name with output
• Thinking context dictionary prints as string
• Assuming request object is shown in template

4. What is wrong with this Django view function?

def my_view(request):
    return render('my_template.html')

medium

A. The function name must be capitalized.

B. The template name should be a dictionary.

C. The view should return HttpResponseRedirect instead.

D. The render function is missing the request argument.

Solution

1. Step 1: Check render function signature

   render() requires at least two arguments: request and template name.

2. Step 2: Identify missing argument

   The code only passes the template name, missing the request argument.

3. Final Answer:

   The render function is missing the request argument. -> Option D

4. Quick Check:

   render(request, template) needs request first [OK]

Hint: render() always needs request as first argument [OK]

Common Mistakes:

• Forgetting to pass request to render()
• Thinking template name should be a dict
• Confusing render with redirect functions

5. You want to display a list of products on a page. Which sequence correctly describes how Django processes this request? A user visits /products/. The URL pattern matches products_view. The view fetches products from the database and passes them to products.html template. The template shows the product names in a list. Which is the correct order of steps Django follows internally?

hard

A. View fetches data -> URL matches -> Template renders -> Response sent

B. Template renders -> View fetches data -> URL matches -> Response sent

C. URL -> View fetches data -> Template renders with data -> Response sent

D. Response sent -> URL matches -> View fetches data -> Template renders

Solution

1. Step 1: URL matching

   Django first matches the incoming URL to the correct view function using URL patterns.

2. Step 2: View processes request

   The view fetches data (products) from the database and prepares context for the template.

3. Step 3: Template rendering and response

   The template uses the context to render HTML, which Django sends as the HTTP response.

4. Final Answer:

   URL -> View fetches data -> Template renders with data -> Response sent -> Option C

5. Quick Check:

   URL then view then template then response [OK]

Hint: Remember: URL matches first, then view, then template, then response [OK]

Common Mistakes:

• Thinking template renders before URL matching
• Mixing order of view and URL matching
• Assuming response sent before processing