本文档描述了 Django 内置的模板标签和过滤器。如果有的话，建议你使用 自动化文档，因为它也会包含安装的任何自定义标签或过滤器的文档。
\nautoescapeLink to this heading#控制当前的自动转义行为。该标签以 on 或 off 作为参数，决定块内是否有自动转义行为。此区块以 endautoescape 结束标签关闭。
示例用法：
\n{% autoescape on %}\n {{ body }}\n{% endautoescape %}\n当自动转义生效时，从变量派生的所有内容在将结果放入输出之前都会应用 HTML 转义（但在应用任何过滤器之后）。这相当于手动对每个变量应用 escape 过滤器。
唯一的例外是已经标记为不需要转义的变量。变量可以通过填充变量的代码、应用 safe 或 escape 过滤器，或者因为它是以前的过滤器将字符串标记为 "safe" 的结果而被标记为 "safe"。
在禁用自动转义的范围内，链式过滤器，包括 escape，可能会导致意外的（但已记录的）结果，例如以下示例：
{% autoescape off %}\n {{ my_list|join:", "|escape }}\n{% endautoescape %}\n上述代码将输出未经转义的 my_list 的连接元素。这是因为过滤器链序列首先在 my_list 上执行 join （由于 autoescape 为 off，不对每个项目应用转义），将结果标记为安全。随后，将安全结果提供给 escape 过滤器，该过滤器不会应用第二轮转义。
为了正确地转义序列中的每个元素，请使用 escapeseq 过滤器：
{% autoescape off %}\n {{ my_list|escapeseq|join:", " }}\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 保护，如 跨站点请求伪造 的文档中所述。
\ncsp_nonce_attrLink to this heading#When called without arguments, renders a nonce="<value>" HTML attribute\nwhen the csp() context processor is\nconfigured, and an empty string otherwise. Use it in <script> or\n<link> elements to allow them under a nonce-based Content Security Policy:
<script src="/path/to/script.js" {% csp_nonce_attr %}></script>\n<link rel="stylesheet" href="/path/to/style.css" {% csp_nonce_attr %}>\nWhen called with a Media object as the argument,\nrenders its assets with the CSP nonce applied to each <script> and\n<link> element:
{% csp_nonce_attr form.media %}\nIn both forms, if the context processor is not configured, assets are rendered\nwithout a nonce attribute.
\nSee Nonce usage for full configuration details.
\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 %}\nVariables included in the cycle will be escaped. You can disable auto-escaping\nwith:
\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> 元素之外发出。
当在循环定义上使用静默关键字时，静默会自动应用于该特定循环标记的所有后续使用。即使第二次调用 {% cycle %} 没有指定 silent，以下模板也会输出 nothing：
{% cycle 'row1' 'row2' as rowcolors silent %}\n{% cycle rowcolors %}\n你可以使用 resetcycle 标签使 {% cycle %} 标签在下次遇到时从第一个值重新开始。
debugLink to this heading#在 DEBUG 设置为 False 时，输出大量的调试信息，包括当前上下文和导入的模块。{% debug %} 在这种情况下不会输出任何内容。
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
| \nThe length of the loop | \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"（即存在，不为空，并且不是假布尔值），则输出块的内容：
{% 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 ...\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#加载一个模板，并在当前上下文中进行渲染。这是一种在模板中 “包含” 其他模板的方式。
\nThe template name can either be a variable or a hardcoded (quoted) string,\nin either single or double quotes.
\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例如，以下模板将加载位于包 package 中的 somelibrary 和 otherlibrary 中注册的所有标签和过滤器：
{% load somelibrary package.otherlibrary %}\n你还可以使用 from 参数有选择地从库中加载单个过滤器或标签。在这个例子中，将从 somelibrary 中加载名为 foo 和 bar 的模板标签/过滤器：
{% 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 %}\npartialLink to this heading#Renders a template fragment that was defined with partialdef, inserting\nthe matching partial at this location.
用法：
\n{% partial partial_name %}\nThe partial_name argument is the name of the template fragment to render.
In the following example, a partial named button is defined and then\nrendered three times:
{% partialdef button %}\n <button>Submit</button>\n{% endpartialdef %}\n\n{% partial button %}\n{% partial button %}\n{% partial button %}\npartialdefLink to this heading#Defines a reusable template fragment that can be rendered multiple times within\nthe same template or accessed directly via template loading or inclusion.
\n用法：
\n{% partialdef partial_name %}\n {# Reusable content. #}\n{% endpartialdef %}\nThe partial_name argument is required and must be a valid template\nidentifier.
In the following example, a new fragment named card is defined:
{% partialdef card %}\n <div class="card">\n <h3>{{ title }}</h3>\n <p>{{ content }}</p>\n </div>\n{% endpartialdef %}\nThis partial can then be rendered using the partial tag:
{% partial card %}\n{% partial card %}\nTo render a fragment immediately in place,\nuse the inline option. The partial is still stored and can be reused later.
querystringLink to this heading#根据提供的参数输出一个 URL 编码的格式化查询字符串。
\nThis tag accepts positional arguments, which must be mappings (such as\nQueryDict or dict). If no positional arguments\nare provided, request.GET is used as the\ndefault to construct the query string.
Positional arguments are processed sequentially, while keyword arguments are\ntreated as key-value pairs, applied last. Later arguments take precedence over\nearlier ones, ensuring the most recent pairs are reflected in the final result.
\nThe result always includes a leading "?" since this tag is mainly used for\nlinks, and an empty result could prevent the page from reloading as expected.
{% querystring %}\nOutputs the current query string verbatim. So if the query string in the\nrequest is ?color=green, the output would be ?color=green. If the\ncurrent query string is empty, the output will be ?.
{% querystring size="M" %}\n输出当前查询字符串并添加 size 参数。根据前面的示例，输出为 ?color=green&size=M。
{% querystring color="red" size="S" %}\n添加或修改查询字符串中的参数。每个关键字参数将被添加到查询字符串中，替换该键的任何现有值。例如，如果当前查询字符串是 ?color=green，输出将是 ?color=red&size=S。
{% querystring color=None %}\n将 None 作为值传递会从查询字符串中删除该参数。例如，如果当前查询字符串是 ?color=green&size=M，输出将是 ?size=M。
{% querystring color=my_list %}\n如果 my_list 是 ["red", "blue"]，输出将是 ?color=red&color=blue，在查询字符串中保留列表结构。
You can pass custom QueryDict or dict instances as positional arguments\nto replace request.GET. When multiple arguments are provided, key-value\npairs from later arguments take precedence over earlier ones.
For example, if my_query_dict is <QueryDict: {'color': ['blue'], 'size':\n['S']}> and my_dict is {'color': 'orange', 'fabric': 'silk', 'type':\n'dress'}, this outputs ?color=orange&size=S&fabric=silk.
{% querystring my_query_dict my_dict size="S" type=None %}\nIf all keys are removed by setting them to None, this outputs ?:
{% querystring my_query_dict my_dict color=None size=None fabric=None type=None %}\nSimilarly, if all positional arguments are empty and keyword arguments do not\ncontribute any new params, the output will also be ?.
使用此标签的一个常见示例是在显示结果页面时保留当前查询字符串，同时添加指向下一页和上一页结果的链接。例如，如果分页器当前位于第 3 页，且当前查询字符串为 ?color=blue&size=M&page=3，以下代码将输出 ?color=blue&size=M&page=4：
{% querystring page=page.next_page_number %}\n你也可以将值存储在变量中。例如，如果需要多个指向同一页面的链接，可以将其定义为：
\n{% querystring page=page.next_page_number as next_page %}\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 %} produces a list (in this case, country_list) of\ngroup objects. Group objects are instances of\nnamedtuple() with two fields:
grouper —— 被分组的项目（例如，“India” 或 “Japan” 等字符串）。
list —— 本组所有项目的清单（例如，country='India' 的所有城市的清单）。
Because {% regroup %} produces namedtuple() objects,\nyou can also write the previous example as:
{% 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对于 regroup 标签，任何有效的模板查找都是合法的分组属性，包括方法、属性、字典键和列表项。例如，如果 "country" 字段是一个外键，指向一个带有属性 "description" 的类，你可以这样使用：
{% 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>Gareth</h1>\n<p class="odd">Harry</p>\n<p class="even">John</p>\n<p class="odd">Nick</p>\n\n<h1>John</h1>\n<p class="odd">Andrea</p>\n<p class="even">Melissa</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#输出用于组成模板标签的语法字符之一。
\n模板系统没有“转义”单个字符的概念。但是，你可以使用 {% templatetag %} 标签来显示其中一个模板标记字符组合。
这个参数告诉我们要输出哪个模板位：
\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.\n另请参阅 verbatim 标签以了解包含这些字符的另一种方式。
urlLink to this heading#返回与给定视图和可选参数相匹配的绝对路径引用（不含域名的 URL）。路径中的任何特殊字符将使用 iri_to_uri() 进行编码。
This is a way to output links without violating the DRY principle by having to\nhardcode URLs in your templates:
\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常见的用法是允许一个与 Django 语法冲突的 JavaScript 模板层。例如：
\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#根据给定的格式设置日期。
\n使用与 PHP 的 date() 函数类似的格式，但有一些差异。
\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 |
| \n年，2 位带前导零的数字。 | \n
| \n
| \n年，4 位带前导零的数字。 | \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
| \n夏令时，无论是否生效。 | \n
| \n
| \n与格林威治时间的时差。 | \n
| \n
| \n本机的时区。 | \n
| \n
| \n时区偏移以秒为单位。UTC 以西的时区偏移总是负数，UTC 以东的时区偏移总是正数。 | \n
| \n
日期／时间 | \n\n | \n |
| \nISO 8601 格式。 （注意：与“Z”、“O”或“r”等其他格式化程序不同，如果值是原始日期时间，“c”格式化程序将不会添加时区偏移量（参见 | \n
| \n
| \nRFC 5322 格式的日期。 | \n
| \n
| \n自 Unix 纪元（1970 年 1 月 1 日 00:00:00 UTC）以来的秒数。 | \n\n |
例如：
\n{{ value|date:"D d M Y" }}\nIf value is a datetime object (e.g., the result of\ndatetime.datetime.now()), the output will be the string\n'Wed 09 Jan 2008'.
传递的格式可以是预定义的 DATE_FORMAT、DATETIME_FORMAT、SHORT_DATE_FORMAT 或 SHORT_DATETIME_FORMAT, 或者是使用上表中显示的格式指定器的自定义格式。请注意，预定义的格式可能会根据当前的 locale 而有所不同。
假设 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" }}\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 过滤器。
例如，当 autoescape 关闭时，你可以对字段应用 escape：
{% autoescape off %}\n {{ title|escape }}\n{% endautoescape %}\nescapejsLink to this heading#将字符转义以用作整个 JavaScript 字符串文字，可以用单引号或双引号，如下所示。此过滤器不会使字符串适用于 "JavaScript 模板文字" （JavaScript 反引号语法）。不支持上面未列出的任何其他用途。通常建议将数据传递使用 HTML data- 属性或 json_script 过滤器，而不是在嵌入的 JavaScript 中使用。
例如：
\n<script>\nlet myValue = '{{ value|escapejs }}'\nescapeseqLink to this heading#将 escape 过滤器应用于序列的每个元素。与其他操作序列的过滤器（如 join）结合使用时非常有用。例如：
{% autoescape off %}\n {{ my_list|escapeseq|join:", " }}\n{% endautoescape %}\nfilesizeformatLink 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
如果传递给 floatformat 的参数具有 g 后缀，它将强制使用当前区域设置的 THOUSAND_SEPARATOR 进行分组。例如，当活动区域设置为 en （英语）时：
| \n模板 | \n输出 | \n
|---|---|---|
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
| \n
输出始终是本地化的（与 {% localize off %} 标签无关），除非传递给 floatformat 的参数具有 u 后缀，这将强制禁用本地化。例如，当活动区域设置为 pl （波兰语）时：
| \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=I ♥ Django"，则输出将是 "?test=I%20%E2%99%A5%20Django"。
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 一起使用。
参数： 可选的 <script> 标签的 HTML "id"。
例如：
\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这与严格的内容安全策略兼容，禁止在页面中执行脚本。它还保持了被动数据和可执行代码之间的明确分离。
\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。
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#返回列表的一个片段。
\n使用与 Python 的列表切片相同的语法。有关介绍，请参阅 Python 文档。
\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假设 LANGUAGE_CODE 是，例如，"de"，那么对于：
{{ value|time:"TIME_FORMAT" }}\n输出将是字符串 "01:23" （Django 自带的 "TIME_FORMAT" 格式指定符为 "H:i"）。
The time filter will only accept parameters in the format string that\nrelate to the time of day, not the date. If you need to format a date\nvalue, use the date filter instead (or along with time if\nyou need to render a full datetime value).
上述规则有一个例外。当传递一个附带时区信息的 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 日上午 8:00 的日期实例，那么以下代码将返回 "8 小时"：
{{ 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 周"：
{{ 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\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\nunordered_listLink to this heading#递归地接受一个自我嵌套的列表，并返回一个 HTML 无序列表 -- 不包括 开启和关闭的 <ul> 标签。
假设列表的格式是正确的。例如，如果 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://djangocon.eu 会被转换，但 djangocon.eu 不会。
它还支持以原始顶级域（.com、.edu、.gov、.int、.mil、.net 和 .org）之一结尾的纯域链接。例如，djangoproject.com 被转换。
链接可以有尾部的标点符号（句号、逗号、闭括号），也可以有前面的标点符号（开头的小括号），urlize 仍然会做正确的事情。
urlize 产生的链接有一个 rel="nofollow" 属性。
例如：
\n{{ value|urlize }}\nIf value is "Check out www.djangoproject.com", the output will be:
Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproject.com</a>\n除了网页链接，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 }}\nIf value is "Check out www.djangoproject.com", the output would be:
Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproj…</a>\n和 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