本文档描述了 Django 内置的模板标签和过滤器。如果有的话，建议你使用 自动化文档，因为它也会包含安装的任何自定义标签或过滤器的文档。
\nautoescapeLink to this heading#控制当前的自动转义行为。该标签以 on 或 off 作为参数，决定块内是否有自动转义行为。此区块以 endautoescape 结束标签关闭。
当自动转义生效时，所有的变量内容在将结果放入输出之前（但在任何过滤器被应用之后）都会被应用 HTML 转义。这相当于对每个变量手动应用 escape 过滤器。
唯一的例外是那些已经被标记为 “安全” 的变量，这些变量可以是被填充变量的代码标记的，也可以是被应用了 safe 或 escape 过滤器的。
示例用法：
\n{% autoescape on %}\n {{ body }}\n{% endautoescape %}\nblockLink to this heading#定义一个可以被子模板覆盖的块。更多信息请参见 模板继承。
\ncommentLink to this heading#忽略 {% comment %} 和 {% endcomment %} 之间的所有内容。可以在第一个标签中插入一个可选的注释。例如，这在注释代码时很有用，可以记录代码被禁用的原因。
示例用法：
\n<p>Rendered text with {{ pub_date|date:"c" }}</p>\n{% comment "Optional note" %}\n <p>Commented out text with {{ create_date|date:"c" }}</p>\n{% endcomment %}\ncomment 标签不能嵌套。
csrf_tokenLink to this heading#这个标签用于 CSRF 保护，如 跨站点请求伪造 的文档中所述。
\ncycleLink to this heading#每次遇到这个标记时，都会产生一个参数。第一次遇到时产生第一个参数，第二次遇到时产生第二个参数，以此类推。一旦用尽所有参数，标签就会循环到第一个参数，并再次生成它。
\n这个标签在循环中特别有用：
\n{% for o in some_list %}\n <tr class="{% cycle 'row1' 'row2' %}">\n ...\n </tr>\n{% endfor %}\n第一次迭代产生的 HTML 引用类 row1，第二次引用 row2，第三次再引用 row1，以此类推，每次循环迭代。
你也可以使用变量。例如，如果你有两个模板变量，rowvalue1 和 rowvalue2，你可以像这样交替使用它们的值：
{% for o in some_list %}\n <tr class="{% cycle rowvalue1 rowvalue2 %}">\n ...\n </tr>\n{% endfor %}\n包含在循环中的变量将被转义。 你可以通过以下方式禁用自动转义：
\n{% for o in some_list %}\n <tr class="{% autoescape off %}{% cycle rowvalue1 rowvalue2 %}{% endautoescape %}">\n ...\n </tr>\n{% endfor %}\n你可以混合变量和字符串：
\n{% for o in some_list %}\n <tr class="{% cycle 'row1' rowvalue2 'row3' %}">\n ...\n </tr>\n{% endfor %}\n在某些情况下，你可能想引用一个周期的当前值，而不是前进到下一个值。要做到这一点，请使用 “as” 给 {% cycle %} 标签命名，比如：
{% cycle 'row1' 'row2' as rowcolors %}\n从那时起，你可以通过引用循环名称作为上下文变量，在模板中任何地方插入循环的当前值。如果你想把循环移动到下一个值，独立于原来的 cycle 标签，你可以使用另一个 cycle 标签，并指定变量的名称。所以，下面的模板：
<tr>\n <td class="{% cycle 'row1' 'row2' as rowcolors %}">...</td>\n <td class="{{ rowcolors }}">...</td>\n</tr>\n<tr>\n <td class="{% cycle rowcolors %}">...</td>\n <td class="{{ rowcolors }}">...</td>\n</tr>\n将会输出：
\n<tr>\n <td class="row1">...</td>\n <td class="row1">...</td>\n</tr>\n<tr>\n <td class="row2">...</td>\n <td class="row2">...</td>\n</tr>\n你可以在一个 cycle 标签中使用任意数量的值，用空格隔开。用单引号（'）或双引号（"）括起来的值被视为字符串字面，而没有引号的值被视为模板变量。
默认情况下，当你在循环标签中使用 as 关键字时，启动循环的 {% cycle %} 的用法将自己产生循环中的第一个值。如果你想在嵌套循环或包含的模板中使用该值，这可能是一个问题。如果你只想声明循环，但不产生第一个值，您可以在标签中添加一个 silent 关键字作为最后一个关键字。例如：
{% for obj in some_list %}\n {% cycle 'row1' 'row2' as rowcolors silent %}\n <tr class="{{ rowcolors }}">{% include "subtemplate.html" %}</tr>\n{% endfor %}\n这将输出一个 <tr> 元素的列表，其 class 在 row1 和 row2 之间交替出现。子模板在其上下文中可以访问 rowcolors，其值将与包围它的 <tr> 的类相匹配。如果省略 silent 关键字，row1 和 row2 将作为普通文本在 <tr> 元素之外发出。
当在循环定义上使用 silent 关键字时，silent 自动适用于该特定循环标记的所有后续使用。以下模板将 不 输出任何东西，即使第二次调用 {% cycle %} 并没有指定 silent ：
{% cycle 'row1' 'row2' as rowcolors silent %}\n{% cycle rowcolors %}\n你可以使用 resetcycle 标签使 {% cycle %} 标签在下次遇到时从第一个值重新开始。
debugLink to this heading#Outputs a whole load of debugging information, including the current context\nand imported modules. {% debug %} outputs nothing when the DEBUG\nsetting is False.
extendsLink to this heading#表示该模板扩展了一个父模板。
\n这个标签有两种使用方式：
\n{% extends "base.html" %} （带引号）使用字面值 "base.html" 作为要扩展的父模板的名称。
{% extends variable %} 使用 variable 的值。如果变量的值是一个字符串，Django 将使用这个字符串作为父模板的名称。如果变量的值是一个 Template 对象，Django 将使用该对象作为父模板。
更多内容请参见 模板继承 文档.
\n通常模板名称是相对于模板加载器的根目录而言的。字符串参数也可以是以 ./ 或 ../ 开头的相对路径。例如，假设以下目录结构：
dir1/\n template.html\n base2.html\n my/\n base3.html\nbase1.html\n在 template.html 中，以下路径将是有效的：
{% extends "./base2.html" %}\n{% extends "../base1.html" %}\n{% extends "./my/base3.html" %}\nfilterLink to this heading#通过一个或多个过滤器过滤块的内容。可以用管道指定多个过滤器，过滤器可以有参数，就像变量语法一样。
\n请注意，该块包括 filter 和 endfilter 标签之间的 所有 文本。
示例用法：
\n{% filter force_escape|lower %}\n This text will be HTML-escaped, and will appear in all lowercase.\n{% endfilter %}\nfirstofLink to this heading#输出第一个不是 false 的参数变量（即存在、不为空、不是一个错误的布尔值，也不是一个零的数值）。如果所有传递的变量都是 false，则不输出任何内容。
示例用法：
\n{% firstof var1 var2 var3 %}\n这相当于：
\n{% if var1 %}\n {{ var1 }}\n{% elif var2 %}\n {{ var2 }}\n{% elif var3 %}\n {{ var3 }}\n{% endif %}\n你也可以在所有传递的变量都是 False 的情况下使用一个字符串作为后备值：
\n{% firstof var1 var2 var3 "fallback value" %}\n这个标签会自动转义变量值。你可以通过以下方式禁用自动转义：
\n{% autoescape off %}\n {% firstof var1 var2 var3 "<strong>fallback value</strong>" %}\n{% endautoescape %}\n或者如果只对一些变量进行转义，可以使用：
\n{% firstof var1 var2|safe var3 "<strong>fallback value</strong>"|safe %}\n你可以使用 {% firstof var1 var2 var3 as value %} 的语法将输出结果存储在一个变量中。
forLink to this heading#循环浏览数组中的每个项目，使该项目在上下文变量中可用。例如，要显示 athlete_list 中提供的运动员列表：
<ul>\n{% for athlete in athlete_list %}\n <li>{{ athlete.name }}</li>\n{% endfor %}\n</ul>\n你可以通过使用 {% for obj in list reversed %} 来反向循环一个列表。
如果你需要对一个列表进行循环，你可以将每个子列表中的值解包为单个变量。例如，如果你的上下文中包含一个名为 points 的 (x,y) 坐标列表，你可以使用下面的方法来输出点的列表：
{% for x, y in points %}\n There is a point at {{ x }},{{ y }}\n{% endfor %}\n如果你需要访问字典中的项目，这也很有用。例如，如果你的上下文中包含一个字典 data，下面将显示该字典的键和值：
{% for key, value in data.items %}\n {{ key }}: {{ value }}\n{% endfor %}\n请记住，对于点运算符来说，字典键查询优先于方法查询。因此，如果 data 字典中包含一个名为 'items' 的键，data.items 将返回 data['items']` 而不是 data.items()。如果你想在模板中使用这些方法，避免添加像字典方法一样命名的键（items、values、keys 等）。在 模板变量的文档 中阅读更多关于点运算符的查找顺序。
for 循环设置了一组可以在循环体内直接使用的变量：
\n变量名 | \n描述 | \n
|---|---|
| \n循环计数器，表示当前循环的索引（从 | \n
| \n循环计数器，表示当前循环的索引（从 | \n
| \n反向循环计数器（以最后一次循环为 | \n
| \n反向循环计数器（以最后一次循环为 | \n
| \n当前循环为首个循环时，该变量为 True | \n
| \n当前循环为最后一个循环时，该变量为 True | \n
| \n在嵌套循环中，指向当前循环的上级循环 | \n
for ... emptyLink to this heading#当传递到 for 标签中的数组不存在或为空时，可以使用 {% empty %} 标签来指定输出的内容:
<ul>\n{% for athlete in athlete_list %}\n <li>{{ athlete.name }}</li>\n{% empty %}\n <li>Sorry, no athletes in this list.</li>\n{% endfor %}\n</ul>\n上面的代码与下面的代码是等同的，但上面的代码更简短，更清晰，也可能更快。
\n<ul>\n {% if athlete_list %}\n {% for athlete in athlete_list %}\n <li>{{ athlete.name }}</li>\n {% endfor %}\n {% else %}\n <li>Sorry, no athletes in this list.</li>\n {% endif %}\n</ul>\nifLink to this heading#{% if %} 标签会判断给定的变量，当变量为 True 时（比如存在、非空、非布尔值 False），就会输出块内的内容：
{% if athlete_list %}\n Number of athletes: {{ athlete_list|length }}\n{% elif athlete_in_locker_room_list %}\n Athletes should be out of the locker room soon!\n{% else %}\n No athletes.\n{% endif %}\n在上面的例子中, 如果 athlete_list 不是空的, 那么变量 {{ athlete_list|length }} 就会被显示出来.
正如你所看到的，if 标签可能带有一个或多个 {% elif %} 分支，以及一个 {% else %} 分支。当 {% else %} 之前的所有分支条件都不满足时，{% else %} 分支的内容会被显示出来。所有的分支都是可选的。
if 标签可以使用 and、or 或 not 来测试一些变量或取反某个变量：
{% if athlete_list and coach_list %}\n Both athletes and coaches are available.\n{% endif %}\n\n{% if not athlete_list %}\n There are no athletes.\n{% endif %}\n\n{% if athlete_list or coach_list %}\n There are some athletes or some coaches.\n{% endif %}\n\n{% if not athlete_list or coach_list %}\n There are no athletes or there are some coaches.\n{% endif %}\n\n{% if athlete_list and not coach_list %}\n There are some athletes and absolutely no coaches.\n{% endif %}\n允许在同一标签中同时使用 and 和 or 子句，and 比 or 优先级高，例如：
{% if athlete_list and coach_list or cheerleader_list %}\n将被解释为：
\nif (athlete_list and coach_list) or cheerleader_list\n在 if 标签中使用实际的括号是无效的语法。如果需要小括号来表示优先级，应使用嵌套的 if 标签。
if 标签也可以使用运算符 ==、!=、<、>、<=、>=、in、not in、is 和 `is not，其作用如下：
== 运算符Link to this heading#相等。例如：
\n{% if somevar == "x" %}\n This appears if variable somevar equals the string "x"\n{% endif %}\n!= 运算符Link to this heading#不相等。例如：
\n{% if somevar != "x" %}\n This appears if variable somevar does not equal the string "x",\n or if somevar is not found in the context\n{% endif %}\n< 运算符Link to this heading#小于。例如：
\n{% if somevar < 100 %}\n This appears if variable somevar is less than 100.\n{% endif %}\n> 运算符Link to this heading#大于。例如：
\n{% if somevar > 0 %}\n This appears if variable somevar is greater than 0.\n{% endif %}\n<= 运算符Link to this heading#小于等于。例如：
\n{% if somevar <= 100 %}\n This appears if variable somevar is less than 100 or equal to 100.\n{% endif %}\n>= 运算符Link to this heading#大于等于。例如：
\n{% if somevar >= 1 %}\n This appears if variable somevar is greater than 1 or equal to 1.\n{% endif %}\nin 运算符Link to this heading#包含其中。许多 Python 容器都支持这个运算符来测试给定值是否在容器中。下面是一些如何解释 x in y 的例子：
{% if "bc" in "abcdef" %}\n This appears since "bc" is a substring of "abcdef"\n{% endif %}\n\n{% if "hello" in greetings %}\n If greetings is a list or set, one element of which is the string\n "hello", this will appear.\n{% endif %}\n\n{% if user in users %}\n If users is a QuerySet, this will appear if user is an\n instance that belongs to the QuerySet.\n{% endif %}\nnot in 操作符Link to this heading#不包含在其中。这是 in 运算符的取反。
is 运算符Link to this heading#对象检测。测试两个变量是否为同一个对象。例如：
\n{% if somevar is True %}\n This appears if and only if somevar is True.\n{% endif %}\n\n{% if somevar is None %}\n This appears if somevar is None, or if somevar is not found in the context.\n{% endif %}\nis not 运算符Link to this heading#对象检测后取反。测试两个变量是否不是同一个对象。这是对 is 运算符的取反。例如：
{% if somevar is not True %}\n This appears if somevar is not True, or if somevar is not found in the\n context.\n{% endif %}\n\n{% if somevar is not None %}\n This appears if and only if somevar is not None.\n{% endif %}\n你也可以在 if 表达式中使用过滤器。例如：
{% if messages|length >= 100 %}\n You have lots of messages today!\n{% endif %}\n以上所有内容都可以组合成复合表达式。对于这样的表达式，了解表达式计算时运算符的分组方式——也就是优先规则，可能很重要。运算符的优先级，从低到高，如下所示：
\nor
and
not
in
==、!=、<、>、<=、>=
（这完全是按照 Python 来的）。所以，例如，以下复杂的 if 标签：
{% if a == b or c == d and e %}\n...将被解释为：
\n(a == b) or ((c == d) and e)\n如果你需要不同的优先级，你需要使用嵌套的 if 标签。有时，为了不了解优先规则的人，这样做还是比较清楚的。
比较运算符不能像在 Python 或数学符号中那样 “连锁”。例如，不能使用：
\n{% if a > b > c %} (WRONG)\n你应该使用：
\n{% if a > b and b > c %}\nifchangedLink to this heading#检查一个值是否在循环的最后一次迭代中发生了变化。
\n{% ifchanged %} 块标签用于循环中。它有两种可能的用法。
根据之前的状态检查自己渲染的内容，只有在内容发生变化时才显示。例如，这将显示一个天数列表，如果它改变了，只显示月份：
\n<h1>Archive for {{ year }}</h1>\n\n{% for date in days %}\n {% ifchanged %}<h3>{{ date|date:"F" }}</h3>{% endifchanged %}\n <a href="{{ date|date:"M/d"|lower }}/">{{ date|date:"j" }}</a>\n{% endfor %}\n如果给定一个或多个变量，检查是否有任何变量发生了变化。例如，下面的例子显示了日期的每次变化，而如果小时或日期发生了变化，则显示小时：
\n{% for date in days %}\n {% ifchanged date.date %} {{ date.date }} {% endifchanged %}\n {% ifchanged date.hour date.date %}\n {{ date.hour }}\n {% endifchanged %}\n{% endfor %}\nifchanged 标签也可以使用一个可选的 {% else %} 子句，如果值没有改变，就会显示：
{% for match in matches %}\n <div style="background-color:\n {% ifchanged match.ballot_id %}\n {% cycle "red" "blue" %}\n {% else %}\n gray\n {% endifchanged %}\n ">{{ match }}</div>\n{% endfor %}\nincludeLink to this heading#加载一个模板，并在当前上下文中进行渲染。这是一种在模板中 “包含” 其他模板的方式。
\n模板名称可以是一个变量，也可以是一个硬编码（引号）字符串，可以是单引号或双引号。
\n这个例子包含模板 "foo/bar.html" 的内容：
{% include "foo/bar.html" %}\n通常模板名称是相对于模板加载器的根目录而言的。字符串参数也可以是以 ./ 或 ../ 开头的相对路径，如 extends 标签所述。
这个例子包含模板的内容，其名称包含在变量 template_name ：
{% include template_name %}\n变量也可以是任何有 render() 方法并接受上下文的对象。这允许你在你的上下文中引用一个编译的 Template。
此外，该变量可以是模板名称的迭代，在这种情况下，将使用第一个可以加载的模板，如 select_template()。
一个被包含的模板会在包含它的模板的上下文中呈现。这个例子产生的输出是 "Hello, John!"。
上下文：变量 person 设置为 "John"，变量 greeting 设置为 "Hello"。
模板：
\n{% include "name_snippet.html" %}\nname_snippet.html 模板：
{{ greeting }}, {{ person|default:"friend" }}!\n你可以使用关键字参数向模板传递额外的上下文：
\n{% include "name_snippet.html" with person="Jane" greeting="Hello" %}\n如果你想只用所提供的变量（甚至不使用变量）来渲染上下文，请使用 only 选项。所包含的模板没有其他变量可用：
{% include "name_snippet.html" with greeting="Hi" only %}\nloadLink to this heading#加载一个自定义模板标签集。
\n例如，下面的模板将加载所有在 somelibrary 和 otherlibrary 中注册的标签和过滤器，这些标签和过滤器位于 package ：
{% load somelibrary package.otherlibrary %}\n你也可以使用 from 参数，有选择地从一个库中加载单个过滤器或标签。在这个例子中，名为 foo 和 bar 的模板标签／过滤器将从 somelibrary 加载：
{% load foo bar from somelibrary %}\n更多信息请参见 自定义标签和过滤器库。
\nloremLink to this heading#显示随机的 “经验之谈” 拉丁文文本。这对于在模板中提供样本数据很有用。
\n用法：
\n{% lorem [count] [method] [random] %}\n{% lorem %} 标签可以使用零、一、二或三个参数。这些参数是：
参数 | \n描述 | \n
|---|---|
| \n一个数字（或变量），包含要生成的段落或字数（默认为 1）。 | \n
| \n字词为 | \n
| \n
| \n
举例：
\n{% lorem %} 将输出常见的 “经验之谈” 段落。
{% lorem 3 p %} 将输出普通的 “经验之谈” 段落和两个随机段落，每个段落用 HTML <p> 标签包装。
{% lorem 2 w random %} 将随机输出两个拉丁语单词。
nowLink to this heading#显示当前日期和／或时间，根据给定的字符串使用格式。这些字符串可以包含格式指定符，如 date 过滤器部分所述。
举例：
\nIt is {% now "jS F Y H:i" %}\n请注意，如果你想使用 “原始” 值，你可以对格式字符串进行反斜杠转义。在这个例子中，“o” 和 “f” 都被反斜杠转义了，因为否则每个都是一个格式字符串，分别显示年份和时间：
\nIt is the {% now "jS \\o\\f F" %}\n这样就会显示为 “It is the 4th of September”。
\n\n你也可以使用 {% now "Y" as current_year %} 的语法将输出（作为字符串）存储在一个变量中。如果你想在模板标签中使用 {% now %}，比如 blocktranslate，这就很有用。
{% now "Y" as current_year %}\n{% blocktranslate %}Copyright {{ current_year }}{% endblocktranslate %}\nregroupLink to this heading#通过一个共同的属性将一个相似的对象列表重新分组。
\n这个复杂的标签通过一个例子得到了最好的说明：假设 cities 是一个由包含 "name"、"population" 和 "country" 键的字典所代表的城市列表。
cities = [\n {'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},\n {'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},\n {'name': 'New York', 'population': '20,000,000', 'country': 'USA'},\n {'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},\n {'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},\n]\n...而你想显示一个按国家排序的分层列表，像这样：
\nIndia
\nMumbai: 19,000,000
Calcutta: 15,000,000
USA
\nNew York: 20,000,000
Chicago: 7,000,000
Japan
\nTokyo: 33,000,000
你可以使用 {% regroup %} 标签按国家对城市列表进行分组。以下模板代码片段可以实现这一目的：
{% regroup cities by country as country_list %}\n\n<ul>\n{% for country in country_list %}\n <li>{{ country.grouper }}\n <ul>\n {% for city in country.list %}\n <li>{{ city.name }}: {{ city.population }}</li>\n {% endfor %}\n </ul>\n </li>\n{% endfor %}\n</ul>\n让我们来看看这个例子。{% regroup %} 需要三个参数：要重新分组的列表、要分组的属性和结果列表的名称。在这里，我们通过 country 属性对 cities 列表进行重新分组，并将结果称为 country_list。
{% regroup %} 产生一个 组对象 的列表（在本例中为 country_list）。组对象是 namedtuple() 的实例，有两个字段。
grouper —— 被分组的项目（例如，“India” 或 “Japan” 等字符串）。
list —— 本组所有项目的清单（例如，country='India' 的所有城市的清单）。
因为 {% regroup %} 会产生 namedtuple() 对象，所以也可以把前面的例子写成：
{% regroup cities by country as country_list %}\n\n<ul>\n{% for country, local_cities in country_list %}\n <li>{{ country }}\n <ul>\n {% for city in local_cities %}\n <li>{{ city.name }}: {{ city.population }}</li>\n {% endfor %}\n </ul>\n </li>\n{% endfor %}\n</ul>\n请注意，{% regroup %} 并没有对其输入进行排序！我们的例子依赖于这样一个事实： cities 列表首先是按 country 排序的。如果 cities 列表没有按 country 排序，重新分组就会天真地显示一个国家的多个组。例如，如果 cities 列表设置成这样（注意，国家没有被归为一组）。
cities = [\n {'name': 'Mumbai', 'population': '19,000,000', 'country': 'India'},\n {'name': 'New York', 'population': '20,000,000', 'country': 'USA'},\n {'name': 'Calcutta', 'population': '15,000,000', 'country': 'India'},\n {'name': 'Chicago', 'population': '7,000,000', 'country': 'USA'},\n {'name': 'Tokyo', 'population': '33,000,000', 'country': 'Japan'},\n]\n有了这个 cities 的输入，上面的 {% regroup %} 模板代码就会有如下输出。
India
\nMumbai: 19,000,000
USA
\nNew York: 20,000,000
India
\nCalcutta: 15,000,000
USA
\nChicago: 7,000,000
Japan
\nTokyo: 33,000,000
解决这个问题最简单的方法是在你的视图代码中确保数据是按照你想显示的方式来排序的。
\n另一种解决方案是使用 dictsort 过滤器对模板中的数据进行排序，如果你的数据是在字典列表中：
{% regroup cities|dictsort:"country" by country as country_list %}\n任何有效的模板查找都是重新分组标签的合法分组属性，包括方法、属性、字典键和列表项。例如，如果 “country” 字段是一个具有 “description” 属性的类的外键，你可以使用：
\n{% regroup cities by country.description as country_list %}\n或者，如果 country 是一个带有 choices 的字段，它将有一个 get_FOO_display() 方法作为属性，允许你对显示字符串进行分组，而不是 choices 键：
{% regroup cities by get_country_display as country_list %}\n{{ country.grouper }} 现在将显示 choices 集的值域，而不是键。
resetcycleLink to this heading#重置之前的 cycle ，使其在下一次遇到时从第一项开始重新启动。如果没有参数，{% resetcycle %} 将重置模板中定义的最后一个 {% cycle %}。
用法示例：
\n{% for coach in coach_list %}\n <h1>{{ coach.name }}</h1>\n {% for athlete in coach.athlete_set.all %}\n <p class="{% cycle 'odd' 'even' %}">{{ athlete.name }}</p>\n {% endfor %}\n {% resetcycle %}\n{% endfor %}\n这个例子会返回这样的HTML：
\n<h1>José Mourinho</h1>\n<p class="odd">Thibaut Courtois</p>\n<p class="even">John Terry</p>\n<p class="odd">Eden Hazard</p>\n\n<h1>Carlo Ancelotti</h1>\n<p class="odd">Manuel Neuer</p>\n<p class="even">Thomas Müller</p>\n请注意第一个代码块以 class="odd" 结束，而新的代码块以 class="odd" 开始。如果没有 {% resetcycle %} 标签，第二块将以 class="even" 开始。
你还可以重置命名的循环标签：
\n{% for item in list %}\n <p class="{% cycle 'odd' 'even' as stripe %} {% cycle 'major' 'minor' 'minor' 'minor' 'minor' as tick %}">\n {{ item.data }}\n </p>\n {% ifchanged item.category %}\n <h1>{{ item.category }}</h1>\n {% if not forloop.first %}{% resetcycle tick %}{% endif %}\n {% endifchanged %}\n{% endfor %}\n在这个例子中，我们既有奇数／偶数行的交替，也有每第五行的 “主要” 行。只有当类别发生变化时，才会重置五行循环。
\nspacelessLink to this heading#删除 HTML 标签之间的空白。这包括制表符和换行符。
\n用法示例：
\n{% spaceless %}\n <p>\n <a href="foo/">Foo</a>\n </p>\n{% endspaceless %}\n这个例子会返回这样的HTML：
\n<p><a href="foo/">Foo</a></p>\n只有 标签 之间的空格会被删除，而不是标签和文本之间的空格。在这个例子中，Hello 周围的空格不会被删除：
{% spaceless %}\n <strong>\n Hello\n </strong>\n{% endspaceless %}\ntemplatetagLink to this heading#输出用于组成模板标签的语法字符之一。
\nThe template system has no concept of "escaping" individual characters.\nHowever, you can use the {% templatetag %} tag to display one of the\ntemplate tag character combinations.
这个参数告诉我们要输出哪个模板位：
\n参数 | \n输出 | \n
|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
示例用法：
\nThe {% templatetag openblock %} characters open a block.\nSee also the verbatim tag for another way of including these\ncharacters.
urlLink to this heading#返回与给定视图和可选参数相匹配的绝对路径引用（不含域名的 URL）。路径中的任何特殊字符将使用 iri_to_uri() 进行编码。
这是在不违反 DRY 原则的情况下，通过在模板中硬编码 URL 来输出链接的方法：
\n{% url 'some-url-name' v1 v2 %}\n第一个参数是一个 URL 模式名称。它可以是一个引号文字或任何其他上下文变量。其他参数是可选的，应该是以空格分隔的值，这些值将在 URL 中作为参数使用。上面的例子显示的是传递位置参数。另外，你也可以使用关键字语法：
\n{% url 'some-url-name' arg1=v1 arg2=v2 %}\n不要在一次调用中同时混合使用位置和关键字语法。URLconf 所要求的所有参数都应该存在。
\n例如，假设你有一个视图，app_views.client，它的 URLconf 需要一个客户端 ID（这里，client() 是视图文件 app_views.py 中的一个方法）。URLconf 行可能是这样的：
path('client/<int:id>/', app_views.client, name='app-views-client')\n如果这个应用的 URLconf 被包含在项目的 URLconf 中，路径如下：
\npath('clients/', include('project_name.app_name.urls'))\n...然后，在模板中，你可以像这样创建一个链接到这个视图：
\n{% url 'app-views-client' client.id %}\n模板标签将输出字符串 /clients/client/123/。
请注意，如果你要反查的 URL 不存在，你会得到一个 NoReverseMatch 的异常引发，这将导致你的网站显示一个错误页面。
如果你想在不显示的情况下检索一个 URL，你可以使用一个稍微不同的调用：
\n{% url 'some-url-name' arg arg2 as the_url %}\n\n<a href="{{ the_url }}">I'm linking to {{ the_url }}</a>\nas var 语法创建的变量范围是 {% block %}，其中出现 {% url %} 标签。
如果缺少视图，这种 {% url ... as var %} 语法 不会 引起错误。在实践中，你会用它来链接到可选的视图：
{% url 'some-url-name' as the_url %}\n{% if the_url %}\n <a href="{{ the_url }}">Link to optional stuff</a>\n{% endif %}\n如果你想检索一个命名空间的 URL，请指定完全限定的名称：
\n{% url 'myapp:view-name' %}\n这将遵循正常的 命名空间 URL 解析策略，包括使用上下文提供的关于当前应用程序的任何提示。
\n\nverbatimLink to this heading#停止模板引擎渲染此块标签的内容。
\n常见的用法是允许 JavaScript 模板层与 Django 的语法发生碰撞。例如：
\n{% verbatim %}\n {{if dying}}Still alive.{{/if}}\n{% endverbatim %}\n你也可以指定一个特定的结束标签，允许使用 {% endverbatim %} 作为未渲染内容的一部分：
{% verbatim myblock %}\n Avoid template rendering via the {% verbatim %}{% endverbatim %} block.\n{% endverbatim myblock %}\nwidthratioLink to this heading#对于创建条形图等，该标签计算给定值与最大值的比率，然后将该比率应用于一个常数。
\n例子：
\n<img src="bar.png" alt="Bar"\n height="10" width="{% widthratio this_value max_value max_width %}">\n如果 this_value 是175，max_value 是 200，max_width 是 100，则上例中的图像宽度为 88 像素（因为 175 / 200 = 0.875；0.875 * 100 = 87.5，四舍五入为 88）。
在某些情况下，你可能想在一个变量中捕获 widthratio 的结果。例如，在 blocktranslate 中，它可能是有用的，像这样：
{% widthratio this_value max_value max_width as width %}\n{% blocktranslate %}The width is: {{ width }}{% endblocktranslate %}\nwithLink to this heading#将一个复杂的变量缓存在一个简单的名称下。当多次访问一个 “昂贵的” 方法（例如，访问数据库的方法）时，这很有用。
\n例子：
\n{% with total=business.employees.count %}\n {{ total }} employee{{ total|pluralize }}\n{% endwith %}\n被填充的变量（在上面的例子中，total）只有在 {% with %} 和 {% endwith %} 标签之间才能使用。
你可以指定一个以上的上下文变量：
\n{% with alpha=1 beta=2 %}\n ...\n{% endwith %}\naddLink to this heading#将参数添加到值中。
\n例子：
\n{{ value|add:"2" }}\n如果 value 是 4，那么输出将是 6。
这个过滤器将首先尝试将两个值强制转为整数。如果失败了，它将尝试将两个值加在一起。这对某些数据类型（字符串、列表等）有效，而对其他类型则失败。如果失败，结果将是一个空字符串。
\n例如，如果我们有：
\n{{ first|add:second }}\n同时 first 是 [1, 2, 3] 并且 second 是 [4, 5, 6]，则输出为 [1, 2, 3, 4, 5, 6]。
addslashesLink to this heading#在引号前添加斜杠。对 CSV 中的字符串进行转义很有用，例如。
\n例子：
\n{{ value|addslashes }}\n如果 value 是 "I'm using Django"，那么输出将是 "I\\'m using Django"。
capfirstLink to this heading#将值的第一个字符大写。如果第一个字符不是字母，这个过滤器就没有效果。
\n例子：
\n{{ value|capfirst }}\n如果 value 是 "django"，则输出为 "Django"。
centerLink to this heading#在给定宽度的字段中使数值居中。
\n例子：
\n"{{ value|center:"15" }}"\n如果 value 是 "Django"，输出将是 " Django "。
cutLink to this heading#从给定的字符串中删除参数的所有值。
\n例子：
\n{{ value|cut:" " }}\n如果 value 是 "String with spaces"，输出将是 "Stringwithspaces"。
dateLink to this heading#根据给定的格式设置日期。
\nUses a similar format to PHP's date() function with some\ndifferences.
\n\n可用的格式字符串：
\n格式字符 | \n描述 | \n输出示例 | \n
|---|---|---|
日 | \n\n | \n |
| \n某月的某日，2 位带前导零的数字。 | \n
| \n
| \n某月的某日，前面没有零。 | \n
| \n
| \n某周的某日，3 个字母的文本。 | \n
| \n
| \n某周的某日，长文本。 | \n
| \n
| \n某月英文序号后缀的某日，2 个字符。 | \n
| \n
| \n某周的某日，不含前导零的数字。 | \n
| \n
| \n某年的某日 | \n
| \n
周 | \n\n | \n |
| \n年的 ISO-8601 周数，周从星期一开始。 | \n
| \n
月 | \n\n | \n |
| \n月份，2 位数，前面加 0。 | \n
| \n
| \n没有前导零的月份。 | \n
| \n
| \n月，3 个字母的文本。 | \n
| \n
| \n月，小写的 3 个字母的文本。 | \n
| \n
| \n月，特定地域的替代表示方法，通常用于长日期表示。 | \n
| \n
| \n月，长文本。 | \n
| \n
| \n美联社风格的月份缩写。专属扩展。 | \n
| \n
| \n特定月份的天数。 | \n
| \n
年 | \n\n | \n |
| \nYear, 2 digits with leading zeros. | \n
| \n
| \nYear, 4 digits with leading zeros. | \n
| \n
| \n是否为闰年的布尔值。 | \n
| \n
| \nISO-8601 周数年，对应于使用闰周的 ISO-8601 周数（W）。更常见的年份格式见 Y。 | \n
| \n
时间 | \n\n | \n |
| \n小时，12 小时格式，无前导零。 | \n
| \n
| \n小时，24 小时格式，无前导零。 | \n
| \n
| \n小时，12 小时格式。 | \n
| \n
| \n小时，24 小时格式。 | \n
| \n
| \n分钟。 | \n
| \n
| \n秒，2 位带前导零的数字。 | \n
| \n
| \n微秒。 | \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n时间，以 12 小时格式的小时和分钟为单位，如果是零，就把分钟去掉。专属扩展。 | \n
| \n
| \n时间，以 12 小时格式的小时、分钟和 'a.m.'／'p.m.' 为单位，如果分钟为零，则不写，如果有，则写上特殊大小写的字符串 'midnight' 和 'noon'。专属扩展。 | \n
| \n
时区 | \n\n | \n |
| \n时区名称。可以是任何格式，也可以返回一个空字符串，取决于日期时间。 | \n
| \n
| \nDaylight saving time, whether it's in\neffect or not. | \n
| \n
| \n与格林威治时间的时差。 | \n
| \n
| \n本机的时区。 | \n
| \n
| \n时区偏移以秒为单位。UTC 以西的时区偏移总是负数，UTC 以东的时区偏移总是正数。 | \n
| \n
日期／时间 | \n\n | \n |
| \nISO 8601 format. (Note: unlike other\nformatters, such as "Z", "O" or "r",\nthe "c" formatter will not add timezone\noffset if value is a naive datetime\n(see | \n
| \n
| \nRFC 5322 格式的日期。 | \n
| \n
| \n自 Unix 纪元（1970 年 1 月 1 日 00:00:00 UTC）以来的秒数。 | \n\n |
例子：
\n{{ value|date:"D d M Y" }}\n如果 value 是一个 datetime 对象（例如，datetime.datetime.datetime.now() 的结果），输出将是字符串 'Wed 09 Jan 2008'。
传递的格式可以是预定义的 DATE_FORMAT、DATETIME_FORMAT、SHORT_DATE_FORMAT 或 SHORT_DATETIME_FORMAT, 或者是使用上表中显示的格式指定器的自定义格式。请注意，预定义的格式可能会根据当前的 locale 而有所不同。
假设 USE_L10N 为 True 和 LANGUAGE_CODE 为例如 "es"，那么对于：
{{ value|date:"SHORT_DATE_FORMAT" }}\n输出将是字符串 "09/01/2008" （Django 自带的 "SHORT_DATE_FORMAT" 格式指定符是 "d/m/Y"）。
当不使用格式字符串时，使用 DATE_FORMAT 格式指定器。假设设置与前一个例子相同：
{{ value|date }}\n输出 9 de Enero de 2008 （DATE_FORMAT' 格式指定符为 r'j\\d\\e F\\d\\e Y'）。“d” 和 “e” 都是反斜杠，因为否则每一个都是一个格式字符串，分别显示日期和时区名称。
你可以将 date 与 time 过滤器结合起来，以呈现一个 datetime 值的完整表示。例如：
{{ value|date:"D d M Y" }} {{ value|time:"H:i" }}\ndefaultLink to this heading#如果值为 False，则使用给定的默认值。否则，使用该值。
例子：
\n{{ value|default:"nothing" }}\n如果 value 是 "" （空字符串），输出将是 nothing。
default_if_noneLink to this heading#如果（也只有当）值是 None，使用给定的默认值。否则，使用该值。
请注意，如果给定一个空字符串，将 不会 使用默认值。如果你想使用空字符串，请使用 default 过滤器。
例子：
\n{{ value|default_if_none:"nothing" }}\n如果 value 是 None，则输出为 nothing。
dictsortLink to this heading#获取一个字典列表，并按照参数中给出的键排序返回该列表。
\n例子：
\n{{ value|dictsort:"name" }}\n如果 value 是：
[\n {'name': 'zed', 'age': 19},\n {'name': 'amy', 'age': 22},\n {'name': 'joe', 'age': 31},\n]\n那么输出将是：
\n[\n {'name': 'amy', 'age': 22},\n {'name': 'joe', 'age': 31},\n {'name': 'zed', 'age': 19},\n]\n你还可以做更复杂的事情，比如：
\n{% for book in books|dictsort:"author.age" %}\n * {{ book.title }} ({{ book.author.name }})\n{% endfor %}\n如果 books 是：
[\n {'title': '1984', 'author': {'name': 'George', 'age': 45}},\n {'title': 'Timequake', 'author': {'name': 'Kurt', 'age': 75}},\n {'title': 'Alice', 'author': {'name': 'Lewis', 'age': 33}},\n]\n那么输出将是：
\n* Alice (Lewis)\n* 1984 (George)\n* Timequake (Kurt)\ndictsort 也可以按照指定的索引对列表（或任何其他实现 __getitem__() 的对象）进行排序。例如：
{{ value|dictsort:0 }}\n如果 value 是：
[\n ('a', '42'),\n ('c', 'string'),\n ('b', 'foo'),\n]\n那么输出将是：
\n[\n ('a', '42'),\n ('b', 'foo'),\n ('c', 'string'),\n]\n你必须以整数而不是字符串的形式传递索引。以下情况会产生空的输出：
\n{{ values|dictsort:"0" }}\nOrdering by elements at specified index is not supported on dictionaries.
\n\ndictsortreversedLink to this heading#取一个字典列表，并按参数中给出的键反向排序返回该列表。这与上面的过滤器的工作原理完全相同，但返回的值将是倒序的。
\ndivisiblebyLink to this heading#如果数值被参数整除，则返回 True。
例子：
\n{{ value|divisibleby:"3" }}\n如果 value 是 21，则输出为 True。
escapeLink to this heading#转义字符串的 HTML。具体来说，它可以进行这些替换。
\n< 被替换为 <
> 被替换为 >
' （单引号）被替换为 '
" （双引号）被替换为 "
& 被替换为 &
将 escape 应用到一个通常会对结果进行自动转义的变量上，结果只会进行一轮转义。所以即使在自动转义环境中使用这个函数也是安全的。如果你想进行多次转义，请使用 force_escape 过滤器。
例如，当 :tag:`autoescape` 关闭时，你可以对字段应用 escape ：
{% autoescape off %}\n {{ title|escape }}\n{% endautoescape %}\nescapejsLink to this heading#在 JavaScript 字符串中使用的转义字符。这并不能使字符串安全地用于 HTML 或 JavaScript 模板字元，但可以保护你在使用模板生成 JavaScript／JSON 时避免语法错误。
\n例子：
\n{{ value|escapejs }}\n如果 value 是 "testing\\r\\njavascript 'string\\" <b> escaping </b>"，则输出为 "testing\\\\u000D\\\\u000Ajavascript \\\\u0027string\\\\u0022 \\\\u003Cb\\\\u003Eescaping\\\\u003C/b\\\\u003E"。
filesizeformatLink to this heading#以 “人类可读” 的文件大小为格式（如 '13 KB'、'4.1 MB'、'102 bytes' 等）。
例子：
\n{{ value|filesizeformat }}\n如果 value 是 123456789，则输出为 117.7 MB。
firstLink to this heading#返回列表中的第一个项目。
\n例子：
\n{{ value|first }}\n如果 value 是列表 ['a', 'b', 'c']，则输出为 'a'。
floatformatLink to this heading#当不使用参数时，将浮点数四舍五入到小数点后一位——但只在有小数部分要显示的情况下。例如：
\n
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
如果与数字整数参数一起使用，floatform 将一个数字四舍五入到小数点后几位。例如：
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
特别有用的是传递 0（零）作为参数，它将把浮点数舍入到最接近的整数。
\n
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
如果传递给 floatform 的参数是负数，它将把一个数字四舍五入到小数点后的位数——但只在有小数部分要显示的情况下。例如：
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
If the argument passed to floatformat has the g suffix, it will force\ngrouping by the THOUSAND_SEPARATOR for the active locale. For\nexample, when the active locale is en (English):
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
Output is always localized (independently of the {% localize off %} tag) unless the argument passed to floatformat has the u\nsuffix, which will force disabling localization. For example, when the active\nlocale is pl (Polish):
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
在没有参数的情况下使用 floatformat 相当于在参数为 -1 的情况下使用 floatformat。
force_escapeLink to this heading#对字符串进行 HTML 转义处理（详情请参见 escape 过滤器）。这个过滤器会 立即 应用，并返回一个新的转义字符串。在极少数情况下，当你需要多次转义或想对转义结果应用其他过滤器时，这很有用。通常情况下，你要使用 escape 过滤器。
例如，如果你想捕捉由 linebreaks 过滤器创建的 <p> HTML 元素：
{% autoescape off %}\n {{ body|linebreaks|force_escape }}\n{% endautoescape %}\nget_digitLink to this heading#给定一个整数，返回要求的数字，其中 1 是最右边的数字，2 是最右边的数字，等等。对于无效的输入（如果输入或参数不是整数，或者参数小于 1），返回原始值。否则，输出总是一个整数。
\n例子：
\n{{ value|get_digit:"2" }}\n如果 value 是 123456789，则输出为 8。
iriencodeLink to this heading#将 IRI（国际化资源标识符）转换为适合包含在 URL 中的字符串。如果你想在 URL 中使用包含非 ASCII 字符的字符串，这一点是必要的。
\n在已经通过 urlencode 过滤器的字符串上使用这个过滤器是安全的。
例子：
\n{{ value|iriencode }}\n如果 value 是 "?test=1&me=2"，则输出为 "?test=1&me=2"。
joinLink to this heading#用字符串连接一个列表，就像 Python 的 str.join(list) 一样。
例子：
\n{{ value|join:" // " }}\n如果 value 是列表 ['a', 'b', 'c']，输出将是字符串 "a // b // c"。
json_scriptLink to this heading#安全地将 Python 对象输出为 JSON，用 <script> 标签包装，准备好与 JavaScript 一起使用。
Argument: The optional HTML "id" of the <script> tag.
例子：
\n{{ value|json_script:"hello-data" }}\n如果 value 是字典 {'hello':'world'}，则输出为：
<script id="hello-data" type="application/json">{"hello": "world"}</script>\n由此产生的数据可以用 JavaScript 来访问，比如这样：
\nconst value = JSON.parse(document.getElementById('hello-data').textContent);\nXSS 攻击可以通过转义字符 “<”、“>” 和 “&” 来缓解。例如，如果 value 是 {'hello': 'world</script>&'}，则输出为：
<script id="hello-data" type="application/json">{"hello": "world\\\\u003C/script\\\\u003E\\\\u0026amp;"}</script>\n这与严格的内容安全策略兼容，禁止在页面中执行脚本。它还保持了被动数据和可执行代码之间的明确分离。
\n\nlastLink to this heading#返回列表中的最后一项。
\n例子：
\n{{ value|last }}\n如果 value 是列表 ['a', 'b', 'c', 'd']，输出将是字符串 "d"。
lengthLink to this heading#返回值的长度。这对字符串和列表都有效。
\n例子：
\n{{ value|length }}\n如果 value 是 ['a', 'b', 'c', 'd'] 或 "abcd"，输出将是 4。
过滤器对未定义的变量返回 0。
length_isLink to this heading#如果值的长度是参数，则返回 True，否则返回 False。
例子：
\n{{ value|length_is:"4" }}\n如果 value 是 ['a', 'b', 'c', 'd'] 或 "abcd"，输出将是 True。
linebreaksLink to this heading#用适当的 HTML 替换纯文本中的换行符；一个新行成为 HTML 换行符（<br>），一个新行后的空行成为段落换行符（</p>）。
例子：
\n{{ value|linebreaks }}\n如果 value 是 Joel\\nis a slug，则输出为 <p>Joel<br>is a slug</p>。
linebreaksbrLink to this heading#将一段纯文本中的所有换行符转换为 HTML 换行符（<br>）。
例子：
\n{{ value|linebreaksbr }}\n如果 value 是 Joel/nis a slug，则输出为 Joel<br>is a slug。
linenumbersLink to this heading#显示带有行号的文本。
\n例子：
\n{{ value|linenumbers }}\n如果 value 是：
one\ntwo\nthree\n输出将是：
\n1. one\n2. two\n3. three\nljustLink to this heading#左对齐给定宽度的字段中的值。
\n参数： 字段大小
\n例子：
\n"{{ value|ljust:"10" }}"\n如果 value 是 Django，则输出为 "Django "。
lowerLink to this heading#将一个字符串转换为全小写。
\n例子：
\n{{ value|lower }}\n如果 value 是 Totally LOVING this Album!，则输出为 totally loving this album!。
make_listLink to this heading#返回变成列表的值。对于字符串，它是一个字符列表。对于整数来说，在创建列表之前，参数会被转换为一个字符串。
\n例子：
\n{{ value|make_list }}\n如果 value 是字符串 "Joel"，输出将是列表 ['J', 'o', 'e', 'l']。如果 value 是 123，输出将是列表 ['1'，'2'，'3']。
phone2numericLink to this heading#将一个电话号码（可能包含字母）转换为其数字等价物。
\n输入的不一定是有效的电话号码。这将很乐意转换任何字符串。
\n例子：
\n{{ value|phone2numeric }}\n如果 value 是 800-COLLECT，则输出为 800-2655328。
pluralizeLink to this heading#如果值不是 1、'1' 或长度为 1 的对象，则返回复数后缀。 默认情况下，后缀为 's'。
举例：
\nYou have {{ num_messages }} message{{ num_messages|pluralize }}.\n如果 num_messages 是 1，输出将是 You have 1 message. 如果 num_messages 是 2，输出将是 You have 2 messages.。
对于需要后缀而不是 's' 的词，你可以提供一个备用后缀作为过滤器的参数。
举例：
\nYou have {{ num_walruses }} walrus{{ num_walruses|pluralize:"es" }}.\n对于不使用简单后缀进行复数的单词，你可以同时指定单数和复数后缀，并用逗号分隔。
\n举例：
\nYou have {{ num_cherries }} cherr{{ num_cherries|pluralize:"y,ies" }}.\npprintLink to this heading#pprint.pprint() 的一个包装器 —— 真的是用来调试的。
randomLink to this heading#从给定列表中随机返回一个项目。
\n例子：
\n{{ value|random }}\n如果 value 是列表 ['a', 'b', 'c', 'd']，输出可能是 "b"。
rjustLink to this heading#右对齐给定宽度的字段中的值。
\n参数： 字段大小
\n例子：
\n"{{ value|rjust:"10" }}"\n如果 value 是 Django，输出将是 " Django"。
safeLink to this heading#标记一个字符串在输出前不需要进一步的 HTML 转义。当自动转义关闭时，该过滤器没有效果。
\n\nsafeseqLink to this heading#将 safe 过滤器应用于序列的每个元素。与其他对序列进行操作的过滤器，如 join 一起使用。例如：
{{ some_list|safeseq|join:", " }}\n在这种情况下，你不能直接使用 safe 过滤器，因为它会首先将变量转换为字符串，而不是处理序列中的单个元素。
sliceLink to this heading#返回列表的一个片段。
\nUses the same syntax as Python's list slicing. See\nhttps://diveinto.org/python3/native-datatypes.html#slicinglists for an\nintroduction.
\n举例：
\n{{ some_list|slice:":2" }}\n如果 some_list 是 ['a', 'b', 'c']，输出将是 ['a', 'b']。
slugifyLink to this heading#转换为 ASCII 码。将空格转换为连字符。移除非字母数字、下划线或连字符的字符。转换为小写字母。还可以去除前导和尾部的空白。
\n例子：
\n{{ value|slugify }}\n如果 value 是 "Joel is a slug"，那么输出将是 "joel-is-a-slug"。
stringformatLink to this heading#根据参数——字符串格式化指定器，对变量进行格式化。这个指定符使用 printf-style String Formatting 语法，例外的是前面的 “%” 被删除。
\n例子：
\n{{ value|stringformat:"E" }}\n如果 value 是 10，则输出为 1.000000E+01。
timeLink to this heading#根据给定的格式对时间进行格式化。
\n给定的格式可以是预定义的 TIME_FORMAT，也可以是自定义的格式，和 date 过滤器一样。请注意，预定义的格式是依赖于 locale 的。
例子：
\n{{ value|time:"H:i" }}\n如果 value 相当于 datetime.datetime.now()，输出将是字符串 "01:23"。
请注意，如果你想使用 “原始” 值，你可以对格式字符串进行反斜杠转义。在这个例子中，“h” 和 “m” 都被反斜杠转义了，因为如果不这样做，每一个都是一个格式字符串，分别显示小时和月份：
\n{{ value|time:"H\\h i\\m" }}\n这样就会显示为 “01h 23m”。
\n另一个例子：
\n假设 USE_L10N 为 True 和 LANGUAGE_CODE 为例如 "de"，那么对于：
{{ value|time:"TIME_FORMAT" }}\n输出将是字符串 "01:23" （Django 自带的 "TIME_FORMAT" 格式指定符为 "H:i"）。
time 过滤器只接受格式字符串中与一天中的时间有关的参数，而不是日期。如果你需要格式化一个 date 值，请使用 date 过滤器来代替（如果你需要渲染一个完整的 datetime 值，则使用 time）。
上述规则有一个例外。当传递一个附带时区信息的 datetime 值时（一个 时区感知 的 datetime 实例），time 过滤器将接受与时区相关的 格式指定符 'e'、'O'、'T' 和 'Z'。
当没有使用格式字符串时，使用 TIME_FORMAT 格式指定符：
{{ value|time }}\n同为：
\n{{ value|time:"TIME_FORMAT" }}\ntimesinceLink to this heading#将日期格式化为自该日期起的时间（如 “4 days, 6 hours”）。
\n取一个可选参数，该参数是一个变量，包含作为比较点的日期（如果没有该参数，比较点是 现在 ）。例如，如果 blog_date 是代表 2006 年 6 月 1 日午夜的日期实例，comment_date 是 2006 年 6 月 1 日 08:00 的日期实例，那么下面将返回 “8 hours”：
{{ blog_date|timesince:comment_date }}\n比较本地偏移和感知偏移的日期会返回一个空字符串。
\n分钟是使用的最小单位，凡是相对于比较点来说是未来的日期，都会返回 “0 minutes”。
\ntimeuntilLink to this heading#与 timesince 类似，不同的是，它测量的是从现在到给定日期或日期时间的时间。例如，如果今天是 2006 年 6 月 1 日，而 conference_date 是一个持有 2006 年 6 月 29 日的日期实例，那么 {conference_date|timeuntil }} 将返回 “4 weeks”。
取一个可选参数，该参数是一个包含日期的变量，用来作为比较点（而不是 现在）。如果 from_date 包含 2006 年 6 月 22 日，那么下面将返回 “1 week”：
{{ conference_date|timeuntil:from_date }}\n比较本地偏移和感知偏移的日期会返回一个空字符串。
\n分钟是使用的最小单位，相对于比较点而言，任何处于过去的日期都将返回 “0 minutes”。
\ntitleLink to this heading#通过使单词以大写字母开头，其余字符以小写字母开头，将字符串转换为大写字母。这个标签不会努力让 “琐碎的单词” 保持小写。
\n例子：
\n{{ value|title }}\n如果 value 是 "my FIRST post"，则输出将是 "My First Post"。
truncatecharsLink to this heading#如果一个字符串的长度超过指定的字符数，则截断它。截断后的字符串将以一个可翻译的省略号（“...”）结束。
\n参数： 要截断的字符数
\n例子：
\n{{ value|truncatechars:7 }}\n如果 value 是 "Joel is a slug"，则输出将是 "Joel i…"。
truncatechars_htmlLink to this heading#类似于 truncatechars，只是它能识别 HTML 标签。任何在字符串中打开但在截断点之前没有关闭的标签都会在截断后立即关闭。
例子：
\n{{ value|truncatechars_html:7 }}\n如果 value 是 "<p>Joel is a slug</p>"，则输出将是 "<p>Joel i…</p>"。
HTML 内容中的新行将被保留。
\n\n\ntruncatewordsLink to this heading#在一定字数后截断字符串。
\n参数： 要在之后截断的字数
\n例子：
\n{{ value|truncatewords:2 }}\n如果 value 是 "Joel is a slug"，则输出将是 "Joel is …"。
字符串内的新行将被删除。
\ntruncatewords_htmlLink to this heading#类似于 truncatewords，只是它能识别 HTML 标签。任何在字符串中打开的标签，如果在截断点之前没有关闭，则会在截断后立即关闭。
这比 truncatewords 效率低，所以只能在传递 HTML 文本时使用。
例子：
\n{{ value|truncatewords_html:2 }}\n如果 value 是 "<p>Joel is a slug</p>"，则输出将是 "<p>Joel is …</p>"。
HTML 内容中的新行将被保留。
\n\n\nunordered_listLink to this heading#Recursively takes a self-nested list and returns an HTML unordered list --\nWITHOUT opening and closing <ul> tags.
假定列表的格式正确。例如，如果 var 包含 ['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]，那么 {{ var|unordered_list }} 将返回：
<li>States\n<ul>\n <li>Kansas\n <ul>\n <li>Lawrence</li>\n <li>Topeka</li>\n </ul>\n </li>\n <li>Illinois</li>\n</ul>\n</li>\nupperLink to this heading#将一个字符串转换为全大写。
\n例子：
\n{{ value|upper }}\n如果 value 是 "Joel is a slug"，则输出将是 "JOEL IS A SLUG"。
urlencodeLink to this heading#转义一个值用于 URL。
\n例子：
\n{{ value|urlencode }}\n如果 value 是 "https://www.example.org/foo?a=b&c=d"，则输出将是 "https%3A//www.example.org/foo%3Fa%3Db%26c%3Dd"。
可以提供一个可选的参数，包含不应该被转义的字符。
\n如果没有提供，则假定 '/' 字符是安全的。当 所有 字符都应该被转义时，可以提供一个空字符串。例如：
\n{{ value|urlencode:"" }}\n如果 value 是 "https://www.example.org/"，则输出将是 "https%3A%2F%2Fwww.example.org%2F"。
urlizeLink to this heading#将文本中的 URL 和电子邮件地址转换为可点击的链接。
\n这个模板标签适用于以 http://`、``https:// 或 www. 为前缀的链接。例如，https://goo.gl/aia1t 会被转换，但 goo.gl/aia1t 不会。
它还支持以原始顶级域（.com、.edu、.gov、.int、.mil、.net 和 .org）之一结尾的纯域链接。例如，djangoproject.com 被转换。
链接可以有尾部的标点符号（句号、逗号、闭括号），也可以有前面的标点符号（开头的小括号），urlize 仍然会做正确的事情。
urlize 产生的链接有一个 rel="nofollow" 属性。
例子：
\n{{ value|urlize }}\n如果 value 是 "Check out www.djangoproject.com"，则输出将是 "Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproject.com</a>"。
除了网页链接，urlize 还将电子邮件地址转换为 mailto: 链接。如果 value 是 "Send questions to foo@example.com"，输出将是 "Send questions to <a href="mailto:foo@example.com">foo@example.com</a>"。
urlize 过滤器还可以使用一个可选的参数 autoescape。如果 autoescape 为 True，则链接文本和 URL 将使用 Django 内置的 escape 过滤器进行转义。autoescape 的默认值是 True。
urlizetruncLink to this heading#像 urlize 一样，将 URL 和电子邮件地址转换为可点击的链接，但会截断长于给定字符限制的 URL。
\n参数： 链接文本应截断的字符数，包括必要时添加的省略号。
\n例子：
\n{{ value|urlizetrunc:15 }}\n如果 value 是 "Check out www.djangoproject.com"，则将输出 'Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproj…</a>'。
和 urlize 一样，这个过滤器只能应用于纯文本。
\nwordcountLink to this heading#返回单词的数量。
\n例子：
\n{{ value|wordcount }}\n如果 value 是 "Joel is a slug"，则输出将是 4。
wordwrapLink to this heading#以指定的行长度包装文字。
\n参数： 包裹文本的字符数
\n例子：
\n{{ value|wordwrap:5 }}\n如果 value 是 Joel is a slug，则输出将是：
Joel\nis a\nslug\nyesnoLink to this heading#将 True、False 和（可选的） None 值映射到字符串 “yes”、“no”、“maybe” 或以逗号分隔的列表形式传递的自定义映射，并根据值返回其中一个字符串。
例子：
\n{{ value|yesno:"yeah,no,maybe" }}\n值 | \n参数 | \n输出 | \n
|---|---|---|
| \n\n |
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n