This document explains the language syntax of the Django template system. If\nyou're looking for a more technical perspective on how it works and how to\nextend it, see The Django template language: for Python programmers.
\nDjango's template language is designed to strike a balance between power and\nease. It's designed to feel comfortable to those used to working with HTML. If\nyou have any exposure to other text-based template languages, such as Smarty\nor Jinja2, you should feel right at home with Django's templates.
\n\nA template is simply a text file. It can generate any text-based format (HTML,\nXML, CSV, etc.).
\nA template contains variables, which get replaced with values when the\ntemplate is evaluated, and tags, which control the logic of the template.
\nBelow is a minimal template that illustrates a few basics. Each element will be\nexplained later in this document.
\n{% extends "base_generic.html" %}\n\n{% block title %}{{ section.title }}{% endblock %}\n\n{% block content %}\n<h1>{{ section.title }}</h1>\n\n{% for story in story_list %}\n<h2>\n <a href="{{ story.get_absolute_url }}">\n {{ story.headline|upper }}\n </a>\n</h2>\n<p>{{ story.tease|truncatewords:"100" }}</p>\n{% endfor %}\n{% endblock %}\nVariables look like this: {{ variable }}. When the template engine\nencounters a variable, it evaluates that variable and replaces it with the\nresult. Variable names consist of any combination of alphanumeric characters\nand the underscore ("_"). The dot (".") also appears in variable\nsections, although that has a special meaning, as indicated below.\nImportantly, you cannot have spaces or punctuation characters in variable\nnames.
Use a dot (.) to access attributes of a variable.
In the above example, {{ section.title }} will be replaced with the\ntitle attribute of the section object.
If you use a variable that doesn't exist, the template system will insert the\nvalue of the string_if_invalid option, which is set to '' (the empty\nstring) by default.
Note that "bar" in a template expression like {{ foo.bar }} will be\ninterpreted as a literal string and not using the value of the variable "bar",\nif one exists in the template context.
You can modify variables for display by using filters.
\nFilters look like this: {{ name|lower }}. This displays the value of the\n{{ name }} variable after being filtered through the lower\nfilter, which converts text to lowercase. Use a pipe (|) to apply a filter.
Filters can be "chained." The output of one filter is applied to the next.\n{{ text|escape|linebreaks }} is a common idiom for escaping text contents,\nthen converting line breaks to <p> tags.
Some filters take arguments. A filter argument looks like this: {{\nbio|truncatewords:30 }}. This will display the first 30 words of the bio\nvariable.
Filter arguments that contain spaces must be quoted; for example, to join a\nlist with commas and spaces you'd use {{ list|join:", " }}.
Django provides about sixty built-in template filters. You can read all about\nthem in the built-in filter reference.\nTo give you a taste of what's available, here are some of the more commonly\nused template filters:
\ndefaultIf a variable is false or empty, use given default. Otherwise, use the\nvalue of the variable. For example:
\n{{ value|default:"nothing" }}\nIf value isn't provided or is empty, the above will display\n"nothing".
lengthReturns the length of the value. This works for both strings and lists.\nFor example:
\n{{ value|length }}\nIf value is ['a', 'b', 'c', 'd'], the output will be 4.
filesizeformatFormats the value like a "human-readable" file size (i.e. '13 KB',\n'4.1 MB', '102 bytes', etc.). For example:
{{ value|filesizeformat }}\nIf value is 123456789, the output would be 117.7 MB.
Again, these are just a few examples; see the built-in filter reference for the complete list.
\nYou can also create your own custom template filters; see\nCustom template tags and filters.
\n\nTo comment-out part of a line in a template, use the comment syntax: {# #}.
For example, this template would render as 'hello':
{# greeting #}hello\nA comment can contain any template code, invalid or not. For example:
\n{# {% if foo %}bar{% else %} #}\nThis syntax can only be used for single-line comments (no newlines are permitted\nbetween the {# and #} delimiters). If you need to comment out a\nmultiline portion of the template, see the comment tag.
The most powerful -- and thus the most complex -- part of Django's template\nengine is template inheritance. Template inheritance allows you to build a base\n"skeleton" template that contains all the common elements of your site and\ndefines blocks that child templates can override.
\nIt's easiest to understand template inheritance by starting with an example:
\n<!DOCTYPE html>\n<html lang="en">\n<head>\n <link rel="stylesheet" href="style.css" />\n <title>{% block title %}My amazing site{% endblock %}</title>\n</head>\n\n<body>\n <div id="sidebar">\n {% block sidebar %}\n <ul>\n <li><a href="/">Home</a></li>\n <li><a href="/blog/">Blog</a></li>\n </ul>\n {% endblock %}\n </div>\n\n <div id="content">\n {% block content %}{% endblock %}\n </div>\n</body>\n</html>\nThis template, which we'll call base.html, defines a simple HTML skeleton\ndocument that you might use for a simple two-column page. It's the job of\n"child" templates to fill the empty blocks with content.
In this example, the block tag defines three blocks that child\ntemplates can fill in. All the block tag does is to tell the template\nengine that a child template may override those portions of the template.
A child template might look like this:
\n{% extends "base.html" %}\n\n{% block title %}My amazing blog{% endblock %}\n\n{% block content %}\n{% for entry in blog_entries %}\n <h2>{{ entry.title }}</h2>\n <p>{{ entry.body }}</p>\n{% endfor %}\n{% endblock %}\nThe extends tag is the key here. It tells the template engine that\nthis template "extends" another template. When the template system evaluates\nthis template, first it locates the parent -- in this case, "base.html".
At that point, the template engine will notice the three block tags\nin base.html and replace those blocks with the contents of the child\ntemplate. Depending on the value of blog_entries, the output might look\nlike:
<!DOCTYPE html>\n<html lang="en">\n<head>\n <link rel="stylesheet" href="style.css" />\n <title>My amazing blog</title>\n</head>\n\n<body>\n <div id="sidebar">\n <ul>\n <li><a href="/">Home</a></li>\n <li><a href="/blog/">Blog</a></li>\n </ul>\n </div>\n\n <div id="content">\n <h2>Entry one</h2>\n <p>This is my first entry.</p>\n\n <h2>Entry two</h2>\n <p>This is my second entry.</p>\n </div>\n</body>\n</html>\nNote that since the child template didn't define the sidebar block, the\nvalue from the parent template is used instead. Content within a {% block %}\ntag in a parent template is always used as a fallback.
You can use as many levels of inheritance as needed. One common way of using\ninheritance is the following three-level approach:
\nCreate a base.html template that holds the main look-and-feel of your\nsite.
Create a base_SECTIONNAME.html template for each "section" of your\nsite. For example, base_news.html, base_sports.html. These\ntemplates all extend base.html and include section-specific\nstyles/design.
Create individual templates for each type of page, such as a news\narticle or blog entry. These templates extend the appropriate section\ntemplate.
This approach maximizes code reuse and makes it easy to add items to shared\ncontent areas, such as section-wide navigation.
\nHere are some tips for working with inheritance:
\nIf you use {% extends %} in a template, it must be the first template\ntag in that template. Template inheritance won't work, otherwise.
More {% block %} tags in your base templates are better. Remember,\nchild templates don't have to define all parent blocks, so you can fill\nin reasonable defaults in a number of blocks, then only define the ones\nyou need later. It's better to have more hooks than fewer hooks.
If you find yourself duplicating content in a number of templates, it\nprobably means you should move that content to a {% block %} in a\nparent template.
If you need to get the content of the block from the parent template,\nthe {{ block.super }} variable will do the trick. This is useful\nif you want to add to the contents of a parent block instead of\ncompletely overriding it. Data inserted using {{ block.super }} will\nnot be automatically escaped (see the next section), since it was\nalready escaped, if necessary, in the parent template.
For extra readability, you can optionally give a name to your\n{% endblock %} tag. For example:
{% block content %}\n...\n{% endblock content %}\nIn larger templates, this technique helps you see which {% block %}\ntags are being closed.
Finally, note that you can't define multiple block tags with the same\nname in the same template. This limitation exists because a block tag works in\n"both" directions. That is, a block tag doesn't just provide a hole to fill --\nit also defines the content that fills the hole in the parent. If there were\ntwo similarly-named block tags in a template, that template's parent\nwouldn't know which one of the blocks' content to use.
When generating HTML from templates, there's always a risk that a variable will\ninclude characters that affect the resulting HTML. For example, consider this\ntemplate fragment:
\nHello, {{ name }}\nAt first, this seems like a harmless way to display a user's name, but consider\nwhat would happen if the user entered their name as this:
\n<script>alert('hello')</script>\nWith this name value, the template would be rendered as:
\nHello, <script>alert('hello')</script>\n...which means the browser would pop-up a JavaScript alert box!
\nSimilarly, what if the name contained a '<' symbol, like this?
<b>username\nThat would result in a rendered template like this:
\nHello, <b>username\n...which, in turn, would result in the remainder of the Web page being bolded!
\nClearly, user-submitted data shouldn't be trusted blindly and inserted directly\ninto your Web pages, because a malicious user could use this kind of hole to\ndo potentially bad things. This type of security exploit is called a\nCross Site Scripting (XSS) attack.
\nTo avoid this problem, you have two options:
\nOne, you can make sure to run each untrusted variable through the\nescape filter (documented below), which converts potentially\nharmful HTML characters to unharmful ones. This was the default solution\nin Django for its first few years, but the problem is that it puts the\nonus on you, the developer / template author, to ensure you're escaping\neverything. It's easy to forget to escape data.
Two, you can take advantage of Django's automatic HTML escaping. The\nremainder of this section describes how auto-escaping works.
By default in Django, every template automatically escapes the output\nof every variable tag. Specifically, these five characters are\nescaped:
\n< is converted to <
> is converted to >
' (single quote) is converted to '
" (double quote) is converted to "
& is converted to &
Again, we stress that this behavior is on by default. If you're using Django's\ntemplate system, you're protected.
\nIf you don't want data to be auto-escaped, on a per-site, per-template level or\nper-variable level, you can turn it off in several ways.
\nWhy would you want to turn it off? Because sometimes, template variables\ncontain data that you intend to be rendered as raw HTML, in which case you\ndon't want their contents to be escaped. For example, you might store a blob of\nHTML in your database and want to embed that directly into your template. Or,\nyou might be using Django's template system to produce text that is not HTML\n-- like an email message, for instance.
\nTo disable auto-escaping for an individual variable, use the safe\nfilter:
This will be escaped: {{ data }}\nThis will not be escaped: {{ data|safe }}\nThink of safe as shorthand for safe from further escaping or can be\nsafely interpreted as HTML. In this example, if data contains '<b>',\nthe output will be:
This will be escaped: <b>\nThis will not be escaped: <b>\nTo control auto-escaping for a template, wrap the template (or just a\nparticular section of the template) in the autoescape tag, like so:
{% autoescape off %}\n Hello {{ name }}\n{% endautoescape %}\nThe autoescape tag takes either on or off as its argument. At\ntimes, you might want to force auto-escaping when it would otherwise be\ndisabled. Here is an example template:
Auto-escaping is on by default. Hello {{ name }}\n\n{% autoescape off %}\n This will not be auto-escaped: {{ data }}.\n\n Nor this: {{ other_data }}\n {% autoescape on %}\n Auto-escaping applies again: {{ name }}\n {% endautoescape %}\n{% endautoescape %}\nThe auto-escaping tag passes its effect onto templates that extend the\ncurrent one as well as templates included via the include tag,\njust like all block tags. For example:
base.html{% autoescape off %}\n<h1>{% block title %}{% endblock %}</h1>\n{% block content %}\n{% endblock %}\n{% endautoescape %}\nchild.html{% extends "base.html" %}\n{% block title %}This & that{% endblock %}\n{% block content %}{{ greeting }}{% endblock %}\nBecause auto-escaping is turned off in the base template, it will also be\nturned off in the child template, resulting in the following rendered\nHTML when the greeting variable contains the string <b>Hello!</b>:
<h1>This & that</h1>\n<b>Hello!</b>\nGenerally, template authors don't need to worry about auto-escaping very much.\nDevelopers on the Python side (people writing views and custom filters) need to\nthink about the cases in which data shouldn't be escaped, and mark data\nappropriately, so things Just Work in the template.
\nIf you're creating a template that might be used in situations where you're\nnot sure whether auto-escaping is enabled, then add an escape filter\nto any variable that needs escaping. When auto-escaping is on, there's no\ndanger of the escape filter double-escaping data -- the\nescape filter does not affect auto-escaped variables.
As we mentioned earlier, filter arguments can be strings:
\n{{ data|default:"This is a string literal." }}\nAll string literals are inserted without any automatic escaping into the\ntemplate -- they act as if they were all passed through the safe\nfilter. The reasoning behind this is that the template author is in control of\nwhat goes into the string literal, so they can make sure the text is correctly\nescaped when the template is written.
This means you would write
\n{{ data|default:"3 < 2" }}\n...rather than:
\n{{ data|default:"3 < 2" }} {# Bad! Don't do this. #}\nThis doesn't affect what happens to data coming from the variable itself.\nThe variable's contents are still automatically escaped, if necessary, because\nthey're beyond the control of the template author.
\nMost method calls attached to objects are also available from within templates.\nThis means that templates have access to much more than just class attributes\n(like field names) and variables passed in from views. For example, the Django\nORM provides the "entry_set" syntax for\nfinding a collection of objects related on a foreign key. Therefore, given\na model called "comment" with a foreign key relationship to a model called\n"task" you can loop through all comments attached to a given task like this:
\n{% for comment in task.comment_set.all %}\n {{ comment }}\n{% endfor %}\nSimilarly, QuerySets provide a count() method\nto count the number of objects they contain. Therefore, you can obtain a count\nof all comments related to the current task with:
{{ task.comment_set.all.count }}\nAnd of course you can easily access methods you've explicitly defined on your\nown models:
\nmodels.pyclass Task(models.Model):\n def foo(self):\n return "bar"\ntemplate.html{{ task.foo }}\nBecause Django intentionally limits the amount of logic processing available\nin the template language, it is not possible to pass arguments to method calls\naccessed from within templates. Data should be calculated in views, then passed\nto templates for display.
\nCertain applications provide custom tag and filter libraries. To access them in\na template, ensure the application is in INSTALLED_APPS (we'd add\n'django.contrib.humanize' for this example), and then use the load\ntag in a template:
{% load humanize %}\n\n{{ 45000|intcomma }}\nIn the above, the load tag loads the humanize tag library, which then\nmakes the intcomma filter available for use. If you've enabled\ndjango.contrib.admindocs, you can consult the documentation area in your\nadmin to find the list of custom libraries in your installation.
The load tag can take multiple library names, separated by spaces.\nExample:
{% load humanize i18n %}\nSee Custom template tags and filters for information on writing your own custom\ntemplate libraries.
\nWhen you load a custom tag or filter library, the tags/filters are only made\navailable to the current template -- not any parent or child templates along\nthe template-inheritance path.
\nFor example, if a template foo.html has {% load humanize %}, a child\ntemplate (e.g., one that has {% extends "foo.html" %}) will not have\naccess to the humanize template tags and filters. The child template is\nresponsible for its own {% load humanize %}.
This is a feature for the sake of maintainability and sanity.
\n\n