Templates

Reviewed & published by Brayan K

A Django template is an HTML file containing the Django Template Language — placeholders and tags that Django fills in with data from your views to produce the final page sent to the browser.

Part of the free Django course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

In this lesson you'll learn how to render a template from a view, pass data through a context dictionary, output variables, drive logic with template tags, and reshape values with filters.

What You'll Learn in This Lesson

• How render() turns a template plus context into a response
• Passing data from a view using a context dictionary
• Outputting values with double-brace variable syntax
• Looping and branching with the for and if template tags
• Transforming values with filters like upper, date, and length
• How to fix TemplateDoesNotExist and missing endfor errors

1 Rendering a Template

A view's job is to gather data and hand it to a template. The render() shortcut takes the request, the template's filename, and a context dictionary, then returns a finished HttpResponse with the rendered HTML.

The keys of the context dictionary become the variable names you can use inside the template. So if your context is {'title': 'Welcome'}, the template can output that value with {{ title }}.

# blog/views.py
from django.shortcuts import render

def home(request):
    context = {
        "title": "Welcome to my blog",
        "author": "Alice",
    }
    return render(request, "index.html", context)

And the matching template file might look like this:

<!-- templates/index.html -->
<h1>{{ title }}</h1>
<p>Posted by {{ author }}</p>

# Django's render() substitutes context values into placeholders.
# We can simulate that substitution with str.format so it runs here,
# while the real Django version is shown in the lesson above.

template = "<h1>{title}</h1>\n<p>Posted by {author}</p>"

context = {
    "title": "Welcome to my blog",
    "author": "Alice",
}

# Django does this fill-in step for you when you call render().
rendered_html = template.format(**context)
print(rendered_html)

# In real Django the view would simply return:
#   return render(request, "index.html", context)

# ✅ Expected output:
# <h1>Welcome to my blog</h1>
# <p>Posted by Alice</p>

2 Variables and Template Tags

The Django Template Language has two main building blocks. Variables use the double-brace syntax to print a value: {{ user.name }}. You can even reach into attributes and dictionary keys with a dot.

Tags use the brace-percent syntax to run logic. The {% for %} tag loops over a list and the {% if %} tag branches. Block tags must be closed: a for-loop ends with {% endfor %} and an if ends with {% endif %}.

<!-- templates/posts.html -->
<h1>{{ heading }}</h1>

{% if posts %}
  <ul>
    {% for post in posts %}
      <li>{{ post.title }} by {{ post.author }}</li>
    {% endfor %}
  </ul>
{% else %}
  <p>No posts yet.</p>
{% endif %}

• Variable — {{ value }} outputs data into the page.
• For tag — {% for x in items %} ... {% endfor %} repeats a block.
• If tag — {% if condition %} ... {% endif %} shows a block conditionally.

# Simulating a {% for %} loop and {{ variable }} output in Python.
# The template engine walks the list and prints one <li> per item.

heading = "Latest Posts"
posts = [
    {"title": "Django Basics", "author": "Alice"},
    {"title": "Templates 101", "author": "Bob"},
]

# Build the HTML the way the {% for %} tag would
print("<h1>" + heading + "</h1>")
if posts:
    print("<ul>")
    for post in posts:
        # {{ post.title }} and {{ post.author }} become these values
        print("  <li>" + post["title"] + " by " + post["author"] + "</li>")
    print("</ul>")
else:
    print("<p>No posts yet.</p>")

# ✅ Expected output:
# <h1>Latest Posts</h1>
# <ul>
#   <li>Django Basics by Alice</li>
#   <li>Templates 101 by Bob</li>
# </ul>

3 Template Filters

A filter transforms a variable just before it is displayed. You apply one with a pipe character after the variable name. Some filters take an argument after a colon, and you can chain several together.

<!-- templates/profile.html -->
<p>{{ name|upper }}</p>                  <!-- ALICE -->
<p>{{ joined|date:"F j, Y" }}</p>        <!-- June 17, 2026 -->
<p>{{ tags|length }} tags</p>            <!-- 3 tags -->
<p>{{ bio|truncatewords:5 }}</p>         <!-- first 5 words... -->
<p>{{ nickname|default:"Anonymous" }}</p><!-- fallback value -->

• upper — converts text to uppercase.
• date — formats a date using a format string.
• length — returns the number of items in a list or characters in a string.
• default — supplies a fallback when the value is empty.
• truncatewords — shortens text to the given number of words.

# Filters transform a value before it is shown. Here are plain-Python
# stand-ins for the upper, length, default and truncatewords filters.

def f_upper(value):
    return value.upper()

def f_length(value):
    return len(value)

def f_default(value, fallback):
    return value if value else fallback

def f_truncatewords(value, count):
    words = value.split()
    if len(words) <= count:
        return value
    return " ".join(words[:count]) + "..."

name = "alice"
tags = ["python", "django", "web"]
nickname = ""
bio = "Learning Django one template at a time today"

print(f_upper(name))                       # {{ name|upper }}
print(f_length(tags), "tags")              # {{ tags|length }}
print(f_default(nickname, "Anonymous"))    # {{ nickname|default:"Anonymous" }}
print(f_truncatewords(bio, 5))             # {{ bio|truncatewords:5 }}

# ✅ Expected output:
# ALICE
# 3 tags
# Anonymous
# Learning Django one template at...

🎯 Your Turn: Fill the Context

Fill in the blank so the context dictionary has a username key that the template variable {{ username }} would print as jordan.

# 🎯 YOUR TURN: replace ___ with the key name "username"

template = "Hello, {username}!"

context = {
    "___": "jordan",
}

print(template.format(**context))

# EXPECTED OUTPUT:
# Hello, jordan!

Common Errors (And How to Fix Them)

Django cannot find the file because the templates directory is not configured or the name is misspelled.

✅ Fix: set APP_DIRS to True or add your folder to DIRS in the TEMPLATES setting, and confirm the filename matches.

❌ Invalid block tag: 'endblock', expected 'endfor'

You opened a {% for %} or {% if %} but never closed it.

✅ Fix: every block tag needs its closing tag — add {% endfor %} or {% endif %}.

❌ Could not parse the remainder of a Python expression

You wrote raw Python (like a function call) where a template tag is needed.

✅ Fix: use a tag such as {% if x %} instead of a Python expression — the template language is not Python.

📋 Quick Reference

🏆 Mini Challenge: Render a Product List

Build the HTML a template would produce for a list of products, applying an uppercase transform to each name like the upper filter would.

❓ Frequently Asked Questions

Lesson complete — your views can now render real pages!

You now know how render() combines a template with a context dictionary, how to output variables with double braces, how to drive logic with the for and if tags, and how to reshape values with filters like upper, date, length, default, and truncatewords.

Practice quiz

Continue this course

• Previous: Views & URLs
• Next: Static Files — Serve CSS, JavaScript, and images with Django's staticfiles system
• Quick reference: Django cheat sheet › Templates

Frequently asked questions

What is a Django template?

A Django template is an HTML file containing the Django Template Language — special placeholders and tags that Django fills in with data from your view. When a request comes in, the view gathers data into a context dictionary, Django renders the template by substituting that data into the placeholders, and the finished HTML is sent to the browser. Templates let you keep presentation (HTML) separate from logic (Python).

What is the difference between a variable and a tag in a template?

A variable, written with double braces, outputs a value into the page — for example outputting a user's name. A tag, written with brace-percent syntax, performs logic such as looping over a list, branching with if, or extending a base layout. Variables produce text; tags control the structure and flow of the template.

What are template filters?

Filters transform the value of a variable just before it is displayed. You apply a filter with a pipe character after the variable name, like name then pipe then upper to uppercase it. Filters can format dates, change case, truncate long text, count items, and supply default values. You can chain multiple filters and some accept an argument after a colon.

Why do I get TemplateDoesNotExist?

Django could not find the template file you named in render(). This usually means the templates directory is not registered in the TEMPLATES setting's DIRS list, the file is in the wrong folder, or the name is misspelled. Make sure APP_DIRS is True or that DIRS points at your templates folder, and that the filename in render() exactly matches the file on disk.