autoescape¶

控制当前的自动转义行为。此标签接受 on 或 off 作为参数，并以此确定自动转义是否在块内生效。该块以 endautoescape 结束标签关闭。

示例用法

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

当自动转义生效时，从变量派生的所有内容在将结果放入输出之前都会应用 HTML 转义（但在应用任何过滤器之后）。这等同于手动将escape 过滤器应用于每个变量。

唯一的例外是已标记为“安全”以防止转义的变量。变量可以通过填充变量的代码、通过应用safe 或escape 过滤器，或者因为它是由先前将字符串标记为“安全”的过滤器产生的结果来标记为“安全”的。

在禁用自动转义的范围内，链接过滤器（包括escape）可能会导致意外（但有记录的）结果，例如以下情况

{% autoescape off %}
    {{ my_list|join:", "|escape }}
{% endautoescape %}

以上代码将输出 my_list 的联接元素，且未转义。这是因为过滤器链接序列首先对 my_list 执行 join（由于 autoescape 为 off，因此不会对每个项目应用转义），并将结果标记为安全。随后，此安全结果将被馈送到 escape 过滤器，该过滤器不会应用第二轮转义。

为了正确转义序列中的每个元素，请使用escapeseq 过滤器

{% autoescape off %}
    {{ my_list|escapeseq|join:", " }}
{% endautoescape %}

block¶

定义一个可以被子模板覆盖的块。有关更多信息，请参见模板继承。

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¶

此标签用于 CSRF 保护，如跨站点请求伪造的文档中所述。

cycle¶

每次遇到此标签时都会生成其参数之一。第一次遇到时生成第一个参数，第二次遇到时生成第二个参数，依此类推。一旦所有参数都用尽，标签就会循环到第一个参数并再次生成它。

此标签在循环中特别有用

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

第一次迭代生成引用类 row1 的 HTML，第二次迭代生成引用类 row2 的 HTML，第三次迭代再次生成引用类 row1 的 HTML，依此类推，循环的每次迭代都如此。

您也可以使用变量。例如，如果您有两个模板变量 rowvalue1 和 rowvalue2，则可以像这样在它们的值之间交替

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

循环中包含的变量将被转义。您可以使用以下方法禁用自动转义：

{% 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 %} 的用法本身将生成循环中的第一个值。如果您想在嵌套循环或包含的模板中使用该值，则这可能是一个问题。如果您只想声明循环而不生成第一个值，可以在标签中添加 silent 关键字作为最后一个关键字。例如

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

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

当在循环定义上使用 silent 关键字时，静默将自动应用于随后对该特定循环标签的所有使用。以下模板将输出无，即使对 {% cycle %} 的第二次调用未指定 silent

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

您可以使用resetcycle 标签使 {% cycle %} 标签在下一次遇到时从其第一个值重新开始。

debug¶

输出大量调试信息，包括当前上下文和导入的模块。{% debug %} 在DEBUG 设置为 False 时不会输出任何内容。

extends¶

表示此模板扩展了父模板。

此标签可以以两种方式使用

• {% extends "base.html" %}（带引号）使用字面值 "base.html" 作为要扩展的父模板的名称。

• {% extends variable %} 使用 variable 的值。如果变量计算结果为字符串，则 Django 将使用该字符串作为父模板的名称。如果变量计算结果为 Template 对象，则 Django 将使用该对象作为父模板。

有关更多信息，请参见模板继承。

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

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

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

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

filter¶

通过一个或多个过滤器过滤块的内容。可以使用管道指定多个过滤器，并且过滤器可以具有参数，就像在变量语法中一样。

请注意，该块包含 filter 和 endfilter 标签之间的所有文本。

示例用法

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

firstof¶

输出第一个不是“假”的参数变量（即存在、不为空、不是假布尔值，且不是零数值）。如果所有传递的变量都是“假”，则不输出任何内容。

示例用法

{% firstof var1 var2 var3 %}

这等价于

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

您还可以使用文字字符串作为回退值，以防所有传递的变量都为 False

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

此标签会自动转义变量值。您可以使用以下方法禁用自动转义：

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

或者，如果只需要转义某些变量，可以使用：

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

可以使用语法 {% firstof var1 var2 var3 as value %} 将输出存储在变量中。

for¶

循环遍历数组中的每个项目，使该项目在上下文变量中可用。例如，要显示在 athlete_list 中提供的运动员列表

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

您可以使用 {% for obj in list reversed %} 反向循环遍历列表。

如果需要循环遍历列表的列表，可以将每个子列表中的值解包到各个变量中。例如，如果您的上下文中包含一个名为 points 的 (x,y) 坐标列表，则可以使用以下方法输出点列表

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

如果需要访问字典中的项目，这也很有用。例如，如果您的上下文中包含一个字典 data，则以下内容将显示字典的键和值

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

请记住，对于点运算符，字典键查找优先于方法查找。因此，如果 data 字典包含一个名为 'items' 的键，则 data.items 将返回 data['items'] 而不是 data.items()。如果您想在模板中使用这些方法，请避免添加与字典方法同名的键（items、values、keys 等）。有关点运算符的查找顺序的更多信息，请参阅 模板变量文档。

for 循环设置了在循环内可用的多个变量

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 %} 标签评估一个变量，如果该变量为“真”（即存在、不为空，且不是假布尔值），则输出块的内容

{% 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 }} 变量将显示运动员的数量。

如您所见，if 标签可以带有一个或多个 {% elif %} 子句，以及一个 {% else %} 子句，如果所有先前的条件都失败，则将显示该子句。这些子句是可选的。

{% 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 %}

{% if athlete_list and coach_list or cheerleader_list %}

if (athlete_list and coach_list) or cheerleader_list:
    ...

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

{% 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 %}

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

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

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

{% 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 %}

{% 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 %}

{% 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 %}

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

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

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

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

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

ifchanged¶

检查循环的上次迭代中某个值是否发生变化。

{% ifchanged %} 块标签用于循环内。它有两种可能的用途。

1. 检查其自身渲染的内容与其之前状态是否一致，并且仅在内容发生变化时显示内容。例如，这将显示一个日期列表，仅在月份发生变化时显示月份。

   <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 %}
   

2. 如果给定一个或多个变量，则检查是否有任何变量发生变化。例如，以下示例在每次日期变化时显示日期，而在小时或日期发生变化时显示小时。

   {% 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 标签所述的 ./ 或 ../ 开始的相对路径。

此示例包含变量 template_name 中包含的模板的内容。

{% include template_name %}

变量也可以是任何具有 render() 方法的对象，该方法接受上下文。这允许您在上下文中引用已编译的 Template。

此外，变量可以是模板名称的可迭代对象，在这种情况下，将使用第一个可以加载的模板名称，如 select_template() 所述。

包含的模板在其包含的模板的上下文中进行渲染。此示例生成输出 "Hello, John!"。

• 上下文：变量 person 设置为 "John"，变量 greeting 设置为 "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 %}

load¶

加载自定义模板标签集。

例如，以下模板将加载在包 package 中的 somelibrary 和 otherlibrary 中注册的所有标签和过滤器。

{% load somelibrary package.otherlibrary %}

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

{% load foo bar from somelibrary %}

有关更多信息，请参阅 自定义标签和过滤器库。

lorem¶

显示随机的“Lorem ipsum”拉丁文文本。这对于在模板中提供示例数据很有用。

用法

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

{% lorem %} 标签可以带零个、一个、两个或三个参数。参数如下：

示例

• {% lorem %} 将输出常见的“Lorem ipsum”段落。

• {% lorem 3 p %} 将输出常见的“Lorem ipsum”段落和两个随机段落，每个段落都用 HTML <p> 标签包装。

• {% lorem 2 w random %} 将输出两个随机的拉丁文字。

now¶

显示当前日期和/或时间，使用根据给定字符串的格式。此类字符串可以包含 date 过滤器部分中所述的格式说明符字符。

示例

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

请注意，如果要使用“原始”值，则可以使用反斜杠转义格式字符串。在此示例中，“o”和“f”都使用反斜杠转义，因为否则每个都是一个分别显示年份和时间的格式字符串。

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

这将显示为“It is the 4th of September”。

It is {% now "SHORT_DATETIME_FORMAT" %}

您还可以使用语法 {% now "Y" as current_year %} 将输出（作为字符串）存储在变量中。如果您想在像 blocktranslate 这样的模板标签中使用 {% now %}，这将非常有用。

{% now "Y" as current_year %}
{% blocktranslate %}Copyright {{ current_year }}{% endblocktranslate %}

querystring¶

根据提供的参数输出 URL 编码格式的查询字符串。

此标签需要一个 QueryDict 实例，如果未提供，则默认为 request.GET。

如果 QueryDict 为空且未提供其他参数，则返回空字符串。非空结果包含前导 "?"。

{% querystring %}

{% querystring size="M" %}

{% querystring my_query_dict %}

{% querystring color="red" size="S" %}

{% querystring color=None %}

{% querystring color=my_list %}

{% querystring page=page.next_page_number %}

{% querystring page=page.next_page_number as next_page %}

regroup¶

根据共同属性对相似对象的列表进行分组。

此复杂标签最好通过示例来说明：假设cities是城市列表，由包含"name"、"population"和"country"键的字典表示

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属性对cities列表进行重新分组，并将结果称为country_list。

{% regroup %}生成一个组对象列表（在本例中为country_list）。组对象是namedtuple()的实例，具有两个字段

• grouper – 已分组的项目（例如，字符串“印度”或“日本”）。

• list – 此组中所有项目的列表（例如，所有国家/地区为“印度”的城市列表）。

因为{% regroup %}生成namedtuple()对象，您还可以将前面的示例编写为

{% 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排序。如果cities列表*没有*按country对其成员进行排序，则重新分组将简单地为单个国家/地区显示多个组。例如，假设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 cities by country.description as country_list %}

{% regroup cities by get_country_display as country_list %}

resetcycle¶

重置之前的cycle，以便在下次遇到时从其第一个项目重新开始。如果没有参数，{% 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>Gareth</h1>
<p class="odd">Harry</p>
<p class="even">John</p>
<p class="odd">Nick</p>

<h1>John</h1>
<p class="odd">Andrea</p>
<p class="even">Melissa</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>

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

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

templatetag¶

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

模板系统没有“转义”单个字符的概念。但是，您可以使用{% templatetag %}标签显示模板标签字符组合之一。

参数指示要输出哪个模板位

示例用法

The {% templatetag openblock %} characters open a block.

另请参阅 verbatim 标签，了解包含这些字符的另一种方法。

url¶

返回与给定视图和可选参数匹配的绝对路径引用（不含域名）。结果路径中的任何特殊字符都将使用 iri_to_uri() 进行编码。

这是一种在不违反 DRY 原则的情况下输出链接的方法，避免在模板中硬编码 URL。

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

第一个参数是 URL 模式名称。它可以是带引号的文字或任何其他上下文变量。其他参数是可选的，应该是空格分隔的值，这些值将用作 URL 中的参数。上面的示例显示了传递位置参数。或者，您可以使用关键字语法。

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

不要在一个调用中混合使用位置和关键字语法。URLconf 所需的所有参数都应存在。

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

path("client/<int:id>/", app_views.client, name="app-views-client")

如果该应用程序的 URLconf 包含在项目的 URLconf 中，路径如下所示：

path("clients/", include("project_name.app_name.urls"))

…那么，在模板中，您可以像这样创建指向此视图的链接：

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

模板标签将输出字符串 /clients/client/123/。

请注意，如果要反转的 URL 不存在，则会引发 NoReverseMatch 异常，这将导致您的网站显示错误页面。

如果要检索 URL 但不显示它，可以使用略微不同的调用：

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

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

as var 语法创建的变量的作用域是出现 {% url %} 标签的 {% block %}。

如果视图缺失，则 {% url ... as var %} 语法**不会**导致错误。在实践中，您将使用此语法链接到可选的视图。

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

如果要检索命名空间 URL，请指定完全限定名称：

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

这将遵循正常的 命名空间 URL 解析策略，包括使用上下文提供的任何有关当前应用程序的提示。

verbatim¶

停止模板引擎呈现此块标签的内容。

一个常见的用法是允许与 Django 语法冲突的 JavaScript 模板层。例如：

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

您还可以指定一个特定的结束标签，允许使用 {% endverbatim %} 作为未呈现内容的一部分。

{% 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 %}">

如果 this_value 是 175，max_value 是 200，max_width 是 100，则上面示例中的图像将为 88 像素宽（因为 175/200 = .875；.875 * 100 = 87.5，向上取整为 88）。

在某些情况下，您可能希望将 widthratio 的结果捕获到一个变量中。例如，这在 blocktranslate 中很有用：

{% widthratio this_value max_value max_width as width %}
{% blocktranslate %}The width is: {{ width }}{% endblocktranslate %}

with¶

将复杂变量缓存到更简单的名称下。当多次访问“昂贵”方法（例如，访问数据库的方法）时，这很有用。

例如：

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

填充的变量（在上面的示例中为 total）仅在 {% with %} 和 {% endwith %} 标签之间可用。

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

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

add¶

将参数添加到值。

例如：

{{ value|add:"2" }}

如果 value 是 4，则输出将为 6。

此过滤器将首先尝试将两个值强制转换为整数。如果失败，它会尝试将值加在一起。这适用于某些数据类型（字符串、列表等），而对其他数据类型则会失败。如果失败，结果将为空字符串。

例如，如果我们有：

{{ first|add:second }}

并且 first 是 [1, 2, 3] 且 second 是 [4, 5, 6]，则输出将为 [1, 2, 3, 4, 5, 6]。

addslashes¶

在引号前添加斜杠。例如，用于转义 CSV 中的字符串。

例如：

{{ value|addslashes }}

如果 value 是 "I'm using Django"，则输出将为 "I\'m using Django"。

capfirst¶

将值的首字母大写。如果首字母不是字母，则此过滤器无效。

例如：

{{ value|capfirst }}

如果 value 是 "django"，则输出将为 "Django"。

center¶

将值居中在给定宽度的字段中。

例如：

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

如果 value 是 "Django"，则输出将为 "     Django    "。

cut¶

从给定字符串中删除所有 arg 的值。

例如：

{{ value|cut:" " }}

如果 value 是 "String with spaces"，则输出将为 "Stringwithspaces"。

date¶

根据给定格式格式化日期。

使用类似于 PHP 的 date() 函数的格式，但有一些差异。

可用的格式字符串

例如：

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

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

传递的格式可以是预定义格式之一 DATE_FORMAT、DATETIME_FORMAT、SHORT_DATE_FORMAT 或 SHORT_DATETIME_FORMAT，也可以是使用上表中显示的格式说明符的自定义格式。请注意，预定义格式可能会因当前区域设置而异。

假设 LANGUAGE_CODE 为“es”，则对于

{{ value|date:"SHORT_DATE_FORMAT" }}

输出将是字符串 "09/01/2008"（随 Django 提供的 es 区域设置的 "SHORT_DATE_FORMAT" 格式说明符为 "d/m/Y"）。“d”和“e”都使用反斜杠转义，否则每个都是显示日期和时区名称的格式字符串。

在不使用格式字符串的情况下，将使用 DATE_FORMAT 格式说明符。假设与上一个示例相同的设置

{{ value|date }}

输出 9 de Enero de 2008（es 区域设置的 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" }}

default¶

如果 value 评估为 False，则使用给定的默认值。否则，使用该值。

例如：

{{ value|default:"nothing" }}

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

default_if_none¶

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

请注意，如果给出空字符串，则不会使用默认值。如果要为空字符串回退，请使用 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" }}

不支持根据指定索引处的元素对字典进行排序。

dictsortreversed¶

获取字典列表并返回根据参数中给定的键按反序排序的该列表。这与上述过滤器的工作原理完全相同，但返回值将按反序排列。

divisibleby¶

如果 value 可被参数整除，则返回 True。

例如：

{{ value|divisibleby:"3" }}

如果value的值为21，则输出结果为True。

escape¶

对字符串进行HTML转义。具体来说，它会进行以下替换

• < 转换为 <

• > 转换为 >

• '（单引号）转换为 '

• "（双引号）转换为 "

• & 转换为 &

将escape应用于一个变量，该变量通常会对结果应用自动转义，只会导致进行一轮转义。因此，即使在自动转义环境中使用此函数也是安全的。如果希望应用多次转义，请使用force_escape过滤器。

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

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

escapejs¶

转义字符以用于整个JavaScript字符串文字，在单引号或双引号内，如下所示。此过滤器不会使字符串安全地用于“JavaScript模板文字”（JavaScript反引号语法）。上面未列出的任何其他用途均不受支持。通常建议使用HTML data-属性或json_script过滤器传递数据，而不是嵌入在JavaScript中。

例如：

<script>
let myValue = '{{ value|escapejs }}'

escapeseq¶

将escape过滤器应用于序列的每个元素。与对序列进行操作的其他过滤器（例如join）结合使用很有用。例如

{% autoescape off %}
    {{ my_list|escapeseq|join:", " }}
{% endautoescape %}

filesizeformat¶

将值格式化为类似“人类可读”的文件大小（即'13 KB'、'4.1 MB'、'102 bytes'等）。

例如：

{{ value|filesizeformat }}

如果value的值为123456789，则输出结果为117.7 MB。

first¶

返回列表中的第一个项目。

例如：

{{ value|first }}

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

floatformat¶

在不带参数使用时，会将浮点数四舍五入到小数点后一位 - 但仅当有小数部分需要显示时。例如

如果使用数字整数参数，则floatformat会将数字四舍五入到指定的小数位数。例如

特别有用的是传递0（零）作为参数，这会将浮点数四舍五入到最接近的整数。

如果传递给floatformat的参数为负数，则会将数字四舍五入到指定的小数位数 - 但仅当有小数部分需要显示时。例如

如果传递给floatformat的参数具有g后缀，则它将强制根据活动区域设置的THOUSAND_SEPARATOR进行分组。例如，当活动区域设置是en（英语）时

输出始终是本地化的（独立于{% localize off %}标记），除非传递给floatformat的参数具有u后缀，这将强制禁用本地化。例如，当活动区域设置是pl（波兰语）时

不带参数使用floatformat等效于使用参数为-1的floatformat。

force_escape¶

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

例如，如果您想捕获linebreaks过滤器创建的<p> HTML元素

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

get_digit¶

给定一个整数，返回请求的数字，其中1是最右边的数字，2是第二右边的数字，依此类推。对于无效输入返回原始值（如果输入或参数不是整数，或者参数小于1）。否则，输出始终为整数。

例如：

{{ value|get_digit:"2" }}

如果value的值为123456789，则输出结果为8。

iriencode¶

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

对已通过urlencode过滤器处理的字符串使用此过滤器是安全的。

例如：

{{ value|iriencode }}

如果value的值为"?test=I ♥ Django"，则输出结果为"?test=I%20%E2%99%A5%20Django"。

join¶

使用字符串连接列表，类似于Python的str.join(list)

例如：

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

如果value是列表['a', 'b', 'c']，则输出将是字符串"a // b // c"。

json_script¶

安全地将 Python 对象输出为 JSON，并将其包装在<script>标签中，以便与 JavaScript 一起使用。

参数：<script>标签的可选 HTML “id”。

例如：

{{ value|json_script:"hello-data" }}

如果value是字典{'hello': 'world'}，则输出将是

<script id="hello-data" type="application/json">{"hello": "world"}</script>

可以在 JavaScript 中这样访问生成的数据

const value = JSON.parse(document.getElementById('hello-data').textContent);

通过转义字符“<”、“>”和“&”来缓解 XSS 攻击。例如，如果value是{'hello': 'world</script>&amp;'}，则输出为

<script id="hello-data" type="application/json">{"hello": "world\\u003C/script\\u003E\\u0026amp;"}</script>

这与禁止页面内脚本执行的严格内容安全策略兼容。它还保持了被动数据和可执行代码之间的清晰分离。

last¶

返回列表中的最后一项。

例如：

{{ value|last }}

如果value是列表['a', 'b', 'c', 'd']，则输出将是字符串"d"。

length¶

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

例如：

{{ value|length }}

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

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

linebreaks¶

将纯文本中的换行符替换为相应的 HTML；单个换行符将变成 HTML 换行符(<br>)，而换行符后跟一个空行将变成段落分隔符(</p>)。

例如：

{{ value|linebreaks }}

如果value是Joel\nis a slug，则输出将为<p>Joel<br>is a slug</p>。

linebreaksbr¶

将纯文本中所有换行符转换为 HTML 换行符(<br>)。

例如：

{{ value|linebreaksbr }}

如果value是Joel\nis a slug，则输出将为Joel<br>is a slug。

linenumbers¶

显示带有行号的文本。

例如：

{{ value|linenumbers }}

如果 value 为

one
two
three

输出将是

1. one
2. two
3. three

ljust¶

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

参数：字段大小

例如：

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

如果value是Django，则输出将是"Django    "。

lower¶

将字符串转换为全小写。

例如：

{{ value|lower }}

如果value是Totally LOVING this Album!，则输出将是totally loving this album!。

make_list¶

返回值转换为列表。对于字符串，它是字符列表。对于整数，在创建列表之前，参数将被转换为字符串。

例如：

{{ value|make_list }}

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

phone2numeric¶

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

输入不必是有效的电话号码。这将愉快地转换任何字符串。

例如：

{{ value|phone2numeric }}

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

pluralize¶

如果值为1、'1'或长度为 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" }}.

pprint¶

pprint.pprint()的包装器——实际上用于调试。

random¶

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

例如：

{{ value|random }}

如果value是列表['a', 'b', 'c', 'd']，则输出可能是"b"。

rjust¶

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

参数：字段大小

例如：

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

如果value是Django，则输出将是"    Django"。

safe¶

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

{{ var|safe|escape }}

safeseq¶

将safe过滤器应用于序列的每个元素。与对序列进行操作的其他过滤器（如join）结合使用时非常有用。例如

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

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

slice¶

返回列表的切片。

使用与 Python 列表切片相同的语法。有关介绍，请参阅Python 文档。

示例

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

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

slugify¶

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

例如：

{{ value|slugify }}

如果value的值为"Joel is a slug"，则输出将为"joel-is-a-slug"。

stringformat¶

根据参数（一个字符串格式化说明符）格式化变量。此说明符使用printf 样式字符串格式化语法，但省略了开头的“%”。

例如：

{{ value|stringformat:"E" }}

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

striptags¶

尽一切努力去除所有 [X]HTML 标签。

例如：

{{ value|striptags }}

如果value的值为"<b>Joel</b> <button>is</button> a <span>slug</span>"，则输出将为"Joel is a slug"。

time¶

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

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

例如：

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

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

请注意，如果要使用“原始”值，您可以使用反斜杠转义格式字符串。在此示例中，“h”和“m”都使用反斜杠转义，因为否则每个都是一个格式字符串，分别显示小时和月份

{{ value|time:"H\h i\m" }}

这将显示为“01h 23m”。

另一个例子

假设LANGUAGE_CODE为，例如，"de"，那么对于

{{ value|time:"TIME_FORMAT" }}

输出将为字符串"01:23"（随 Django 提供的de区域设置的"TIME_FORMAT"格式说明符为"H:i"）。

time过滤器仅接受与一天中的时间相关的格式字符串中的参数，而不是日期。如果您需要格式化date值，请改用date过滤器（或者与time一起使用，如果您需要呈现完整的datetime值）。

上述规则有一个例外：当传递一个带有附加时区信息的datetime值（一个时区感知datetime实例）时，time过滤器将接受与时区相关的格式说明符'e'、'O'、'T'和'Z'。

在不使用格式字符串的情况下，将使用TIME_FORMAT格式说明符

{{ value|time }}

与

{{ value|time:"TIME_FORMAT" }}

timesince¶

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

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

{{ blog_date|timesince:comment_date }}

比较偏移量朴素和偏移量感知日期时间将返回空字符串。

分钟是最小的使用单位，对于相对于比较点在将来的任何日期，将返回“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 }}

比较偏移量朴素和偏移量感知日期时间将返回空字符串。

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

title¶

通过使单词以大写字符开头，其余字符小写来将字符串转换为标题大小写。此标签不会努力将“不重要的单词”保持为小写。

例如：

{{ value|title }}

如果value的值为"my FIRST post"，则输出将为"My First Post"。

truncatechars¶

如果字符串的长度超过指定的字符数，则截断该字符串。截断的字符串将以可翻译的省略号字符（”…”）结尾。

**参数：**要截断到的字符数

例如：

{{ value|truncatechars:7 }}

如果value的值为"Joel is a slug"，则输出将为"Joel i…"。

truncatechars_html¶

类似于truncatechars，但它知道 HTML 标签。在字符串中打开但在截断点之前未关闭的任何标签都将在截断后立即关闭。

例如：

{{ value|truncatechars_html:7 }}

如果value的值为"<p>Joel is a slug</p>"，则输出将为"<p>Joel i…</p>"。

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

truncatewords¶

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

**参数：**截断后的单词数

例如：

{{ value|truncatewords:2 }}

如果value的值为"Joel is a slug"，则输出将为"Joel is …"。

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

truncatewords_html¶

类似于truncatewords，但它知道 HTML 标签。在字符串中打开但在截断点之前未关闭的任何标签都将在截断后立即关闭。

这比 truncatewords效率低，所以只有在传递HTML文本时才应该使用。

例如：

{{ value|truncatewords_html:2 }}

如果 value 为 "<p>Joel is a slug</p>"，则输出将为 "<p>Joel is …</p>"。

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

unordered_list¶

递归地获取一个自嵌套列表，并返回一个HTML无序列表 - **不包含** <ul> 标签的开头和结尾。

假设列表格式正确。例如，如果 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 is a slug"，则输出将为 "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¶

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

此模板标签适用于以 http://、https:// 或 www. 为前缀的链接。例如，https://djangocon.eu 将被转换，但 djangocon.eu 不会。

它还支持以原始顶级域名之一结尾的仅域名链接（.com、.edu、.gov、.int、.mil、.net 和 .org）。例如，djangoproject.com 会被转换。

链接可以有尾随标点符号（句点、逗号、右括号）和前导标点符号（左括号），而 urlize 仍然会正确处理。

由 urlize 生成的链接添加了 rel="nofollow" 属性。

例如：

{{ value|urlize }}

如果 value 为 "Check out www.djangoproject.com"，则输出将为 "Check out <a href="https://django.ac.cn" 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。

{{ value|truncatechars:500|urlize }}

urlizetrunc¶

与 urlize 一样，将URL和电子邮件地址转换为可点击的链接，但会截断超过给定字符限制的URL。

**参数：**链接文本应截断到的字符数，包括如果需要截断则添加的省略号。

例如：

{{ value|urlizetrunc:15 }}

如果 value 为 "Check out www.djangoproject.com"，则输出将为 'Check out <a href="https://django.ac.cn" rel="nofollow">www.djangoproj…</a>'。

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

wordcount¶

返回单词数量。

例如：

{{ value|wordcount }}

如果 value 为 "Joel is a slug"，则输出将为 4。

wordwrap¶

在指定的行长处换行。

**参数：**要换行的文本的字符数

例如：

{{ value|wordwrap:5 }}

如果 value 为 Joel is a slug，则输出将为

Joel
is a
slug

yesno¶

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

例如：

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

i18n¶

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

参见 国际化：在模板代码中。

l10n¶

此库提供了控制模板中值本地化的功能。您只需使用 {% load l10n %} 加载此库即可。

参见 控制模板中的本地化。

tz¶

此库提供了控制模板中时区转换的功能。与 l10n 一样，您只需使用 {% load tz %} 加载此库即可，但通常您还需要将 USE_TZ 设置为 True，以便默认情况下将时间转换为本地时间。

参见 模板中的时区感知输出。

django.contrib.humanize¶

一组 Django 模板过滤器，用于为数据添加“人性化”效果。参见 django.contrib.humanize。

static¶

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

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

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

{% 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!">

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