Django模板(Template)系统

叁歲伎倆 2023-06-12 09:41 18阅读 0赞

### 模板系统基础 ###

Django 模板是一些文本字符串，作用是把文档的表现与数据区分开。模板定义一些占位符和基本的逻辑（模板标签），规定如何显示文档。通常，模板用于生成HTML，不过 Django 模板可以生成任何基于文本的格式。

语法

两对花括号包围的文本（如\{ \{ person\_name \}\}）是变量，意思是“把指定变量的值插入这里”。 一对花括号和百分号包围的文本（如\{% if ordered\_warranty %\}）是模板标签。标签的定义相当宽泛：只要能让模板系统处理逻辑相关的就是标签。

变量与方法

\{ \{ 变量名 \}\}，变量名由字母数字和下划线组成。点（.）在模板语言中有特殊的含义，用来获取对象的相应属性值。

几个例子： view.py中的代码：

def template_test(request):
        l = [11, 22, 33]
        d = {"name": "alex"}
    
        class Person(object):
            def __init__(self, name, age):
                self.name = name
                self.age = age
    
            def dream(self):
                return "{} is dream...".format(self.name)
    
        Alex = Person(name="Alex", age=34)
        Egon = Person(name="Egon", age=9000)
        Eva_J = Person(name="Eva_J", age=18)
    
        person_list = [Alex, Egon, Eva_J]
        return render(request, "template_test.html", {"l": l, "d": d, "person_list": person_list})

模板中支持的写法：

# 取l中的第一个参数
    {
       { l.0 }}
    # 取字典中key的值
    {
       { d.name }}
    # 取对象的name属性
    {
       { person_list.0.name }}
    # .操作只能调用不带参数的方法
    {
       { person_list.0.dream }}

标签

\{% if %\} 计算变量的值，如果为真（即存在、不为空，不是假值），模板系统显示\{% if %\} 和\{% endif %\}之间的内容。例如：

{% if today_is_weekend %}
    <p>Welcome to the weekend!</p>
    {% endif %}

\{% else %\} 标签是可选的：

{% if today_is_weekend %}
    <p>Welcome to the weekend!</p>
    {% else %}
    <p>Get back to work.</p>
    {% endif %}

if 标签还可以有一个或多个\{% elif %\} 子句：

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

\{% if %\} 支持使用and、or 或not 测试多个变量，或者取反指定的变量。例如：

{% if athlete_list and coach_list %}
    <p>Both athletes and coaches are available. </p>
    {% endif %}
    
    {% if not athlete_list %}
    <p>There are no athletes. </p>
    {% endif %}
    
    {% if athlete_list or coach_list %}
    <p>There are some athletes or some coaches. </p>
    {% endif %}
    
    {% if not athlete_list or coach_list %}
    <p>There are no athletes or there are some coaches. </p>
    {% endif %}
    
    {% if athlete_list and not coach_list %}
    <p>There are some athletes and absolutely no coaches. </p>
    {% endif %}

在同一个标签中可以同时使用and 和or，此时，and 的优先级比or 高。例如：

{% if athlete_list and coach_list or cheerleader_list %}
    # 像这样解释(在if 标签中使用括号是无效的句法。)：
    if (athlete_list and coach_list) or cheerleader_list

如果需要通过括号指明优先级，应该使用嵌套的if 标签。不支持使用括号控制操作的顺序。如果觉得有必要使用括号，可以考虑在模板外部执行逻辑，然后通过专用的模板变量传入结果。或者，直接使用嵌套的\{%if %\} 标签，如下所示：

{% if athlete_list %}
        {% if coach_list or cheerleader_list %}
        <p>We have athletes, and either coaches or cheerleaders! </p>
        {% endif %}
    {% endif %}

每个\{% if %\} 都必须有配对的\{% endif %\}。否则，Django 会抛出TemplateSyntaxError 异常。

for

\{% for %\} 标签用于迭代序列中的各个元素。与 Python 的for 语句一样，句法是for X in Y，其中Y 是要迭 代的序列，X 是单次循环中使用的变量。每次迭代时，模板系统会渲染\{% for %\} 和\{% endfor %\} 之间的内 容。例如，可以使用下述模板显示athlete\_list 变量中的运动员：

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

在标签中添加reversed，反向迭代列表：

{% for athlete in athlete_list reversed %}
    ...
    {% endfor %}

\{% for %\} 标签可以嵌套：

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

如果需要迭代由列表构成的列表，可以把每个子列表中的值拆包到独立的变量中。比如说上下文中有一个包含 (x,y) 坐标点的列表，名为points，可以使用下述模板输出这些坐标点：

{% for x, y in points %}
    <p>There is a point at {
       { x }},{
       { y }}</p>
    {% endfor %}

如果需要访问字典中的元素，也可以使用这个标签。如果上下文中包含一个字典data，可以使用下述模板显示字典的键和值：

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

通常，迭代列表之前要先检查列表的大小，如果为空，显示一些特殊的文字：

{% if athlete_list %}
        {% for athlete in athlete_list %}
        <p>{
       { athlete.name }}</p>
        {% endfor %}
    {% else %}
        <p>There are no athletes. Only computer programmers.</p>
    {% endif %}

这种做法太常见了，因此for 标签支持一个可选的\{% empty %\} 子句，用于定义列表为空时显示的内容。下述示例与前一个等效：

{% for athlete in athlete_list %}
    <p>{
       { athlete.name }}</p>
    {% empty %}
    <p>There are no athletes. Only computer programmers.</p>
    {% endfor %}

在\{% for %\} 循环内部，可以访问一个名为forloop 的模板变量。这个变量有几个属性，通过它们可以获知循环进程的一些信息：

*  forloop.counter 的值是一个整数，表示循环的次数。这个属性的值从 1 开始，因此第一次循环时，forloop.counter 等于1。下面举个例子：

{% for item in todo_list %}
    <p>{
       { forloop.counter }}: {
       { item }}</p>
    {% endfor %}

*  forloop.counter0 与forloop.counter 类似，不过是从零开始的。第一次循环时，其值为0。
 *  forloop.revcounter 的值是一个整数，表示循环中剩余的元素数量。第一次循环时，forloop.revcounter 的值是序列中要遍历的元素总数。最后一次循环时，forloop.revcounter 的值为1。
 *  forloop.revcounter0 与forloop.revcounter 类似，不过索引是基于零的。第一次循环时，forloop.revcounter0 的值是序列中元素数量减去一。最后一次循环时，forloop.revcounter0 的值为0。
 *  forloop.first 是个布尔值，第一次循环时为True。需要特殊处理第一个元素时很方便：

{% for object in objects %}
        {% if forloop.first %}
            ...
        {% else %}
            ...
        {% endif %}
        {
       { object }}
            ...
    {% endfor %}

*  forloop.last 是个布尔值，最后一次循环时为True。经常用它在一组链接之间放置管道符号：

{% for link in links %}
    {
       { link }}
    {% if not forloop.last %}
        |
    {% endif %}
    {% endfor %}

上述模板代码的输出可能是：Link1 | Link2 | Link3 | Link4,此外，还经常用它在一组单词之间放置逗号：

<p>Favorite places:</p>
    {% for p in places %}
    {
       { p }}{% if not forloop.last %}, {% endif %}
    {% endfor %}

*  在嵌套的循环中，forloop.parentloop 引用父级循环的forloop 对象。下面举个例子：

{% for country in countries %}
        <table>
            {% for city in country.city_list %}
            <tr>
                <td>Country #{
       { forloop.parentloop.counter }}</td>
                <td>City #{
       { forloop.counter }}</td>
                <td>{
       { city }}</td>
            </tr>
            {% endfor %}
        </table>
    {% endfor %}

forloop 变量只在循环内部可用。模板解析器遇到\{% endfor %\} 时，forloop 随之消失。

ifequal/ifnotequal

模板经常需要比较两个值，在相等时显示一些内容。为此，Django 提供了\{% ifequal %\} 标签。\{% ifequal %\} 标签比较两个值，如果相等，显示\{%ifequal %\} 和\{% endifequal %\} 之间的内容。下述示例比较模板标签user 和currentuser：

{% ifequal user currentuser %}
    <h1>Welcome!</h1>
    {% endifequal %}

参数可以是硬编码的字符串，使用单引号或双引号都行，因此下述代码是有效的：

{% ifequal section 'sitenews' %}
        <h1>Site News</h1>
    {% endifequal %}
        {% ifequal section "community" %}
    <h1>Community</h1>
    {% endifequal %}

与\{% if %\} 一样，\{% ifequal %\} 标签支持可选的\{% else %\} 子句：

{% ifequal section 'sitenews' %}
    <h1>Site News</h1>
    {% else %}
    <h1>No News Here</h1>
    {% endifequal %}

\{% ifequal %\} 的参数只能是模板变量、字符串、整数和小数。下面是有效的示例：

{% ifequal variable 1 %}
    {% ifequal variable 1.23 %}
    {% ifequal variable 'foo' %}
    {% ifequal variable "foo" %}

其他变量类型，例如 Python 字典、列表或布尔值，不能在\{% ifequal %\} 中硬编码。下面是无效的示例：

{% ifequal variable True %}
    {% ifequal variable [1, 2, 3] %}
    {% ifequal variable {'key': 'value'} %}

如果想测试真假，应该使用\{% if %\} 标签。ifequal 标签可以替换成if 标签和== 运算符。

\{% ifnotequal %\} 的作用与ifequal 类似，不过它测试两个参数是否不相等。ifnotequal 标签可以替换成if标签和!= 运算符。

注释

与 HTML 和 Python 一样，Django 模板语言支持注释。注释使用\{\# \#\} 标明：\{\# This is a comment \#\}

如果想编写多行注释，使用\{% comment %\} 模板标签，如下所示：

{% comment %}
    This is a
    multi-line comment.
    {% endcomment %}

注释标签不能嵌套。

Fiter过滤器

模板过滤器是在显示变量之前调整变量值的简单方式。过滤器使用管道符号指定，如下所示：

`{ { name|lower }}`

上述代码先通过lower 过滤器调整\{ \{ name \}\} 变量的值——把文本转换成小写，然后再显示。过滤器可以串接，即把一个过滤器的输出传给下一个过滤器。

下述示例获取列表中的第一个元素，然后将其转换成大写：

`{ { my_list|first|upper }}`

有些过滤器可以接受参数。过滤器的参数放在冒号之后，始终放在双引号内。例如：

`{ { bio|truncatewords:"30" }}`显示bio 变量的前 30 个词。

模板加载机制

为了从文件系统中加载模板，Django 提供了便利而强大的 API，力求去掉模板加载调用和模板自身的冗余。若想使用这个模板加载 API，首先要告诉框架模板的存储位置。这个位置在设置文件中配置，即前一章介绍ROOT\_URLCONF 设置时提到的settings.py 文件。打开settings.py 文件，找到TEMPLATES 设置。它的值是一个列表，分别针对各个模板引擎：

TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [],
            'APP_DIRS': True,
            'OPTIONS': {
                # ... 一些选项 ...
            },
        },
    ]

BACKEND 的值是一个点分 Python 路径，指向实现 Django 模板后端 API 的模板引擎类。内置的后端有django.template.backends.django.DjangoTemplates 和django.template.backends.jinja2.Jinja2。

因为多数引擎从文件中加载模板，所以各个引擎的顶层配置包含三个通用的设置：

*  DIRS 定义一个目录列表，模板引擎按顺序在里面查找模板源文件。
 *  APP\_DIRS 设定是否在安装的应用中查找模板。按约定，APPS\_DIRS 设为True 时，DjangoTemplates 会在INSTALLED\_APPS 中的各个应用里查找名为“templates”的子目录。这样，即使DIRS 为空，模板引擎还能查找应用模板。
 *  OPTIONS 是一些针对后端的设置。

同一个后端可以配置具有不同选项的多个实例，然而这并不常见。要为各个引擎定义唯一的NAME。

include(组件) 模板标签

内置模板标签：\{% include %\}

这个标签的作用是引入另一个模板的内容。它的参数是要引入的模板的名称，可以是变量，也可以是硬编码的字符串（放在引号里，单双引号都行）。

只要想在多个模板中使用相同的代码，就可以考虑使用\{% include %\}，去除重复。下述示例引入includes/nav.html 模板的内容：

`{% include 'includes/nav.html' %}`

模板继承

模板继承是指创建一个基底“骨架”模板，包含网站的所有通用部分，并且定义一些“块”，让子模板覆盖。

首先，要定义一个基模板，即一个骨架，供子模板填充。下面是针对前述示例的基模板：

<!DOCTYPE html>
    <html lang="en">
    <head>
        <title>{% block title %}{% endblock %}</title>
    </head>
    <body>
        <h1>My helpful timestamp site</h1>
        {% block content %}{% endblock %}
        {% block footer %}
        <hr>
        <p>Thanks for visiting my site.</p>
        {% endblock %}
    </body>
    </html>

我们把这个模板命名为base.html，它定义了一个简单的 HTML 文档骨架，供网站中的所有页面使用。子模板可以覆盖块的内容、向块中添加内容，或者原封不动。\{% block %\}标签：它的作用很简单，告诉模板引擎，子模板可以覆盖这部分内容。

创建好基模板之后，修改现有的current\_datetime.html 模板，让它使用基模板：

{% extends "base.html" %}
    {% block title %}The current time{% endblock %}
    {% block content %}
    <p>It is now {
       { current_date }}.</p>
    {% endblock %}

下面说说原理。模板引擎加载current\_datetime.html 模板时，发现有\{% extends %\} 标签，意识到这是一个子模板，因此立即加载父模板，即这里的base.html。

加载父模板时，模板引擎发现base.html 中有三个\{% block %\} 标签，然后使用子模板中的内容替换。因此，将使用\{% block title %\} 中定义的标题和\{% block content %\} 中定义的内容。

注意，这个子模板没有定义footer 块，因此模板系统使用父模板中的内容。父模板中的\{% block %\} 块总是后备内容。

继承不影响模板的上下文。也就是说，继承树中的任何模板都能访问上下文中的每一个模板变量。根据需要，继承层级的深度不限。继承经常使用下述三层结构：

*  创建base.html 模板，定义网站的整体外观。这个模板的内容很少变化。
 *  为网站中的各个“区域”创建base\_SECTION.html 模板（如base\_photos.html 和base\_forum.html）。这些模板扩展base.html，包含各区域专属的样式和设计。
 *  为各种页面创建单独的模板，例如论坛页面或相册。这些模板扩展相应的区域模板。

这种方式能最好地复用代码，而且便于为共享的区域添加内容，例如同一个区域通用的导航。

下面是使用模板继承的一些指导方针：

*  如果模板中有\{% extends %\}，必须是模板中的第一个标签。否则，模板继承不起作用。
 *  一般来说，基模板中的\{% block %\} 标签越多越好。记住，子模板无需定义父模板中的全部块，因此可以为一些块定义合理的默认内容，只在子模板中覆盖需要的块。钩子多总是好的。
 *  如果发现要在多个模板中重复编写相同的代码，或许说明应该把那些代码移到父模板中的一个\{%block %\} 标签里。
 *  如果需要从父模板中的块里获取内容，使用\{ \{ block.super \}\}，这是一个“魔法”变量，提供父模板中渲染后的文本。向块中添加内容，而不是完全覆盖时就可以这么做。
 *  在同一个模板中不能为多个\{% block %\} 标签定义相同的名称。之所以有这个限制，是因为block 标签是双向的。即，block 标签不仅标识供填充的空位，还用于定义填充父模板中空位的内容。如果一个模板中有两个同名的块，那么父模板就不知道使用哪个块里的内容。
 *  多数情况下，\{% extends %\} 的参数是字符串，不过如果直到运行时才知道父模板的名称，也可以用变量。通过这一点可以做些动态判断。

内置标签

1.  `autoescape`：控制当前的自动转义行为。这个标签的参数为on 或off，指明在块中自动转义是否生效。块以endautoescape标签结尾。启用自动转义时，包含 HTML 的变量先转义再输出（在此之前先应用过滤器）。这与手动在各个变量上应用escape 过滤器效果一样。唯一的例外是被生成变量的代码或者通过safe 或escape 过滤器标记为无需转义的安全内容。用法举例：

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

1.  `block`:定义可由子模板覆盖的块。
2.  `comment`:忽略\{% comment %\} 和\{% endcomment %\} 之间的全部内容。起始标签可以添加可选的注解，例如说明为何要注释掉代码。comment 标签不能嵌套。
3.  `csrf_token`:这个标签提供 CSRF 防护。关于跨站请求伪造（Cross Site Request Forgery）
4.  `cycle`:每执行这个标签一次输出参数中的一个值。第一次执行输出第一个参数，第二次执行输出第二个参数，以此类推。所有参数都输出一遍之后，回到第一个参数，再依次输出。这个标签在循环中特别有用：

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

一个cycle 标签中可以使用任意多个值（以空格分开）。放在单引号（'）或双引号（"）中的值视作字符串字面量，没有引号的视为模板变量。 6. `debug`:输出大量调试信息，包括当前上下文和导入的模块。 7. `extends`:表明所在模板扩展某个父模板。这个标签有两种用法：\{% extends "base.html" %\}（有引号），以字面值"base.html" 为父模板的名称。\{% extends variable %\} 以variable 的值为父模板的名称。如果variable 的求值结果是一个字符串，Django 以那个字符串为父模板的名称；如果求值结果是一个Template 对象，Django 使用那个对象为父模板。 8. `filter`:使用一个或多个过滤器过滤内容块。 9. `firstof`:输出参数中第一个不为False 的变量值。如果传入的变量都为False，不输出任何内容。用法示例：

{% firstof var1 var2 var3 %}
    # 等效于：
    {% if var1 %}
    {
       { var1 }}
    {% elif var2 %}
    {
       { var2 }}
    {% elif var3 %}
    {
       { var3 }}
    {% endif %}

1.  `for`:迭代数组中的各个元素，并把当前迭代的元素赋值给一个上下文变量。
2.  `for … empty`:for 标签有个可选的\{% empty %\} 子句，在指定的数组为空或无法找到时显示一些文本。
3.  `if`:\{% if %\} 计算变量的值，如果为真（即存在、不为空、不是假值），输出块中的内容if标签可以有一个或多个\{% elif %\} 子句，以及一个\{% else %\} 子句，在前述条件判断都失败时显示。这些子句都是可选的。
4.  `ifchanged`:检查前一次迭代之后值是否变了。\{% ifchanged %\} 块标签在循环中使用。有两种用法：1-检查渲染得到的内容，与之前的状态比较，只在有变化时显示内容。2-检查指定的一个或多个变量的值是否有变化。
5.  `ifequal`:两个参数相等时输出块中的内容。例如：

{% ifequal user.pk comment.user_id %}
    ...
    {% endifequal %}

1.  `ifnotequal`:与ifequal 类似，不过测试的是两个参数是否不等。可用if 和!= 运算符代替。
2.  `include`:加载一个模板，在当前上下文中渲染。这是在模板中引入其他模板的方式。模板的名称可以是一个变量：`{% include template_name %}`或者硬编码的字符串（有引号）：`{% include "foo/bar.html" %}`
3.  `load`:加载自定义的模板标签。
4.  `lorem`:显示随机的占位拉丁文本。可用于为模板提供示例数据。用法：`{% lorem [count] [method] [random] %}`\{% lorem %\} 标签可接受零个、一个、两个或三个参数。这些参数分别是：1-count：一个数字（或变量），指定生成的段落或单词数量（默认为 1）。2-method：为表示单词的w、表示 HTML 段落的p 或表示纯文本段落的b（默认为b）。3-random：生成文本时随机输出（指定时），不使用常见的段落（Lorem ipsum dolor sit amet…）。例如，\{% lorem 2 w random %\} 随机输出两个拉丁单词。
5.  `now`:以参数指定的格式显示当前日期和（或）时间。例如：It is \{% now "jS F Y H:i" %\}传入的格式也可以是某个预定义的值，如DATE\_FORMAT、DATETIME\_FORMAT、SHORT\_DATE\_FORMAT 或SHORT\_DATETIME\_FORMAT。预定义格式的输出内容根据当前本地化设置和是否启用本地化格式而有所不同。例如：It is \{% now "SHORT\_DATETIME\_FORMAT" %\}
6.  `regroup`:按共有属性重新分组一组相似的对象。\{% regroup %\} 生成分组对象构成的列表。每个分组对象有两个属性：1-grouper：分组的依据（如字符串"India" 或"Japan"）,2-list：分组中的元素列表（如国家为"India" 的城市列表）,任何有效的模板查找对象都是有效的分组属性，包括方法、属性、字典的键和列表的元素。
7.  `spaceless`:删除 HTML 标签之间的空白，包括制表符和换行符。用法示例：

{% spaceless %}
    <p>
    <a href="foo/">Foo</a>
    </p>
    {% endspaceless %}
    # 这个示例返回的 HTML 如下：
    <p><a href="foo/">Foo</a></p>

1.  `emplatetag`:输出构成模板标签句法的字符。模板系统自身无法转义，因此若想显示构成模板标签的字符，必须使用\{%templatetag %\} 标签。
2.  `url`:返回指定视图函数和可选参数对应的绝对路径（不带域名的 URL）。路径中的特殊字符会使用iri\_to\_uri()编码。使用这种方式输出链接符合 DRY 原则，因为无需在模板中硬编码 URL。
3.  `verbatim`:不让模板引擎渲染块中的内容。JavaScript 模板层经常使用这个标签防止与 Django 的句法冲突。
4.  `widthratio`:插入条形图等图像时用于计算上至某个值的长宽比，然后把这一比例规整。例如： `<img src="bar.png" alt="Bar" height="10" width="{% widthratio this_value max_value max_width%}" />`
5.  `with`:把复杂的变量缓存到一个简单的名称下。多次访问耗资源的（如访问数据库）方法时可以这么做。例如：

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

内置过滤器

1.  `add`：把参数加到值上。例如：`{ { value|add:"2" }}`如果value 为4，输出6。
2.  `addslashes`:在引号前加上斜线。可用于转义 CSV 中的字符串。例如：`{ { value|addslashes }}`如果value 为"I'm using Django"，输出"I'm using Django"。
3.  `capfirst`:把值的首字母变成大写。如果第一个字符不是字母，这个过滤器没有效果。
4.  `center`:在指定宽度中居中显示值。例如：`"{ { value|center:"14" }}"`如果value 为"Django"，输出"␣␣␣␣Django␣␣␣␣"（␣ 表示一个空格）。
5.  `cut`:从字符串中删除参数指定的值。
6.  `date`:使用指定的格式格式化日期。例如：`{ { value|date:"D d M Y" }}`如果value 是一个datetime 对象（例如datetime.datetime.now() 的结果），输出的字符串类似于"Fri 01Jul 2016"。也可以传入预定义的格式DATE\_FORMAT、DATETIME\_FORMAT、SHORT\_DATE\_FORMAT 或SHORT\_DATETIME\_FORMAT，以及使用日期格式说明符自定义的格式。
7.  `default`:如果value 是假值，使用指定的默认值；否则，使用value 的值。例如：`{ { value|default:"nothing" }}`
8.  `default_if_none`:当且仅当value 为None 时使用指定的默认值，否则使用value 的值。
9.  `dictsort`:按参数指定的键排序字典构成的列表，返回排序后的列表。例如：`{ { value|dictsort:"name" }}`
10. `dictsortreversed`:按参数指定的键排序字典构成的列表，返回反向排序后的列表。
11. `divisibleby`:如果值能被参数整除，返回True。例如：`{ { value|divisibleby:"3" }}`如果value 为21，返回True。
12. `escapejs`:转义 JavaScript 字符串中的字符。这个过滤器得到的结果不能在 HTML 中安全使用，但是使用模板生成JavaScript/JSON 时能防止句法出错。
13. `filesizeformat`:把值格式化为人类可读的文件大小（如'13 KB'、'4.1 MB'、'102 bytes'，等等）。例如：`{ { value|filesizeformat }}`如果value 为123456789，输出117.7 MB。
14. `first`:返回列表中的第一个元素。
15. `floatformat`:不指定参数时，近似浮点数，只保留一位小数（前提是有小数）。如果指定了整数参数，floatformat 近似时保留相应位数的小数。如果value 为34.23234，`{ { value|floatformat:3 }}` 输出34.232。
16. `get_digit`:从一个数字中取回指定的那一位，1 表示最低位。
17. `iriencode`:把 IRI（Internationalized Resource Identifier，国际化资源标识符）转换成适合在 URL 中使用的字符串。
18. `join`:使用字符串连接列表，类似于 Python 的str.join(list)。
19. `last`:返回列表中的最后一个元素。
20. `length`:返回值的长度。字符串和列表都适用。
21. `length_is`:如果值的长度与参数相等，返回True，否则返回False。例如：`{ { value|length_is:"4" }}`
22. `linebreaks`:把纯文本中的换行替换成适当的 HTML 标签。一个换行符替换成一个 HTML <br /> 标签，换行之后还有新行则替换成段落结束标签（</p>）。
23. `linebreaksbr`:把纯文本中的所有换行都替换成 HTML <br /> 标签。
24. `linenumbers`:显示带有行号的文本。
25. `ljust`:在指定宽度中左对齐值。例如：`{ { value|ljust:"10" }}`如果value 为"Django"，输出"Django␣␣␣␣"（␣ 表示一个空格）。
26. `lower`:把字符串转换成全小写形式。
27. `make_list`:把值转换成列表。值为字符串时，返回各字母构成的列表。值为整数时，先把参数转换成 Unicode 字符串，然后再创建列表。
28. `phone2numeric`:把电话号码（可能包含字母）转换成等效的数值。输入无需是有效的电话号码，任何字符串都能转换。例如：`{ { value|phone2numeric }}`如果value 为800-COLLECT，输出800-2655328。
29. `pluralize`:值不为1 时返回复数后缀。默认后缀为"s"。单词复数变形较为复杂时，可以指定单数和复数后缀，以逗号分开。例如：`You have { { num_cherries }} cherr{ { num_cherries|pluralize:"y,ies" }}.`
30. `random`:返回指定列表中的一个随机元素。
31. `rjust`:在指定宽度中右对齐值。例如：`{ { value|rjust:"10" }}`如果value 为"Django"，输出"␣␣␣␣Django"（␣ 表示一个空格）。
32. `safe`:标记字符串在输出之前无需进一步转义 HTML。关闭自动转义时这个过滤器没有效果。
33. `safeseq`:把safe 过滤器应用到序列中的各个元素上。可以与其他作用于序列的过滤器合用（如join）。例如：`{ { some_list|safeseq|join:", " }}`此时不能直接使用safe 过滤器，因为它先把变量转换成字符串，而不是处理序列中的单个元素。
34. `slice`:返回列表的切片。句法与 Python 的列表切片一样。
35. `tim`e:使用指定格式格式化时间。与date 过滤器一样，可以是预定义的TIME\_FORMAT，也可以是自定义的格式。
36. `timesince`:把日期格式化为距某一刻的时间（如“4 days, 6 hours”）。有个可选的参数，指定比较的日期基点（如不指定，与now 比较）。
37. `timeuntil`:距指定日期或日期时间的跨度。
38. `title`:把字符串转换成标题格式，即单词首字母大写，其余字母小写。
39. `truncatechars`:字符串的字符串超过指定长度时截断。截断后的字符串以可翻译的省略号（…）结尾。例如：`{ { value|truncatechars:9 }}`
40. `truncatechars_html`:与truncatechars 类似，不过知道如何截断 HTML 标签。
41. `truncatewords`:在指定的单词个数后截断字符串。
42. `truncatewords_html`:与truncatewords 类似，不过知道如何截断 HTML 标签。
43. `unordered_list`:递归遍历嵌套的列表，返回一个 HTML 无序列表（不含起始和结束标签）。
44. `upper`:把字符串转换成全大写字母形式。
45. `urlencode`:转义，以便在 URL 中使用。
46. `urlize`:把文本中的 URL 和电子邮件地址转换成可点击的链接。支持以[http://、https][http_https]:// 或www. 开头的 URL。
47. `urlizetrunc`:与urlize 一样，把 URL 和电子邮件地址转换成可点击的链接，但是在指定的字符长度处截断 URL。例如：`{ { value|urlizetrunc:15 }}`如果value 为"Check out www.djangoproject.com"，输出"Checkout<ahref="[http://www.djangoproject.com][http_www.djangoproject.com]"rel="nofollow">www.djangopr…</a>"。与urlize 一样，这个过滤器只应该应用于纯文本。
48. `wordcount`:返回字数。
49. `wordwrap`:在指定的长度处换行。
50. `yesno`:把True、False 和None（可选）映射到字符串“yes”、“no”、“maybe”上，或者是通过参数传入的列表上（以逗号分隔），根据真假值情况，返回相应的字符串。例如：`{ { value|yesno:"yeah,no,maybe" }}`

[http_https]: http://xn--https-0t3d/
[http_www.djangoproject.com]: http://www.djangoproject.com/