内置模板标签和过滤器¶

本文档描述的是django 内置模板标签和过滤器. 我们推荐尽可能使用自动化文档，同时也可以自行编辑任何已安装的自定义标签或过滤器的文档。

内置标签引用¶

`autoescape`¶

控制自动转义是否可用. 这种标签带有任何 on 或 off 作为参数的话，他将决定转义块内效果。该标签会以一个endautoescape作为结束标签.

当自动转义生效时，所有变量内容会被转义成HTML输出（在所有过滤器生效后）这等同与手动将escape筛选器应用于每个变量。

唯一一个例外是，变量或者通过渲染变量的代码，或者因为它已经应用了 safe或escape过滤器，已经被标记为“safe”。

例如：

{% autoescape on %}
    {{ body }}
{% endautoescape %}

`block`¶

block标签可以被子模板覆盖. 查看 Template inheritance 可以获得更多信息.

`comment`¶

在 {% comment %} 和 {% endcomment %}，之间的内容会被忽略，作为注释。在第一个标签可以插入一个可选的记录。比如，当要注释掉一些代码时，可以用此来记录代码被注释掉的原因。

例如：

<p>Rendered text with {{ pub_date|date:"c" }}</p>
{% comment "Optional note" %}
    <p>Commented out text with {{ create_date|date:"c" }}</p>
{% endcomment %}

comment标签不能嵌套使用。

`csrf_token`¶

这个标签用于跨站请求伪造保护, 具体可以参考Cross Site Request Forgeries中的描述。

`cycle`¶

每当这个标签被访问,则传出一个它的可迭代参数的元素。第一次访问返回第一个元素,第二次访问返回第二个参数,以此类推. 一旦所有的变量都被访问过了，就会回到最开始的地方，重复下去

这个标签在循环中特别有用:

{% for o in some_list %}
    <tr class="{% cycle 'row1' 'row2' %}">
        ...
    </tr>
{% endfor %}

第一次迭代产生的HTML引用了 row1类，第二次则是row2类，第三次又是row1 类，如此类推。

你也可以使用变量，例如，如果你有两个模版变量, rowvalue1和rowvalue2, 你可以让他们的值像这样替换:

{% for o in some_list %}
    <tr class="{% cycle rowvalue1 rowvalue2 %}">
        ...
    </tr>
{% endfor %}

被包含在cycle中的变量将会被转义。你可以禁止自动转义:

{% for o in some_list %}
    <tr class="{% autoescape off %}{% cycle rowvalue1 rowvalue2 %}{% endautoescape %}">
        ...
    </tr>
{% endfor %}

你能混合使用变量和字符串：

{% for o in some_list %}
    <tr class="{% cycle 'row1' rowvalue2 'row3' %}">
        ...
    </tr>
{% endfor %}

在某些情况下，您可能需要连续引用一个当前循环的值，而不前进到下一个循环值。要达到这个目的，只需使用“as”来给{％ cycle ％}一个别名，就像这样：

{% cycle 'row1' 'row2' as rowcolors %}

从那时起（设置别名后），你可以通过将别名作为一个模板变量进行引用，从而随意在模板中插入当前循环的值。如果要将循环值移动到独立于原始cycle标记的下一个值，可以使用另一个cycle标记并指定变量的名称。所以，下面的模板：

<tr>
    <td class="{% cycle 'row1' 'row2' as rowcolors %}">...</td>
    <td class="{{ rowcolors }}">...</td>
</tr>
<tr>
    <td class="{% cycle rowcolors %}">...</td>
    <td class="{{ rowcolors }}">...</td>
</tr>

将输出：

<tr>
    <td class="row1">...</td>
    <td class="row1">...</td>
</tr>
<tr>
    <td class="row2">...</td>
    <td class="row2">...</td>
</tr>

cycle 标签中，通过空格分割，你可以使用任意数量的值。被包含在单引号 (')或者双引号 (") 中的值被认为是可迭代字符串，相反，没有被引号包围的值被当作模版变量。

默认情况下，当你在cycle标签中使用as 关键字时，关于{% cycle %}的使用，会启动cycle并且直接产生第一个值。如果你想要在嵌套循环中或者included模版中使用这个值，那么将会遇到困难。如果你只是想要声明cycle，但是不产生第一个值，你可以添加一个silent关键字来作为cycle标签的最后一个关键字。像这样：

{% for obj in some_list %}
    {% cycle 'row1' 'row2' as rowcolors silent %}
    <tr class="{{ rowcolors }}">{% include "subtemplate.html" %}</tr>
{% endfor %}

这将输出row1元素的列表，其中class在<tr>和row2之间交替。子模板将在其上下文中访问rowcolors，并且该值将匹配包围它的<tr>的类。如果省略row2关键字，则row1和silent将作为正常文本发出，<tr>

当在循环定义上使用silent关键字时，静默将自动应用于该特定周期标记的所有后续使用。 The following template would output nothing, even though the second call to {% cycle %} doesn’t specify silent:

{% cycle 'row1' 'row2' as rowcolors silent %}
{% cycle rowcolors %}

您可以使用resetcycle标签制作{％循环％}标签从下一次遇到的第一个值重新启动。

`debug`¶

输出整个调试信息，包括当前上下文和导入的模块。

`extends`¶

表示当前模板继承自一个父模板

这个标签可以有两种用法:

{% extends "base.html" %} (要有引号).继承名为"base.html"的父模板
{％延伸变量％}使用variable 如果变量被计算成一个字符串，Django将会把它看成是父模版的名字。如果变量被计算到一个Template对象，Django将会使用那个对象作为一个父模版。

查看 Template inheritance 可以获得更多信息.

通常模板名称是相对于模板加载器的根目录。字符串参数也可以是以./或../开头的相对路径。例如，假设以下目录结构：

dir1/
    template.html
    base2.html
    my/
        base3.html
base1.html

在template.html中，以下路径将有效：

{% extends "./base2.html" %}
{% extends "../base1.html" %}
{% extends "./my/base3.html" %}

Django中的新功能1.10：

添加了使用相对路径的能力。

`filter`¶

通过一个或多个过滤器对内容过滤。作为灵活可变的语法，多个过滤器被管道符号相连接，且过滤器可以有参数。

注意块中所有的内容都应该包括在endfilter 和filter 标签中。

例如：

{% filter force_escape|lower %}
    This text will be HTML-escaped, and will appear in all lowercase.
{% endfilter %}

注

escape和safe过滤器不是可接受的参数。而应使用autoescape标记来管理模板代码块的自动转义。

`firstof`¶

输出第一个不为False参数。如果传入的所有变量都为False，就什么也不输出。

例如：

{% firstof var1 var2 var3 %}

它等价于：

{% if var1 %}
    {{ var1 }}
{% elif var2 %}
    {{ var2 }}
{% elif var3 %}
    {{ var3 }}
{% endif %}

当然你也可以用一个默认字符串作为输出以防传入的所有变量都是False：

{% firstof var1 var2 var3 "fallback value" %}

标签auto-escapes是开启的，你可以禁止自动转义:

{% autoescape off %}
    {% firstof var1 var2 var3 "<strong>fallback value</strong>" %}
{% endautoescape %}

如果只想要部分变量被规避，可以这样使用：

{% firstof var1 var2|safe var3 "<strong>fallback value</strong>"|safe %}

You can use the syntax {% firstof var1 var2 var3 as value %} to store the output inside a variable.

`for`¶

循环组中的每一个项目，并让这些项目在上下文可用。举个例子，展示athlete_list中的每个成员：

<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% endfor %}
</ul>

可以利用{% for obj in list reversed %}反向完成循环。

如果你需要循环一个包含列表的列表，可以通过拆分每一个二级列表为一个独立变量来达到目的。举个例子，如果你的内容包括一个叫做points的(x,y) 列表，你可以像以下例子一样输出points列表：

{% for x, y in points %}
    There is a point at {{ x }},{{ y }}
{% endfor %}

如果你想访问一个字典中的项目，这个方法同样有用。举个例子：如果你的内容包含一个叫做data的字典，下面的方式可以输出这个字典的键和值：

{% for key, value in data.items %}
    {{ key }}: {{ value }}
{% endfor %}

请记住，对于点运算符，字典键查找优先于方法查找。 Therefore if the data dictionary contains a key named 'items', data.items will return data['items'] instead of data.items(). 如果要在模板中使用这些方法（items，values，keys等），请避免添加名为字典方法的键。有关模板变量的documentation of template variables

The current iteration of the loop (1-indexed)

变量	描述
`forloop.counter`	循环的当前迭代（1索引）
`forloop.counter0`	循环的当前迭代（0索引）
`forloop.revcounter`	循环结束的迭代次数（1索引）
`forloop.revcounter0`	循环结束的迭代次数（0索引）
`forloop.first`	如果这是第一次通过循环，则为真
`forloop.last`	如果这是最后一次循环，则为真
`forloop.parentloop`	对于嵌套循环，这是围绕当前循环的循环

`for` ... `empty` ¶

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。

<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% empty %}
    <li>Sorry, no athletes in this list.</li>
{% endfor %}
</ul>

它和下面的例子作用相等，但是更简洁、更清晰甚至可能运行起来更快：

<ul>
  {% if athlete_list %}
    {% for athlete in athlete_list %}
      <li>{{ athlete.name }}</li>
    {% endfor %}
  {% else %}
    <li>Sorry, no athletes in this list.</li>
  {% endif %}
</ul>

`if`¶

{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），这个内容块会输出：

{% if athlete_list %}
    Number of athletes: {{ athlete_list|length }}
{% elif athlete_in_locker_room_list %}
    Athletes should be out of the locker room soon!
{% else %}
    No athletes.
{% endif %}

上述例子中，如果athlete_list不为空，就会通过使用{{ athlete_list|length }}过滤器展示出athletes的数量。

正如你所见，if标签之后可以带有一个或者多个{% elif %} 从句，也可以带有一个{% else %}从句以便在之前的所有条件不成立的情况下完成执行。这些从句都是可选的。

布尔运算符¶

if标签可以使用not，and或or来测试多个变量或取消给定变量：

{% if athlete_list and coach_list %}
    Both athletes and coaches are available.
{% endif %}

{% if not athlete_list %}
    There are no athletes.
{% endif %}

{% if athlete_list or coach_list %}
    There are some athletes or some coaches.
{% endif %}

{% if not athlete_list or coach_list %}
    There are no athletes or there are some coaches.
{% endif %}

{% if athlete_list and not coach_list %}
    There are some athletes and absolutely no coaches.
{% endif %}

允许同时使用and和or子句，and的优先级高于or ：

{% if athlete_list and coach_list or cheerleader_list %}

将解释如下：

if (athlete_list and coach_list) or cheerleader_list

在if标记中使用实际括号是无效的语法。如果您需要它们指示优先级，则应使用嵌套的if标记。

if tags may also use the operators ==, !=, <, >, <=, >=, in, not in, is, and is not which work as follows:

`==` operator ¶

相等。例如：

{% if somevar == "x" %}
  This appears if variable somevar equals the string "x"
{% endif %}

`!=` operator ¶

不相等。例如：

{% if somevar != "x" %}
  This appears if variable somevar does not equal the string "x",
  or if somevar is not found in the context
{% endif %}

`<`操作符¶

小于。例如：

{% if somevar < 100 %}
  This appears if variable somevar is less than 100.
{% endif %}

`>` operator ¶

大于。例如：

{% if somevar > 0 %}
  This appears if variable somevar is greater than 0.
{% endif %}

`<=` operator¶

小于或等于。例如：

{% if somevar <= 100 %}
  This appears if variable somevar is less than 100 or equal to 100.
{% endif %}

`>=` operator ¶

大于或等于。例如：

{% if somevar >= 1 %}
  This appears if variable somevar is greater than 1 or equal to 1.
{% endif %}

`in`操作符¶

包含在内。许多Python容器支持此运算符，以测试给定值是否在容器中。以下是中的x 的一些示例将被解释：

{% if "bc" in "abcdef" %}
  This appears since "bc" is a substring of "abcdef"
{% endif %}

{% if "hello" in greetings %}
  If greetings is a list or set, one element of which is the string
  "hello", this will appear.
{% endif %}

{% if user in users %}
  If users is a QuerySet, this will appear if user is an
  instance that belongs to the QuerySet.
{% endif %}

`not in`操作符¶

不包含在内。这是in运算符的否定操作。

`is` operator ¶

Django中的新功能1.10。

对象身份。测试两个值是否相同。例如：

{% if somevar is True %}
  This appears if and only if somevar is True.
{% endif %}

{% if somevar is None %}
  This appears if somevar is None, or if somevar is not found in the context.
{% endif %}

`is not`操作符¶

Django中的新功能1.10。

否定对象身份测试两个值是否不一样。这是is运算符的否定。例如：

{% if somevar is not True %}
  This appears if somevar is not True, or if somevar is not found in the
  context.
{% endif %}

{% if somevar is not None %}
  This appears if and only if somevar is not None.
{% endif %}

过滤器¶ T0>

你也可以在 if表达式中使用过滤器。像这样：

{% if messages|length >= 100 %}
   You have lots of messages today!
{% endif %}

复合表达式¶

所有上述操作符可以组合以形成复杂表达式。对于这样的表达式，重要的是要知道在表达式求值时如何对运算符进行分组 - 即优先级规则。操作符的优先级从低至高如下：

or
and
not
in
==，!=，<，>，<= ，>=

（这完全依据Python）。所以，例如，下面的复杂if标签：

{% if a == b or c == d and e %}

...将被解释为：

(a == b) or ((c == d) and e)

如果你想要不同的优先级，那么你需要使用嵌套的if 标签。有时，为了清楚起见，更好的是为了那些不知道优先规则的人。

比较运算符不能像Python或数学符号中那样“链接”。例如，不能使用：

{% if a > b > c %}  (WRONG)

你应该使用：

{% if a > b and b > c %}

`ifequal`和`ifnotequal` ¶

{％ ifequal a b ％} ... {％ endifequal ％} 是一种过时的写作方式 {％ if a == b ％} ... {％万一％}. 同样， {％ ifnotequal a b ％} ... {％ endifnotequal ％} 被替代 {％ if a ！= b ％} ... {％万一％}. ifequal和ifnotequal标签将在以后的版本中弃用。

`ifchanged`¶

检查一个值是否在上一次的迭代中改变。

{% ifchanged %} 块标签用在循环里。它可能有两个用处：

检查它已经渲染过的内容中的先前状态。并且只会显示发生改变的内容。例如，以下的代码是输出days的列表项，不过它只会输出被修改过月份的项:

<h1>Archive for {{ year }}</h1>

{% for date in days %}
    {% ifchanged %}<h3>{{ date|date:"F" }}</h3>{% endifchanged %}
    <a href="{{ date|date:"M/d"|lower }}/">{{ date|date:"j" }}</a>
{% endfor %}

如果标签内被给予多个值时,则会比较每一个值是否与上一次不同。例如，以下显示每次更改时的日期，如果小时或日期已更改，则显示小时：

{% for date in days %}
    {% ifchanged date.date %} {{ date.date }} {% endifchanged %}
    {% ifchanged date.hour date.date %}
        {{ date.hour }}
    {% endifchanged %}
{% endfor %}

ifchanged标记也可以采用可选的{％ else ％} 将显示如果值没有改变：

{% for match in matches %}
    <div style="background-color:
        {% ifchanged match.ballot_id %}
            {% cycle "red" "blue" %}
        {% else ％}
            gray
        {% endifchanged ％}
    ">{{ match }}</div>
{% endfor %}

`include`¶

加载模板并以标签内的参数渲染。这是一种可以引入别的模板的方法。

模板名可以是变量或者是硬编码的字符串，可以用单引号也可以是双引号.

下面这个示例包括模板"foo/bar.html"的内容：

{% include "foo/bar.html" %}

通常模板名称是相对于模板加载器的根目录。字符串参数也可以是以./或../开头的相对路径，如extends标签中所述。

Django中的新功能1.10：

添加了使用相对路径的能力。

此示例包括其名称包含在变量template_name中的模板的内容：

{% include template_name %}

变量也可以是任何实现了render() 方法接口的对象，这个对象要可以接收上下文（context）。这就允许你在context中引用一个已经被编译过的Template。

被包含的模板在包含它的模板的上下文中渲染。下面这个示例生成输出“Hello, John!”：

上下文：变量greeting设置为"John"，变量person设置为"Hello"。
模板：
```
{% include "name_snippet.html" %}
```

name_snippet.html模板：

{{ greeting }}, {{ person|default:"friend" }}!

你可以使用关键字参数将额外的上下文传递到模板：

{% include "name_snippet.html" with person="Jane" greeting="Hello" %}

如果要仅使用提供的变量（或根本不使用变量）来渲染上下文，请使用only选项。所包含的模板没有其他变量可用：

{% include "name_snippet.html" with greeting="Hi" only %}

如果包含的模板在渲染时导致异常（包括缺少或具有语法错误），行为会因template engine's而异。 debug选项（如果未设置，此选项默认为DEBUG的值）。当调试模式打开时，将出现TemplateDoesNotExist或TemplateSyntaxError之类的异常。当调试模式关闭时，{％包括％}向django.template记录器，除了在渲染所包含的模板并返回一个空字符串时发生的异常。

自1.11版以来已弃用渲染{％包含％}模板标记的沉默异常已弃用。在Django 2.1中，将会提出异常。

注

include 标签应该被理解为是一种"将子模版渲染并嵌入HTML中"的变种方法,而不是认为是"解析子模版并在被父模版包含的情况下展现其被父模版定义的内容". 这意味着在不同的被包含的子模版之间并不共享父模版的状态,每一个子包含都是完全独立的渲染过程.

Block模块在被包含之前就已经被执行. 这意味着模版在被包含之前就已经从另一个block扩展并 已经被执行并完成渲染 - 没有block模块会被include引入并执行,即使父模版中的扩展模版.

`load`¶

加载自定义模板标签集。

举个例子, 下面这模板将会从package包中载入所有otherlibrary 和somelibrary 中已经注册的标签和过滤器:

{% load somelibrary package.otherlibrary %}

你还可以使用from参数从库中选择性加载单个过滤器或标记。在下面这个示例中，名为somelibrary和bar的模板标签/过滤器将从foo加载：

{% load foo bar from somelibrary %}

有关详细信息，请参阅Custom tag and filter libraries。

`lorem`¶

展示随机的“lorem ipsum”拉丁文本. 这个标签是用来在模版中提供文字样本以供测试用的.

用法：

{% lorem [count] [method] [random] %}

可以使用零个，一个，两个或三个参数使用{％ lorem ％} 。这些参数是：

论据	描述
`计数`	一个数字（或变量），其中包含要生成的段落或字数（默认值为1）。
`方法`	Either `w` for words, `p` for HTML paragraphs or `b` for plain-text paragraph blocks (default is `b`).
`random`	如果给出的话，`random`这个词在生成文本时不会使用公共段落（“Lorem ipsum dolor sit amet ...”）。

例子：

{％ lorem ％}将输出常见的“lorem ipsum”段落。
{％ lorem 3 p ％}输出常用的“lorem ipsum”段落和两个随机段落，每段包裹在HTML 标签中。
{％ lorem 2 w 随机％} / t6>将输出两个随机拉丁字。

`now`¶

显示最近的日期或事件,可以通过给定的字符串格式显示。此类字符串可以包含格式说明符字符，如date过滤器部分中所述。

例如：

It is {% now "jS F Y H:i" %}

注意！，如果你想要使用“raw”值，你能够反斜杠转义一个格式化字符串。在这个例子中，“o”和“f”都是反斜杠转义，因为如果不这样，会分别显示年和时间：

It is the {% now "jS \o\f F" %}

这将显示为“这是9月4日”。

注

传递的格式也可以是预定义的DATE_FORMAT，DATETIME_FORMAT，SHORT_DATE_FORMAT或SHORT_DATETIME_FORMAT之一。预定义的格式可能会因当前语言环境和Format localization的启用而有所不同，例如：

It is {% now "SHORT_DATETIME_FORMAT" %}

您也可以使用语法{％ now “Y” as current_year ％}将输出（作为字符串）存储在变量中。 This is useful if you want to use {% now %} inside a template tag like blocktrans for example:

{% now "Y" as current_year %}
{% blocktrans %}Copyright {{ current_year }}{% endblocktrans %}

`regroup`¶

用相似对象间共有的属性重组列表.

This complex tag is best illustrated by way of an example: say that cities is a list of cities represented by dictionaries containing "name", "population", and "country" keys:

cities = [
    {'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},
    {'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},
    {'name': 'New York', 'population': '20,000,000', 'country': 'USA'},
    {'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},
    {'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},
]

...并且您想显示按国家/地区排序的分层列表，如下所示：

印度
- 孟买：19,000,000
- 加尔各答：15,000,000
美国
- 纽约：20,000,000
- 芝加哥：7,000,000
日本
- 东京：33,000,000

你可以使用{% regroup %}标签来给每个国家的城市分组。以下模板代码片段将实现这一点：

{% regroup cities by country as country_list %}

<ul>
{% for country in country_list %}
    <li>{{ country.grouper }}
    <ul>
        {% for city in country.list %}
          <li>{{ city.name }}: {{ city.population }}</li>
        {% endfor %}
    </ul>
    </li>
{% endfor %}
</ul>

让我们来看看这个例子。 {% regroup %}有三个参数：你想要重组的列表, 被分组的属性, 还有结果列表的名字. 在这里，我们通过country_list属性重新分组country列表，并调用结果cities。

{％ regroup ％}产生一个清单（在本例中为country_list的组对象。组对象是具有两个字段的namedtuple()的实例：

grouper - 按分组的项目（例如，字符串“India”或“Japan”）。
list - 此群组中所有项目的列表（例如，所有城市的列表，其中country ='India'）。

在Django更改1.11：

组对象已从字典更改为namedtuple()。

Because {% regroup %} produces namedtuple() objects, you can also write the previous example as:

{% regroup cities by country as country_list %}

<ul>
{% for country, local_cities in country_list %}
    <li>{{ country }}
    <ul>
        {% for city in local_cities %}
          <li>{{ city.name }}: {{ city.population }}</li>
        {% endfor %}
    </ul>
    </li>
{% endfor %}
</ul>

请注意，{％ regroup ％}不会对其输入进行排序！我们的例子依赖于事实：cities列表首先由country排序。如果country列表不通过cities对其成员进行排序，则重新分组将天真显示单个国家/地区的多个组。例如，假设cities列表已设置为此（请注意，国家/地区未分组在一起）：

cities = [
    {'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},
    {'name': 'New York', 'population': '20,000,000', 'country': 'USA'},
    {'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},
    {'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},
    {'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},
]

对于cities的输入，示例{％ regroup ％}以上将导致以下输出：

印度
- 孟买：19,000,000
美国
- 纽约：20,000,000
印度
- 加尔各答：15,000,000
美国
- 芝加哥：7,000,000
日本
- 东京：33,000,000

这个问题的最简单的解决方案是确保在你的视图代码中，数据是根据你想要显示的顺序排序。

另一个解决方案是使用dictsort过滤器对模板中的数据进行排序，如果您的数据在字典列表中：

{% regroup cities|dictsort:"country" by country as country_list %}

分组其他属性¶

一个有效的模版查找是一个regroup标签的合法的分组属性。包括方法，属性，字典健和列表项。例如，如果“country”字段是具有属性“description”的类的外键，则可以使用：

{% regroup cities by country.description as country_list %}

或者，如果choices是具有choices的字段，则它将具有作为属性的get_FOO_display()方法，显示字符串而不是country键：

{% regroup cities by get_country_display as country_list %}

{{ country.grouper }}现在会显示choices

`resetcycle`¶

Django中的新功能1.11。

重置先前的循环，以便在下一次遇到时从其第一个项目重新启动。没有参数， {% resetcycle %} 会重置模板中定义的最后一个{% cycle %}

用法示例：

{% for coach in coach_list %}
    <h1>{{ coach.name }}</h1>
    {% for athlete in coach.athlete_set.all %}
        <p class="{% cycle 'odd' 'even' %}">{{ athlete.name }}</p>
    {% endfor %}
    {% resetcycle %}
{% endfor %}

这个示例将返回下面的HTML：

<h1>José Mourinho</h1>
<p class="odd">Thibaut Courtois</p>
<p class="even">John Terry</p>
<p class="odd">Eden Hazard</p>

<h1>Carlo Ancelotti</h1>
<p class="odd">Manuel Neuer</p>
<p class="even">Thomas Müller</p>

注意第一个块以class="odd"结束，新的以class="odd"开头。没有{％ resetcycle ％}标签，第二个块将以class="even"

您还可以重置命名循环标签：

{% for item in list %}
    <p class="{% cycle 'odd' 'even' as stripe %} {% cycle 'major' 'minor' 'minor' 'minor' 'minor' as tick %}">
        {{ item.data }}
    </p>
    {% ifchanged item.category %}
        <h1>{{ item.category }}</h1>
        {% if not forloop.first %}{% resetcycle tick %}{% endif %}
    {% endifchanged %}
{% endfor %}

在这个例子中，我们有交替的奇数/偶数行和第五行的“主要”行。当类别更改时，只有五行周期被重置。

`spaceless`¶

删除HTML标签之间的空白格. 包括制表符和换行.

用法示例：

{% spaceless %}
    <p>
        <a href="foo/">Foo</a>
    </p>
{% endspaceless %}

这个示例将返回下面的HTML：

<p><a href="foo/">Foo</a></p>

仅删除 tags 之间的空格 – 而不是标签和文本之间的。在此示例中，Hello周围的空格不会被删除：

{% spaceless %}
    <strong>
        Hello
    </strong>
{% endspaceless %}

`templatetag`¶

输出用于构成模板标记的语法字符之一。

由于模板系统没有“转义”的概念，为了显示模板标签中使用的一个位，必须使用{％ templatetag ％}标记。

参数指定要输出哪个模板位：

论据	输出
`openblock`	`{％`
`closeblock`	`％}`
`openvariable`	`{{`
`closevariable`	`}}`
`openbrace`	`{`
`closebrace`	`}`
`opencomment`	`{＃`
`closecomment`	`＃}`

例如：

{% templatetag openblock %} url 'entry_list' {% templatetag closeblock %}

`url`¶

返回与给定视图和可选参数匹配的绝对路径引用（不带域名的URL）。在解析后返回的结果路径字符串中，每个特殊字符将使用iri_to_uri()编码。

这是一种不违反DRY原则的输出链接的方式，它可以避免在模板中硬编码链接路径。

{% url 'some-url-name' v1 v2 %}

第一个参数是url() name。它可以是一个被引号引起来的字符串或者其他的上下文变量. 其他参数是可选的并且应该以空格隔开，这些值会在URL中以参数的形式传递. 上面的例子展示了如何传递位置参数. 当然你也可以使用关键字参数.

{% url 'some-url-name' arg1=v1 arg2=v2 %}

不要把位置参数和关键字参数混在一起使用。 URLconf所需的所有参数都应该存在。

例如，假设您有一个视图app_views.py，其URLconf接受客户端ID（此处client()是视图文件app_views.client）。 URLconf行可能如下所示：

('^client/([0-9]+)/$', app_views.client, name='app-views-client')

如果你的应用中的URLconf 已经被包含到项目 URLconf 中，比如下面这样

('^clients/', include('project_name.app_name.urls'))

然后，在模板中，您可以创建一个此视图的链接，如下所示：

{% url 'app-views-client' client.id %}

模板标签会输出如下的字符串 /clients/client/123/.

请注意，如果您要反查的网址不存在，您会收到NoReverseMatch异常，这会导致您的网站显示错误网页。

如果您希望在不显示网址的情况下检索网址，则可以使用略有不同的调用：

{% url 'some-url-name' arg arg2 as the_url %}

<a href="{{ the_url }}">I'm linking to {{ the_url }}</a>

as var语法创建的变量的范围是{％块％}其中{％ url ％} / t7>标签出现。

此标签 {％ url ... as VAR ％} 语法将不导致错误，如果视图丢失。实际上，您将使用此链接来链接到可选的视图：

{% url 'some-url-name' as the_url %}
{% if the_url %}
  <a href="{{ the_url }}">Link to optional stuff</a>
{% endif %}

如果您要检索名称空间网址，请指定完全限定名称：

{% url 'myapp:view-name' %}

这将遵循正常的namespaced URL resolution strategy，包括使用上下文对当前应用程序提供的任何提示。

警告

不要忘记在url() name之间放置引号，否则该值将被解释为上下文变量！

`verbatim`¶

停止模版引擎在该标签中的渲染/

常见的用法是允许与Django语法冲突的JavaScript模板图层。像这样：

{% verbatim %}
    {{if dying}}Still alive.{{/if}}
{% endverbatim %}

You can also designate a specific closing tag, allowing the use of {% endverbatim %} as part of the unrendered contents:

{% verbatim myblock %}
    Avoid template rendering via the {% verbatim %}{% endverbatim %} block.
{% endverbatim myblock %}

`widthratio`¶

为了创建条形图等，此标签计算给定值与最大值的比率，然后将该比率应用于常量。

像这样：

<img src="bar.png" alt="Bar"
     height="10" width="{% widthratio this_value max_value max_width %}" />

如果max_width是175，max_value是200，并且this_value是100，则上述示例中的图像将是88像素宽（因为175 / 200 = .875； .875 * 100 = 87.5，上舍入为88）。

在某些情况下，您可能想要捕获变量中的widthratio的结果。它可以是有用的，例如，在blocktrans像这样：

{% widthratio this_value max_value max_width as width %}
{% blocktrans %}The width is: {{ width }}{% endblocktrans %}

`with`¶

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

像这样：

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

填充变量（以上示例total）仅适用于{％与％} t5>和{％ endwith ％}标签。

你可以分配多个上下文变量：

{% with alpha=1 beta=2 %}
    ...
{% endwith %}

注

The previous more verbose format is still supported: {% with business.employees.count as total %}

内置过滤器参考¶

`add`¶

把add后的参数加给value

像这样：

{{ value|add:"2" }}

如果 值 为 4,则会输出 6.

过滤器首先会强制把两个值转换成Int类型。如果强制转换失败, 它会试图使用各种方式吧两个值相加。这将适用于某些数据类型（字符串，列表等）并且对别人失败。 Day of the month, 2 digits with leading zeros.

例如，我们使用下面的值

{{ first|add:second }}

first 是 [1, 2, 3] ，second 是 [4, 5, 6], 将会输出 [1, 2, 3, 4, 5, 6].

警告

如果字符串可以被强制转换成int类型则会 summed，无法被转换，则和上面的第一个例子一样

`addslashes`¶

在引号前面加上斜杆。例如，用于在CSV中转义字符串。

像这样：

{{ value|addslashes }}

如果value 是 "I'm using Django", 输出将变成 "I\'m using Django".

`capfirst`¶

大写变量的第一个字母。如果第一个字符不是字母，该过滤器将不会生效。

像这样：

{{ value|capfirst }}

如果 "Django" 是 "django", 输出将变成 value.

`center`¶

使"value"在给定的宽度范围内居中.

像这样：

"{{ value|center:"15" }}"

如果"Django"是value，输出将是“ Django t7>。

`cut`¶

移除value中所有的与给出的变量相同的字符串

像这样：

{{ value|cut:" " }}

如果value为“String with spaces”，输出将为"Stringwithspaces"。

`date`¶

根据给定格式对一个date变量格式化

使用与PHP的date()函数（https://php.net/date）类似的格式，具有一些差异。

注

这些格式字符不在模板外的Django中使用。它们被设计为与PHP兼容，以便为设计者轻松过渡。

可用的格式字符串：

格式化字符	描述	示例输出
a	`'a.m.'`或`'p.m.'`（请注意，这与PHP的输出略有不同，因为这包括符合Associated Press风格的期间）	`'a.m.'`
A	`'AM'`或`'PM'`。	`'AM'`
b	月，文字，3个字母，小写。	`'jan'`
B	未实现。
c	ISO 8601格式。（注意：与其他格式化程序不同，例如“Z”，“O”或“r”，如果值为naive datetime，则“c”格式化程序不会添加时区偏移量（请参阅`datetime.tzinfo`）。	`2008-01-02T10:30:00.000123+02:00`或`2008-01-02T10:30:00.000123`如果datetime是天真的
d	月的日子，带前导零的2位数字。	`'01'`到`'31'`
D	一周中的文字，3个字母。	`“星期五”`
e	时区名称可能是任何格式，或者可能返回一个空字符串，具体取决于datetime。	`''`、`'GMT'`、`'-500'`、`'US/Eastern'`等
E	月份，特定地区的替代表示通常用于长日期表示。	`'listopada'`（对于波兰语区域，而不是`'Listopad'`）
f	时间，在12小时的小时和分钟内，如果它们为零，则分钟停留。专有扩展。	`'1'`，`'1:30'`
F	月，文，长。	`'一月'`
g	小时，12小时格式，无前导零。	`'1'`到`'12'`
G	小时，24小时格式，无前导零。	`'0'`到`'23'`
h	小时，12小时格式。	`'01'`到`'12'`
H	小时，24小时格式。	`'00'`到`'23'`
i	分钟。	`'00'`到`'59'`
I	夏令时间，无论是否生效。	`'1'`或`'0'`
j	没有前导零的月份的日子。	`'1'`到`'31'`
l	星期几，文字长。	`'星期五'`
L	布尔值是否是一个闰年。	`True`或`False`
m	月，2位数字带前导零。	`'01'`到`'12'`
M	月，文字，3个字母。	`“扬”`
n	月无前导零。	`'1'`到`'12'`
N	美联社风格的月份缩写。专有扩展。	`'Jan.'`，`'Feb.'`，`'March'`，`'May'`
o	ISO-8601周编号，对应于使用闰年的ISO-8601周数（W）。对于更常见的年份格式，请参见Y。	`'1999年'`
O	与格林威治时间的差异在几小时内。	`'+0200'`
P	时间为12小时，分钟和'a.m。'/'p.m。'，如果为零，分钟停留，特殊情况下的字符串“午夜”和“中午”。专有扩展。	`'1 am'`，`'1:30 pm' / t3>，'midnight'，'noon'，'12：30 pm' / T10>`
r	RFC 5322格式化日期。	`'Thu, 21 Dec 2000 16:01:07 +0200'`
s	秒，带前导零的2位数字。	`'00'`到`'59'`
S	一个月的英文序数后缀，2个字符。	`'st'`，`'nd'`，`'rd'`或`'th'`
t	给定月份的天数。	`28` to `31`
T	本机的时区。	`'EST'`，`'MDT'`
u	微秒。	`000000` to `999999`
U	自Unix Epoch以来的二分之一（1970年1月1日00:00:00 UTC）。
w	星期几，数字无前导零。	`'0'`（星期日）至`'6'`（星期六）
W	ISO-8601周数，周数从星期一开始。	`1`，`53`
y	年份，2位数字。	`'99'`
Y	年，4位数。	`'1999年'`
z	一年中的日子	`0`到`365`
Z	时区偏移量，单位为秒。 UTC以西时区的偏移量总是为负数，对于UTC以东时，它们总是为正。	`-43200`到`43200`

像这样：

{{ value|date:"D d M Y" }}

如果datetime.datetime.now()是datetime对象（例如，value的结果），输出将是字符串 'Wed 09 Jan 2008'。

传递的格式可以是预定义的格式DATE_FORMAT，DATETIME_FORMAT，SHORT_DATE_FORMAT或SHORT_DATETIME_FORMAT使用上表中显示的格式说明符。请注意，预定义的格式可能会根据当前语言环境而有所不同。

假设USE_L10N为True和LANGUAGE_CODE为例如"es"

{{ value|date:"SHORT_DATE_FORMAT" }}

输出将是Django附带的es区域设置的字符串"09/01/2008"（"SHORT_DATE_FORMAT"格式说明符"d/m/Y"

当不使用格式字符串时使用DATE_FORMAT格式说明符。假设与上一个例子相同的设置：

{{ value|date }}

输出9 de Enero de 2008 es区域设置的DATE_FORMAT格式说明符为r'j \ d \ e F \ d \ e Y'。

在Django更改1.10：

在旧版本中，当没有给出格式字符串时，始终使用DATE_FORMAT设置（无本地化）。

您可以将date与time过滤器结合使用，以呈现datetime值的完整表示形式。例如。：

{{ value|date:"D d M Y" }} {{ value|time:"H:i" }}

`default`¶

如果value的计算结果为False，则使用给定的默认值。否则，使用该value。

像这样：

{{ value|default:"nothing" }}

如果nothing为""（空字符串），则输出将为value。

`default_if_none`¶

如果（且仅当）value为None，则使用给定的默认值。否则，使用该value。

注意，如果给出一个空字符串，默认值将不被使用。如果要回退空字符串，请使用default过滤器。

像这样：

{{ value|default_if_none:"nothing" }}

如果value是None，输出将不会nothing。

`dictsort`¶

接受一个字典列表，并返回按参数中给出的键排序后的列表。

像这样：

{{ value|dictsort:"name" }}

如果value为：

[
    {'name': 'zed', 'age': 19},
    {'name': 'amy', 'age': 22},
    {'name': 'joe', 'age': 31},
]

那么输出将是：

[
    {'name': 'amy', 'age': 22},
    {'name': 'joe', 'age': 31},
    {'name': 'zed', 'age': 19},
]

你也可以做更复杂的事情，如：

{% for book in books|dictsort:"author.age" %}
    * {{ book.title }} ({{ book.author.name }})
{% endfor %}

如果books是：

[
    {'title': '1984', 'author': {'name': 'George', 'age': 45}},
    {'title': 'Timequake', 'author': {'name': 'Kurt', 'age': 75}},
    {'title': 'Alice', 'author': {'name': 'Lewis', 'age': 33}},
]

那么输出将是：

* Alice (Lewis)
* 1984 (George)
* Timequake (Kurt)

dictsort也可以按指定索引的元素排列列表（或实现__getitem__()）的列表。像这样：

{{ value|dictsort:0 }}

如果value为：

[
    ('a', '42'),
    ('c', 'string'),
    ('b', 'foo'),
]

那么输出将是：

[
    ('a', '42'),
    ('b', 'foo'),
    ('c', 'string'),
]

您必须将索引作为整数而不是字符串传递。以下产生空输出：

{{ values|dictsort:"0" }}

在Django更改1.10：

添加列表列表的功能。

`dictsortreversed`¶

获取字典列表，并返回按照参数中给出的键按相反顺序排序的列表。这与上面的过滤器完全相同，但返回的值将是相反的顺序。

`divisibleby`¶

如果value可以被给出的参数整除，则返回 True

像这样：

{{ value|divisibleby:"3" }}

如果True是21，则输出将为value。

`escape`¶

转义字符串的HTML。具体来说，它使这些替换：

<转换为<
>转换为>
'（单引号）转换为'
"（双引号）转换为"
&转换为&

转义仅在字符串输出时应用，因此在连接的过滤器序列中escape的位置无关紧要：它将始终应用，就像它是最后一个过滤器。如果要立即应用转义，请使用force_escape过滤器。

将escape应用于通常会对结果应用自动转义的变量只会导致一轮转义完成。因此，即使在自动逃逸环境中使用此功能也是安全的。如果要应用多个转义通过，请使用force_escape过滤器。

例如，您可以在autoescape关闭时将escape应用于字段：

{% autoescape off %}
    {{ title|escape }}
{% endautoescape %}

自1.10版以来已弃用 escape筛选器的“懒惰”行为已被弃用。它会更改为立即在Django 2.0中应用conditional_escape()。

`escapejs`¶

转义用于JavaScript字符串的字符。这使不使字符串安全用于HTML，但确保在使用模板生成JavaScript / JSON时避免语法错误。

像这样：

{{ value|escapejs }}

如果value为“testing \ r \ njavascript \'string” ＆lt； b＆gt； escaping＆lt； / b＆ ，输出将为“testing \\ u000D \\ u000Ajavascript \\ u0027string \\ u0022 \\ u003Cb \\ u003Eescaping \\ u003C / b \\ u003E“。

`filesizeformat`¶

适合人们阅读的文件大小格式（例如 '13 KB', '4.1 MB', '102 bytes' 等）。

像这样：

{{ value|filesizeformat }}

如果value 为123456789，输出将是117.7 MB。

文件大小和国际系统单位

严格来说，filesizeformat不符合建议使用KiB，MiB，GiB等的国际单位制。当字节大小以1024的幂计算（在这种情况下）。相反，Django使用传统的单位名称（KB，MB，GB等）对应于更常用的名称。

`first`¶

返回列表中的第一项。

像这样：

{{ value|first }}

如果value是列表['a'， 'b'， 'c'] ，输出将为'a'。

`floatformat`¶

当不使用参数时，将浮点数舍入到小数点后一位，但前提是要显示小数部分。像这样：

`值`	模板	产量
`34.23234`	`{{ value \| floatformat }}`	`34.2`
`34.00000`	`{{ value \| floatformat }}`	`34`
`34.26000`	`{{ value \| floatformat }}`	`34.3`

如果与数字整数参数一起使用，floatformat将数字四舍五入为小数位数。像这样：

`值`	模板	产量
`34.23234`	`{{ value \| floatformat：3 }}`	`34.232`
`34.00000`	`{{ value \| floatformat：3 }}`	`34.000`
`34.26000`	`{{ value \| floatformat：3 }}`	`34.260`

特别有用的是传递0（零）作为参数，它将使float浮动到最接近的整数。

`值`	模板	产量
`34.23234`	`{{ value \| floatformat：“0” }}`	`34`
`34.00000`	`{{ value \| floatformat：“0” }}`	`34`
`39.56000`	`{{ value \| floatformat：“0” }}`	`40`

如果传递给floatformat的参数为负，则它会将一个数字四舍五入到小数点后的位置，但前提是要显示一个小数部分。像这样：

`值`	模板	产量
`34.23234`	`{{ value \| floatformat：“ - 3” }}`	`34.232`
`34.00000`	`{{ value \| floatformat：“ - 3” }}`	`34`
`34.26000`	`{{ value \| floatformat：“ - 3” }}`	`34.260`

使用没有参数的-1等效于使用具有floatformat的参数的floatformat。

`force_escape`¶

将HTML转义应用于字符串（有关详细信息，请参阅escape过滤器）。此过滤器立即应用于，并返回一个新的转义字符串。这在需要多次转义或想要对转义结果应用其他过滤器的罕见情况下非常有用。通常，您要使用escape过滤器。

例如，如果您要捕获由linebreaks过滤器创建的 HTML元素：

{% autoescape off %}
    {{ body|linebreaks|force_escape }}
{% endautoescape %}

`get_digit`¶

给定一个整数，返回所请求的数字，其中1是最右边的数字，2是第二个最右边的数字等。返回无效输入的原始值（如果输入或参数不是整数，或参数小于1）。否则，输出总是一个整数。

像这样：

{{ value|get_digit:"2" }}

如果value为123456789，则输出将为8。

`iriencode`¶

将IRI（国际化资源标识符）转换为适合包含在URL中的字符串。如果您尝试在网址中使用包含非ASCII字符的字符串，这是必要的。

在已经通过urlencode过滤器的字符串上使用此过滤器是安全的。

像这样：

{{ value|iriencode }}

如果"?test=1&me=2"为"?test=1&me=2"，输出将为value

`join`¶

使用字符串连接列表，例如Python的str.join(list)

像这样：

{{ value|join:" // " }}

如果value是列表['a'， 'b'， 'c'] / t2>，输出将为“a // b // C“ T11> T6>。

`last`¶

返回列表中的最后一个项目。

像这样：

{{ value|last }}

If value is the list ['a', 'b', 'c', 'd'], the output will be the string "d".

`length`¶

返回值的长度。这适用于字符串和列表。

像这样：

{{ value|length }}

如果4是['a'， 'b'， 'c'， 'd']或"abcd"，输出将为value。

对于未定义的变量，过滤器返回0。

`length_is`¶

如果值的长度是参数，则返回True，否则返回False。

例如：

{{ value|length_is:"4" }}

如果True是['a'， 'b'， 'c'， 'd']或"abcd"，输出将为value。

`linebreaks`¶

替换纯文本中的换行为正确的HTML标签；单独的一个换行变成( ) ，换行后接一个空行变成()。

例如：

{{ value|linebreaks }}

如果value为Joel\nis a slug，输出将为Joel is a slug。

`linebreaksbr`¶

将纯文本中的所有换行符转换为HTML换行符（ ）。

例如：

{{ value|linebreaksbr }}

If value is Joel\nis a slug, the output will be Joel is a slug.

`linenumbers`¶

显示带行号的文本。

像这样：

{{ value|linenumbers }}

如果value为：

one
two
three

输出将是：

one
two
three

`ljust`¶

将给定宽度的字段中的值左对齐。

论据： 字段大小

像这样：

"{{ value|ljust:"10" }}"

如果Django为value，则输出将为“Django ”。

`lower`¶

将字符串转换为全部小写。

像这样：

{{ value|lower }}

如果value是 完全 LOVING 这个相册！，输出就是 完全爱心这个专辑！.

`make_list`¶

返回转换为列表的值。对于字符串，它是一个字符列表。对于整数，在创建列表之前将参数强制转换为unicode字符串。

像这样：

{{ value|make_list }}

如果value是字符串"Joel"，输出将是列表['J'， 'o' ， 'e'， 'l']。如果value为123，输出将为列表['1', '2', '3']。

`phone2numeric`¶

将电话号码（可能包含字母）转换为其等效数字。

输入不必是有效的电话号码。这将很乐意转换任何字符串。

像这样：

{{ value|phone2numeric }}

如果800-2655328为800-COLLECT，输出将为value。

`pluralize`¶

如果值不是1则返回一个复数形式通常用 's'表示.

例如：

You have {{ num_messages }} message{{ num_messages|pluralize }}.

如果num_messages是1，则输出将为 You have 1 message. 如果num_messages是2，输出将为 You have 2 messages.

另外如果你需要的不是 's'后缀的话, 你可以提供一个备选的参数给过滤器

例如：

You have {{ num_walruses }} walrus{{ num_walruses|pluralize:"es" }}.

对于非一般形式的复数,你可以同时指定单复数形式，用逗号隔开.

例如：

You have {{ num_cherries }} cherr{{ num_cherries|pluralize:"y,ies" }}.

注

使用blocktrans来翻译复数形式的字符串

`pprint`¶

包装器pprint.pprint() - 用于调试，真的。

`random`¶

返回给定列表中的随机项。

像这样：

{{ value|random }}

If value is the list ['a', 'b', 'c', 'd'], the output could be "b".

`rjust`¶

右对齐给定宽度字段中的值。

论据： 字段大小

像这样：

"{{ value|rjust:"10" }}"

如果Django为value，则输出将为“ Django”。

`safe`¶

将字符串标记为在输出之前不需要进一步的HTML转义。当自动转义关闭时，此过滤器不起作用。

注

如果您要链接过滤器，在safe后应用的过滤器可能会使内容再次不安全。例如，以下代码按原样打印变量：

{{ var|safe|escape }}

`safeseq`¶

将safe过滤器应用于序列的每个元素。与对序列进行操作的其他过滤器（例如join）一起使用非常有用。像这样：

{{ some_list|safeseq|join:", " }}

在这种情况下，不能直接使用safe过滤器，因为它首先将变量转换为字符串，而不是使用序列的各个元素。

`slice`¶

返回列表的一部分。

使用与Python的列表切片相同的语法。有关介绍，请参见http://www.diveintopython3.net/native-datatypes.html#slicinglists。

例如：

{{ some_list|slice:":2" }}

如果some_list为['a', 'b', 'c']，那么输出将是['a', 'b']。

`slugify`¶

转换为ASCII。将空格转换为连字符。删除不是字母数字，下划线或连字符的字符。转换为小写。还剥离前导和尾随空格。

像这样：

{{ value|slugify }}

如果value是“Joel 是 a slug” t2 >，输出将为"joel-is-a-slug"。

`stringformat`¶

根据参数格式化变量，一个字符串格式化说明符。此说明符使用printf-style String Formatting语法，但前导“％”被删除。

像这样：

{{ value|stringformat:"E" }}

如果value为10，输出将为1.000000E+01。

`striptags`¶

尽一切可能努力剥离所有[X] HTML标签。

像这样：

{{ value|striptags }}

如果value是“＆lt； b＆gt； Joel＆lt； / b＆gt；＆lt； button＆gt；是＆lt； / button＆gt； a ＆lt； span＆gt； slug＆lt； / span＆gt；“，输出将为”Joel is a slug“。

无安全保证

请注意，striptags不会保证其输出是HTML安全的，尤其是对于无效的HTML输入。因此，NEVER将striptags过滤器应用于safe输出。如果您正在寻找更强大的功能，可以使用bleach Python库，特别是其clean方法。

`time`¶

根据给定的格式格式化时间。

给定格式可以是预定义的TIME_FORMAT，也可以是与date过滤器相同的自定义格式。请注意，预定义的格式是与区域设置相关的。

像这样：

{{ value|time:"H:i" }}

如果"01:23"等效于datetime.datetime.now()，则输出将为字符串value。

另一个例子：

假设USE_L10N为True且LANGUAGE_CODE为例如"de"

{{ value|time:"TIME_FORMAT" }}

输出将为Django附带的de区域设置的字符串"01:23"（"TIME_FORMAT"格式说明符为"H:i"

time过滤器只接受格式字符串中与时间相关的参数，而不是日期（由于显而易见的原因）。如果您需要格式化date值，请改用date过滤器（或沿time，如果需要渲染完整的datetime值）。

There is one exception the above rule: When passed a datetime value with attached timezone information (a time-zone-aware datetime instance) the time filter will accept the timezone-related format specifiers 'e', 'O' , 'T' and 'Z'.

当使用没有格式字符串时，使用TIME_FORMAT格式说明符：

{{ value|time }}

是相同的：

{{ value|time:"TIME_FORMAT" }}

在Django更改1.10：

在旧版本中，当没有给出格式字符串时，始终使用TIME_FORMAT设置（无本地化）。

`timesince`¶

将日期格式设为自该日期起的时间（例如，“4天，6小时”）。

采用一个可选参数，它是一个包含用作比较点的日期的变量（不带参数，比较点为现在）。例如，如果blog_date是表示2006年6月1日午夜的日期实例，并且comment_date是2006年6月1日08:00的日期实例，则以下将返回“8小时”：

{{ blog_date|timesince:comment_date }}

比较offset-naive和offset-aware datatimes将返回一个空字符串。

分钟是所使用的最小单位，对于相对于比较点的未来的任何日期，将返回“0分钟”。

`timeuntil`¶

类似于timesince，除了它测量从现在开始直到给定日期或日期时间的时间。例如，如果今天是2006年6月1日，而conference_date是保留2006年6月29日的日期实例，则{{ conference_date | timeuntil }}将返回“4周”。

使用可选参数，它是一个包含用作比较点的日期（而不是现在）的变量。如果from_date包含2006年6月22日，则以下内容将返回“1周”：

{{ conference_date|timeuntil:from_date }}

比较offset-naive和offset-aware datatimes将返回一个空字符串。

分钟是使用的最小单位，对于过去的任何相对于比较点的日期，将返回“0分钟”。

`title`¶

使字符以大写字符开头，其余字符小写，将字符串转换为titlecase。此标记不会努力保持“小写字”小写。

像这样：

{{ value|title }}

如果value为“my FIRST post”，输出将为“My First Post”。

`truncatechars`¶

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。

论据： 要截断的字符数

像这样：

{{ value|truncatechars:9 }}

如果value是“Joel 是 a slug” t2 >，输出将为“Joel i ...”。

`truncatechars_html`¶

类似于truncatechars，除了它知道HTML标记。在字符串中打开并且在截断点之前未关闭的任何标记在截断后立即关闭。

像这样：

{{ value|truncatechars_html:9 }}

如果value是“＆lt； p＆gt； Joel 是 a slug＆lt； / p＆gt； “，输出将为”＆lt； p＆gt； Joel i ...＆lt； / p＆gt；“ t7 >。

HTML内容中的换行符将保留。

`truncatewords`¶

在一定数量的字后截断字符串。

论据： 要截断的字数

像这样：

{{ value|truncatewords:2 }}

如果value 是 "Joel is a slug", 输出变为 "Joel is ...".

字符串中的换行符将被删除。

`truncatewords_html`¶

类似于truncatewords，除了它知道HTML标记。在字符串中打开并且在截断点之前未关闭的任何标记在截断后立即关闭。

这比truncatewords效率较低，因此只应在传递HTML文本时使用。

像这样：

{{ value|truncatewords_html:2 }}

如果value是“＆lt； p＆gt； Joel 是 a slug＆lt； / p＆gt； “，输出将为”＆lt； p＆gt； Joel ...＆lt； / p＆gt； T10> T7>。

HTML内容中的换行符将保留。

`unordered_list`¶

接收一个嵌套的列表，返回一个HTML 的列表 —— 不包含开始和结束的

列表假设成具有合法的格式。例如，如果var 包含['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]，那么{{ var|unordered_list }} 将返回：

<li>States
<ul>
        <li>Kansas
        <ul>
                <li>Lawrence</li>
                <li>Topeka</li>
        </ul>
        </li>
        <li>Illinois</li>
</ul>
</li>

`upper`¶

将字符串转换为大写形式：

像这样：

{{ value|upper }}

如果value是“Joel 是 a slug” t2 >，输出将为“JOEL IS A SLUG”。

`urlencode`¶

转义要在URL中使用的值。

像这样：

{{ value|urlencode }}

如果value为"https://www.example.org/foo?a=b&c=d"，输出将为"https%3A//www.example.org/foo%3Fa%3Db%26c%3Dd"

可以提供包含不应该转义的字符的可选参数。

如果未提供，则'/'字符被假定为安全的。当所有字符都应该转义时，可以提供一个空字符串。像这样：

{{ value|urlencode:"" }}

如果value为"https://www.example.org/"，输出将为"https%3A%2F%2Fwww.example.org%2F"

`urlize`¶

将文字中的网址和电子邮件地址转换为可点击的链接。

该模板标签适用于前缀为http://，https://的链接，或 万维网。. 例如，https://goo.gl/aia1t将被转换，但goo.gl/aia1t不会。

它还支持以原始顶级域（.org，.mil，.net，.gov，.edu，.com和.int）。例如，djangoproject.com被转换。

链接可以具有结尾标点符号（句点，逗号，近括号）和前导标点符号（开头括号），urlize仍然可以做正确的事。

由urlize生成的链接会向其中添加rel="nofollow"属性。

像这样：

{{ value|urlize }}

如果value是“检查 out www.djangoproject.com”，输出将“检查出 href =”http://www.djangoproject.com“ t10> rel =“nofollow”＆gt； www.djangoproject.com＆lt； / a＆gt；“。

除了网络链接之外，urlize也会将电子邮件地址转换为 邮寄地址： 链接。如果value是“发送问题到 foo@example.com” t6 >，输出将是“发送问题到＆lt； a href =“mailto：foo@example.com”＆gt； foo@example.com&lt； / a＆gt；“。

urlize过滤器还采用可选参数autoescape。如果True是autoescape，则使用Django的内置escape过滤器转义链接文字和网址。 autoescape的默认值为True。

注

如果urlize应用于已经包含HTML标记的文本，则会无法正常工作。仅将此过滤器应用于纯文本。

`urlizetrunc`¶

将网址和电子邮件地址转换为可点击的链接，就像urlize，但截断长度超过给定字符数限制的网址。

论据： 链接文本的字符数应截短为，包括如果截断是必要的，添加的省略号。

像这样：

{{ value|urlizetrunc:15 }}

If value is "Check out www.djangoproject.com", the output would be 'Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangopr...</a>'.

与urlize一样，此过滤器应仅应用于纯文本。

`wordcount`¶

返回字数。

像这样：

{{ value|wordcount }}

如果value是“Joel 是 a slug” t2 >，输出将为4。

`wordwrap`¶

以指定的行长度换行单词。

论据： 用于包装文本的字符数

像这样：

{{ value|wordwrap:5 }}

如果value是Joel is a slug 输出将是：

Joel
is a
slug

`yesno`¶

将值“None，False和（可选）True映射到字符串”yes“，”no“，”maybe“自定义映射作为逗号分隔列表传递，并根据值返回其中一个字符串：

像这样：

{{ value|yesno:"yeah,no,maybe" }}

值	参数	输出
`True`		`yes`
`True`	`"yeah,no,maybe"`	`yeah`
`False`	`"yeah,no,maybe"`	`no`
`None`	`"yeah,no,maybe"`	`maybe`
`None`	`"yeah,no"`	`no` (转换 `None` 为 `False` ，如果没有给出 `None`的映射)

国际化标签和过滤器¶

Django提供模板标记和过滤器，以控制模板中internationalization的每个方面。它们允许对翻译，格式化和时区转换进行粒度控制。

`i18n`¶

此库允许在模板中指定可翻译文本。要启用它，请将USE_I18N设置为True，然后加载{％ load i18n ％}。

请参阅Internationalization: in template code中。

`l10n`¶

此库提供对模板中值的本地化的控制。您只需要使用{％ load l10n ％}但您通常会将USE_L10N设置为True，以便本地化默认处于活动状态。

请参阅Controlling localization in templates。

`tz`¶

此库提供对模板中时区转换的控制。像True，您只需要使用{％ load tz }，但通常还会将USE_TZ设置为l10n，以便默认情况下会转换为本地时间。

请参阅Time zone aware output in templates。

其他标签和过滤器库¶

Django附带了一些其他模板标记库，您必须在INSTALLED_APPS设置中显式启用，并在您的模板中启用{% load %}标记。

`django.contrib.humanize`¶

一组Django模板过滤器，用于向数据添加“人性化”。请参阅django.contrib.humanize。

`static`¶

要链接保存在STATIC_ROOT中的静态文件，Django附带了static模板标记。如果安装了django.contrib.staticfiles应用程序，则标签将使用STATICFILES_STORAGE指定的存储区域的url()方法提供文件。像这样：

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

它还能够消耗标准上下文变量，例如。假设将user_stylesheet变量传递给模板：

{% load static %}
<link rel="stylesheet" href="{% static user_stylesheet %}" type="text/css" media="screen" />

如果您希望在不显示静态网址的情况下检索静态网址，则可以使用略有不同的调用：

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

使用Jinja2模板？

有关Jinja2使用static标签的信息，请参阅Jinja2。

在Django更改1.10：

在旧版本，你必须在你的模板中使用 {% load static from staticfiles %}，以从定义在STATICFILES_STORAGE的储存文件夹中提供相关文件。现在已经不再需要了.

`get_static_prefix`¶

您应该选择static静态模板标记, 但如果需要对 STATIC_URL 在模板中的确切位置和方式进行更多的控制, 则可以使用 get_static_prefix 模板标记:

{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

还有一个第二种形式，你可以使用，以避免额外的处理，如果你需要多次的价值：

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

`get_media_prefix`¶

类似于get_static_prefix，get_media_prefix填充媒体前缀为MEDIA_URL的模板变量，例如：

{% load static %}
<body data-media-url="{% get_media_prefix %}">

通过将值存储在数据属性中，如果我们想在JavaScript上下文中使用它，我们确保它适当地转义。

Django 1.11.6 文档

内置模板标签和过滤器¶

内置标签引用¶

autoescape¶

block¶

comment¶

csrf_token¶

cycle¶

debug¶

extends¶

filter¶

firstof¶

for¶

for ... empty ¶

if¶

布尔运算符¶

== operator ¶

!= operator ¶

<操作符¶

> operator ¶

<= operator¶

>= operator ¶

in操作符¶

not in操作符¶

is operator ¶

is not操作符¶

过滤器¶ T0>

复合表达式¶

ifequal和ifnotequal ¶

ifchanged¶

include¶

load¶

lorem¶

now¶

regroup¶

分组其他属性¶

resetcycle¶

spaceless¶

templatetag¶

url¶

verbatim¶

widthratio¶

with¶

内置过滤器参考¶

add¶

addslashes¶

capfirst¶

center¶

cut¶

date¶

default¶

default_if_none¶

dictsort¶

dictsortreversed¶

divisibleby¶

escape¶

escapejs¶

filesizeformat¶

first¶

floatformat¶

force_escape¶

get_digit¶

iriencode¶

join¶

last¶

length¶

length_is¶

linebreaks¶

linebreaksbr¶

linenumbers¶

ljust¶

lower¶

make_list¶

phone2numeric¶

pluralize¶

pprint¶

random¶

rjust¶

safe¶

safeseq¶

`autoescape`¶

`block`¶

`comment`¶

`csrf_token`¶

`cycle`¶

`debug`¶

`extends`¶

`filter`¶

`firstof`¶

`for`¶

`for` ... `empty` ¶

`if`¶

`==` operator ¶

`!=` operator ¶

`<`操作符¶

`>` operator ¶

`<=` operator¶

`>=` operator ¶

`in`操作符¶

`not in`操作符¶

`is` operator ¶

`is not`操作符¶

`ifequal`和`ifnotequal` ¶

`ifchanged`¶

`include`¶

`load`¶

`lorem`¶

`now`¶

`regroup`¶

`resetcycle`¶

`spaceless`¶

`templatetag`¶

`url`¶

`verbatim`¶

`widthratio`¶

`with`¶

`add`¶

`addslashes`¶

`capfirst`¶

`center`¶

`cut`¶

`date`¶

`default`¶

`default_if_none`¶

`dictsort`¶

`dictsortreversed`¶

`divisibleby`¶

`escape`¶

`escapejs`¶

`filesizeformat`¶

`first`¶

`floatformat`¶

`force_escape`¶

`get_digit`¶

`iriencode`¶

`join`¶

`last`¶

`length`¶

`length_is`¶

`linebreaks`¶

`linebreaksbr`¶

`linenumbers`¶

`ljust`¶

`lower`¶

`make_list`¶

`phone2numeric`¶

`pluralize`¶

`pprint`¶

`random`¶

`rjust`¶

`safe`¶

`safeseq`¶

`slice`¶

`slugify`¶

`stringformat`¶

`striptags`¶

`time`¶

`timesince`¶

`timeuntil`¶

`title`¶