Python 俱乐部

本页面只读。您可以查看源文件，但不能更改它。如果您觉得这是系统错误，请联系管理员。
====== Django 模板语言: 写给模板作者 ======
Django 的模板语言的设计原则在动力和易用性之间取得均衡.(功能要足够强大，还要容易使用), 如果你以前使用过 HTML,你会觉得很容易上手.如果有其它基于文本的模板语言的经验, 比如Smarty或CheetahTemplate, 你会觉得..使用django模板..就象在自己家里一样.

===== Templates =====

一个模板就是一个文本文件. 通过模板可以生成任意的基于文本的格式文件(HTML, XML, CSV, etc.).

一个模板包含 变量, 当模板被求值时,这些变量就被它们的值代替.而 标签 则控制着模板的逻辑.

下面是一个最小化的模板,它演示了某些基本概念. 其中的每个元素都会在本文档的后面部分被详细解释.:

<code html>
{% extends "base_generic.html" %}

{% block title %}{{ section.title }}{% endblock %}

{% block content %}
<h1>{{ section.title }}</h1>

{% for story in story_list %}
<h2>
  <a href="{{ story.get_absolute_url }}">
    {{ story.headline|upper }}
  </a>
</h2>
<p>{{ story.tease|truncatewords:"100" }}</p>
{% endfor %}
{% endblock %}
</code>

哲学

为什么使用基于文本的模板系统而不是基于 XML (类似 Zope 的 TAL)? 我们希望 Django 的模板语言能比那些 XML/HTML 模板更可用.在 World Online, 我们使用它处理 e-mails, JavaScript 和 CSV. 你能使用这种模板语言生成任何基于文本的格式. 哦,还有一个理由,那就是我们认为除非一个人有受虐趋向，否则谁也不愿意手工编辑 xml。
===== Variables =====

变量的形式: %%{{ variable }}%%. 当模板引擎遇到一个变量时,就会对变量求值,并在变量所在的位置用变量的值取代变量名,然后输出.

使用句点 (.) 可以访问变量的属性.

幕后

技术上,当模板系统遇到 句点, 它会按顺序尝试进依次查询:

  * Dictionary lookup
  * Attribute lookup
  * Method call
  * List-index lookup

在上面的例子中, %%{{ section.title }}%% 会被 section 对象的 title 属性替换.

如果你用到的一个变量不存在,模板系统会插入一个值:TEMPLATE_STRING_IF_INVALID ,这个值在 settings 中定义, 默认设置是一个空的字符串.

参见下面的 使用内建参考 , 这会帮助你发现给定模板中有哪些变量可用.

你可以使用 过滤器 来修改变量的显示.
===== 过滤器 =====

通过使用 过滤器 ，可以定制变量的显示格式。

过滤器的形式: %%{{ name|lower }}%%. 这将显示 %%{{ name }}%% 变量通过 lower 过滤后的值. 它将文本转换为小写. 使用管道符号 (|) 应用一个过滤器.

过滤器可以 "链接". 一个过滤器的输入作为下一个过滤器的输入: %%{{ text|escape|linebreaks }}%% 是一个常用过滤器组合,用于将文本内容转义然后将换行转换成 <p> 标签.

有些过滤器能接受参数. 一个带有参数的过滤器看起来这样: %%{{ bio|truncatewords:"30" }}%%. 它用来显示 bio 变量的前 30 个. 过滤器参数总是带有比引号. 下文中的 内建过滤器参考 描述了所有的内建过滤器.
===== 标签 =====

标签看起来这样: {% 标签 %}. 标签比起变量来复杂的多: 它负责在输出中创建一些文本,执行循环或逻辑分支, 装入额外信息以供后面的模板变量使用等等.

有些标签要求有开始标记和结束标记 (也就是 {% tag %} ... 标签内容 ... {% endtag %}). 下文中的 内建标签参考 描述了所有的内建标签.你也可以创建你自己的标签, 如果你会写 Python 代码的话.

===== 模板继承 =====

Django 模板引擎最强大的 — 也是最复杂的 — 部分是模板继承. 模板继承允许你建立一个基本的 "骨架" 模板, 它包含你所有最常用的站点元素并定义了一些可以被子模板覆盖的 块 .

通过下面的例子你很容易理解模板继承:

<code html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}My amazing site{% endblock %}</title>
</head>

<body>
    <div id="sidebar">
        {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
        {% endblock %}
    </div>

    <div id="content">
        {% block content %}{% endblock %}
    </div>
</body>
</html>
</code>

我们称它为 base.html, 定义了一些简单的 HTML 骨架文档, 你可以把它用到一些简单两列的网页上. "子" 模板的任务就是用内容填写这些空白的内容块.

在这个例子里, {% block %} 标签定义了三个子模板要填写的 block . 所有的 block 标签告诉模板引擎,模板的这些部分可以被子模板覆盖.

一个子模板类似下面这样:

<code html>
{% extends "base.html" %}

{% block title %}My amazing blog{% endblock %}

{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}
</code>

这里的 {% extends %} 标签是最关键的. 它告诉模板引擎这个模板 "扩展" 了另一个模板. 当模板系统要应用该模板时,首先它会去寻找父模板–在这里是 "base.html" .

模板引擎会注意到在 base.html 里有三个 block 并用子模板的相关内容替换这些 block. 用 blog_entries 里的值填写父模板之后, 最后的输出可能看起来象这样:

<code html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>

<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>

    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>

        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>
</code>

注意由于子模板并未定义 sidebar block, 父模板中的值就被保留.

对模板的继承层数,Django未做任何限制. 常用的一种模板继承方法是如下的三层:


  * 创建一个 ``base.html`` 模板，用它表现站点主要的外观。

  * 为站点的每个 section 创建一个 ``base_SECTIONNAME.html`` 模板。比如 ``base_news.html``,``base_sport.html``等等， 这些模板扩充了 ``base.html`` 并包括 section 特有的样式和设计。

  * 为每种类型的页面创建一个独立的模板，比如一篇新闻稿或者一个博客，这些模板扩展了相应的 section 模板。

这种方式能够最大程度的重用代码并能很容易的扩充内容及共享内容区块，比如 section-范围的导航。
==== 下面是使用模板继承的一些小技巧: ====

  * 如果你在模板中使用了 ``{% extends %}`` ,那么它必须是这个模板中的第一个模板 tag ，否则它就不工作。

  * 在父模板中 ``{% block %}`` 标签虽然不是越多越好,总得来说多比少好. 记住,子模板不需要定义所有的 parent block, 因此你可以先定义一系列 blocks 并填入合理的默认值, 然后定义那些你以后才需要的 block. It's better to have more hooks than fewer hooks.

  * 如果发现在一堆模板文件中重复定义相同的内容, 就意味着需要将这些内容放到父模板的一个 ``{% block %}`` 中去.

  * 如果你需要在子模板中引用父模板中的 block 的内容,使用%%``{{ block.super }}``%%变量. 这在你希望在父模板的内容之后添加一些内容时会很有用.(你不必完全覆盖父模板的内容.)
最后, 提醒你不能在一个模板文件中定义多个相同名字的 {% block %} 标签.

===== 使用内建参考 =====

Django 自带的 admin site 内建一个当前站点的所有模板标签及过滤器的参考. 要查阅这个参考, 进入 admin 站点，然后点击页面右上角的 "Documentation" 链接(如果你的语言选择的是中文,你会看到一个 "文档" 链接)..

这个参考分为四大部分:tags, filters, models, 和 views.

tags 和 filters 部分描述了所有的内建标签(事实上, 下文中的标签和过滤器 参考直接来自那些页面)和所有自定义标签或过滤器 库(如果有的话).

views 页是最有价值的.你站点中的每个 URL 都有一个入口在这儿, 点击这个 URL 你会看到:

生成该页面的 view 函数的名字
该 view 功能的一个简短的描述.
该 view 的 context, 或者该 view 对应模板中的可用变量列表
模板的名字,或该模板使用到的模板名字
每个 view 文档页还有一个 bookmarklet , 使用它你可以任意页跳回到这个 view 页.

由于 Django 站点通常会用到数据库对象, 文档页的 models 小节描述了系统中每个对象的类型及那个对象的所有可用字段.

总得来说, 文档页会告诉你给定模板的每个标签, 每个过滤器,每个变量和对象的细节信息.

===== 自定义标签及过滤器库 =====

某些应用提供自定义标签和过滤器库. 要在一个模板中访问它们, 使用 {% load %} 标签:


  {% load comments %}

  {% comment_form for blogs.entries entry.id with is_public yes %}
在上面这个例子里, load 标签载入 comments 标签库, 之后 comment_form 标签才能使用. 参考你的 admin 界面的文档部分你会发现一个自定义库的列表. {% load %} 标签可接受空隔分隔的多个库的名字作为参数. 比如:


  {% load comments i18n %}
===== 自定义库及模板继承 =====

当你载入一个自定义标签或过滤器库, 只有当前模板可以使用这些标签/过滤器 — 继承链中不论是父模板还是子模板都不能使用使用这些标签和过滤器.

举例来说, 如果一个模板 foo.html 内有 {% load comments %} 指令, 一个子模板(也就是一个模板内有 {% extends "foo.html" %} 指令将 不能 访问 comments 模板标签和过滤器. 子模板必须自己负责 {% load comments %} 才可以使用这个库.

这是为了模板逻辑的清晰性和可维护性有意而为的一个特性.
===== 内建标签和过滤器参考 =====

下面的标签和过滤器参考就是为那些没有 admin 站点的可用的人准备的.由于 Django 是高度可定制的,你的 admin 里的关于标签和过滤器的参考可以认为是最可信的.
===== 内建标签参考 =====
 ==== block ====


定义一个能被子模板覆盖的 块. 参阅 模板继承 了解更多信息

 
==== comment ====


注释.模板引擎会忽略掉 {% comment %} 和 {% endcomment %} 之间的所有内容.

==== cycle ====


在循环时轮流使用给定的字符串列表中的值.

在一个循环中, 在循环过程中的每次循环里轮流使用给定的字符串列表元素:
<code html>
{% for o in some_list %}
    <tr class="{% cycle row1,row2 %}">
        ...
    </tr>
{% endfor %}
</code>
在循环之外, 在你第一次调用它时给这些字符串值定义一个不重复的名字,然后在循环中使用这个名字:

  <tr class="{% cycle row1,row2,row3 as rowcolors %}">...</tr>
  <tr class="{% cycle rowcolors %}">...</tr>
  <tr class="{% cycle rowcolors %}">...</tr>
你可以使用任意数量的逗号分隔的值.只有一点请你注意,不要在值与值之间放任何空隔–仅仅只有一个逗号即可.

==== debug ====


输出完整的调试信息,包括当前的上下文及导入的模块信息.

==== extends ====


当前模板 扩展 父模板的一个信号(标记).

这个标签有两种使用方式: {% extends "base.html" %} (带双引号) 使用 "base" 作为要扩展的父模板的名字.或者 {% extends variable %} 使用 variable 的值作为要扩展的父模板的名字.

参阅 模板继承 以了解更多信息.

==== filter ====


用来过滤变量的值.

允许多级过滤, 并且他们可以带有参数运行 — just like in variable syntax.

示例:

{% filter escape|lower %}
    文本将被 HTML-转义, 并且全部转化为小写
{% end过滤器 %}
==== firstof ====


输出传递给它的第一个不是 False 的变量值. 如果所有的变量都是 False 那就不输出任何东西.

示例:

  {% firstof var1 var2 var3 %}
它等价于:

<code html>
{% if var1 %}
    {{ var1 }}
{% else %}{% if var2 %}
    {{ var2 }}
{% else %}{% if var3 %}
    {{ var3 }}
{% endif %}{% endif %}{% endif %}
</code>


==== for ====
<html>
<p>循环. 比如要显示一个 <tt class="docutils literal"><span class="pre">athlete_list</span></tt> 中的全部运动员:</p>
<pre class="literal-block">
&lt;ul&gt;
{% for athlete in athlete_list %}
    &lt;li&gt;{{ athlete.name }}&lt;/li&gt;

{% endfor %}
&lt;/ul&gt;
</pre>
<p>通过使用 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">for</span> <span class="pre">obj</span> <span class="pre">in</span> <span class="pre">list</span> <span class="pre">reversed</span> <span class="pre">%}</span></tt> 你也可以实现反序循环.</p>

<p>在循环过程中 for 循环会设置以下的一系列变量:</p>
<blockquote>
<table class="docutils" border="1">
<colgroup>
<col width="35%">
<col width="65%"></colgroup>
<thead valign="bottom">
<tr>
<th class="head">Variable</th>
<th class="head">Description</th>
</tr>
</thead>
<tbody valign="top">
<tr>

<td><tt class="docutils literal"><span class="pre">forloop.counter</span></tt></td>
<td>当前循环次数 (1-indexed)</td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">forloop.counter0</span></tt></td>
<td>当前循环次数 (0-indexed)</td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">forloop.revcounter</span></tt></td>
<td>倒序循环时当前循环次数(1-indexed)</td>
</tr>

<tr>
<td><tt class="docutils literal"><span class="pre">forloop.revcounter0</span></tt></td>
<td>倒序循环时当前循环次数(0-indexed)</td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">forloop.first</span></tt></td>
<td>如果当前循环是循环过程的第一次则为True</td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">forloop.last</span></tt></td>
<td>如果当前循环是循环过程的最后一次则为True</td>

</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">forloop.parentloop</span></tt></td>
<td>对嵌套循环, 当前循环之上的循环</td>
</tr>
</tbody>
</table>
</blockquote>
</div>
<div class="section">
</html>
==== if ====
<html>
<p><tt class="docutils literal"><span class="pre">{%</span> <span class="pre">if</span> <span class="pre">%}</span></tt> 标签对一个变量求值, 若这个变量为 "true" , 就输出 <tt class="docutils literal"><span class="pre">if</span></tt> 内容块:</p>

<pre class="literal-block">
{% if athlete_list %}
    Number of athletes: {{ athlete_list|length }}
{% else %}
    No athletes.
{% endif %}
</pre>
<p>在上例中, 如果 <tt class="docutils literal"><span class="pre">athlete_list</span></tt> 非空, 运动员人数就会通过 <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">athlete_list|length</span> <span class="pre">}}</span></tt> 变量显示出来.</p>
<p>就象你刚刚看到的, <tt class="docutils literal"><span class="pre">if</span></tt> 标签可以带一个 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">else</span> <span class="pre">%}</span></tt> 子句,用来当 <tt class="docutils literal"><span class="pre">if</span></tt> 测试失败后输出相应的内容块.</p>

<p><tt class="docutils literal"><span class="pre">if``标签可以使用</span> <span class="pre">``and</span></tt>,“or“ 或 <tt class="docutils literal"><span class="pre">not</span></tt> 来测试一系列变量或否定一个给定的变量:</p>
<pre class="literal-block">
{% 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 (OK, so
    writing English translations of boolean logic sounds
    stupid; it's not our fault).
{% endif %}

{% if athlete_list and not coach_list %}
    There are some athletes and absolutely no coaches.
{% endif %}
</pre>
<p>为避免造成歧义, <tt class="docutils literal"><span class="pre">if``标签不允许在一个</span> <span class="pre">tag</span> <span class="pre">中同时有</span> <span class="pre">``and</span></tt> 和 <tt class="docutils literal"><span class="pre">or</span></tt> 逻辑; 举个例子，下面这个语句不能工作:</p>

<pre class="literal-block">
{% if athlete_list and coach_list or other_list %}
</pre>
<p>如果确实需要组合条件，可以使用嵌套的 <tt class="docutils literal"><span class="pre">if</span></tt> 实现相同的功能:</p>
<pre class="literal-block">
{% if athlete_list %}
    {% if coach_list or other_list %}
         We have athletes and , either coaches or others.
    {% endif %}
{% endif %}
</pre>
</div>
<div class="section">
</html>
==== ifchanged ====
<html>
<p>检查一个变量自上次循环之后是否发生了改变.(我的理解:主要用于过滤掉重复的值)</p>

<p>‘ifchanged’ block标签用于循环中. 它根据自身上次的状态检查自己值, 只有值发生变化时才显示这个值:</p>
<pre class="literal-block">
&lt;h1&gt;Archive for {{ year }}&lt;/h1&gt;

{% for day in days %}
{% ifchanged %}&lt;h3&gt;{{ day|date:"F" }}&lt;/h3&gt;{% endifchanged %}
&lt;a href="{{ day|date:"M/d"|lower }}/"&gt;{{ day|date:"j" }}&lt;/a&gt;

{% endfor %}
</pre>
</div>
<div class="section">
</html>
==== ifequal ====
<html>
<p>若两个参数相等,输出一个内容块.</p>
<p>例子:</p>
<pre class="literal-block">
{% ifequal user.id comment.user_id %}
    ...
{% endifequal %}
</pre>
<p>如同 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">if</span> <span class="pre">%}</span></tt> tag, 它也支持一个可选的 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">else</span> <span class="pre">%}</span></tt> 子句.</p>

<p>参数可以是变量,也可以是字符串字面值, 也就是说下面这样也是合法的:</p>
<pre class="literal-block">
{% ifequal user.username "adrian" %}
    ...
{% endifequal %}
</pre>
</div>
<div class="section">
</html>
==== ifnotequal ====
<html>
<p>类似 <tt class="docutils literal"><span class="pre">ifequal</span></tt>, 只是它用来测试两个参数是否不等.</p>
</div>
<div class="section">
</html>
==== include ====
<html>

<p>载入一个模板并根据当前上下文渲染它.用于在一个模板中包含其它模板.</p>
<p>模板名字可以是一个变量,也可以是一个字符串(带引号的字符串,无所谓单引号还是双引号).</p>
<p>下面这个例子包含了 <tt class="docutils literal"><span class="pre">"foo/bar.html"</span></tt> 模板的内容:</p>
<pre class="literal-block">
{% include "foo/bar.html" %}
</pre>
<p>下面这个例子包含了另一个模板(该模板的名字为变量 <tt class="docutils literal"><span class="pre">template_name</span></tt> 的值)的内容:</p>

<pre class="literal-block">
{% include template_name %}
</pre>
<p>被包含的模板使用包含它的模板的上下文(也就是环境)进行渲染(求值),下面这个例子输出 <tt class="docutils literal"><span class="pre">"Hello,</span> <span class="pre">John"</span></tt>:</p>
<blockquote>
<ul>
<li>
<p class="first">Context: variable <tt class="docutils literal"><span class="pre">person</span></tt> is set to <tt class="docutils literal"><span class="pre">"john"</span></tt>.</p>

</li>
<li>
<p class="first">Template:</p>
<pre class="literal-block">
{% include "name_snippet.html" %}
</pre>
</li>
<li>
<p class="first">The <tt class="docutils literal"><span class="pre">name_snippet.html</span></tt> template:</p>
<pre class="literal-block">
Hello, {{ person }}
</pre>

</li>
</ul>
</blockquote>
<p>参阅: <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">ssi</span> <span class="pre">%}</span></tt>.</p>
</div>
<div class="section">
</html>
==== load ====
<html>
<p>装入一个自定义模板标签集.</p>

<p>参阅 <a class="reference" href="#id5">自定义标签及过滤器库</a> 以了解更多信息.</p>
</div>
<div class="section">
</html>
==== now ====
<html>
<p>显示当前日期, 根据给定的字符串决定输出格式.</p>
<p>使用和 PHP 的 <tt class="docutils literal"><span class="pre">date()</span></tt> 函数一样的格式码 (<a class="reference" href="http://php.net/date">http://php.net/date</a>) 并做了一些扩展</p>

<p>可用的格式字符串:</p>
<blockquote>
<table class="docutils" border="1">
<colgroup>
<col width="12%">
<col width="31%">
<col width="57%"></colgroup>
<thead valign="bottom">
<tr>
<th class="head">格式字符</th>
<th class="head">描述</th>
<th class="head">输出示例</th>
</tr>

</thead>
<tbody valign="top">
<tr>
<td>a</td>
<td><tt class="docutils literal"><span class="pre">'a.m.'</span></tt> 或 <tt class="docutils literal"><span class="pre">'p.m.'</span></tt> (注意,它与PHP 的输出略有不同.它包括了句点(django扩展).</td>
<td><tt class="docutils literal"><span class="pre">'a.m.'</span></tt></td>
</tr>
<tr>
<td>A</td>

<td><tt class="docutils literal"><span class="pre">'AM'</span></tt> 或 <tt class="docutils literal"><span class="pre">'PM'</span></tt>.</td>
<td><tt class="docutils literal"><span class="pre">'AM'</span></tt></td>
</tr>
<tr>
<td>B</td>
<td>未实现.</td>
<td>&nbsp;</td>
</tr>
<tr>

<td>d</td>
<td>每月第几天, 带前导零</td>
<td><tt class="docutils literal"><span class="pre">'01'</span></tt> to <tt class="docutils literal"><span class="pre">'31'</span></tt></td>
</tr>
<tr>
<td>D</td>
<td>每周第几天,3字母的字符串.</td>
<td><tt class="docutils literal"><span class="pre">'Fri'</span></tt></td>

</tr>
<tr>
<td>f</td>
<td>时间, 12-小时制的小时和分钟数, 如果分钟数为零,则不显示.(django 扩展).</td>
<td><tt class="docutils literal"><span class="pre">'1'</span></tt>, <tt class="docutils literal"><span class="pre">'1:30'</span></tt></td>
</tr>
<tr>
<td>F</td>
<td>月份, 长文本格式.</td>
<td><tt class="docutils literal"><span class="pre">'January'</span></tt></td>

</tr>
<tr>
<td>g</td>
<td>小时, 12-小时制,没有前导零</td>
<td><tt class="docutils literal"><span class="pre">'1'</span></tt> to <tt class="docutils literal"><span class="pre">'12'</span></tt></td>
</tr>
<tr>
<td>G</td>
<td>小时, 24-小时制,没有前导零</td>

<td><tt class="docutils literal"><span class="pre">'0'</span></tt> to <tt class="docutils literal"><span class="pre">'23'</span></tt></td>
</tr>
<tr>
<td>h</td>
<td>小时, 12-小时制,有前导零</td>
<td><tt class="docutils literal"><span class="pre">'01'</span></tt> to <tt class="docutils literal"><span class="pre">'12'</span></tt></td>
</tr>

<tr>
<td>H</td>
<td>小时, 24-小时制,有前导零</td>
<td><tt class="docutils literal"><span class="pre">'00'</span></tt> to <tt class="docutils literal"><span class="pre">'23'</span></tt></td>
</tr>
<tr>
<td>i</td>
<td>分钟.</td>
<td><tt class="docutils literal"><span class="pre">'00'</span></tt> to <tt class="docutils literal"><span class="pre">'59'</span></tt></td>

</tr>
<tr>
<td>I</td>
<td>未实现</td>
<td>&nbsp;</td>
</tr>
<tr>
<td>j</td>
<td>每月第几天, 无前导零</td>
<td><tt class="docutils literal"><span class="pre">'1'</span></tt> to <tt class="docutils literal"><span class="pre">'31'</span></tt></td>

</tr>
<tr>
<td>l</td>
<td>每周第几天,长文本格式.</td>
<td><tt class="docutils literal"><span class="pre">'Friday'</span></tt></td>
</tr>
<tr>
<td>L</td>
<td>是否闰年.</td>
<td><tt class="docutils literal"><span class="pre">True</span></tt> or <tt class="docutils literal"><span class="pre">False</span></tt></td>

</tr>
<tr>
<td>m</td>
<td>数字表示的月份,有前导零.</td>
<td><tt class="docutils literal"><span class="pre">'01'</span></tt> to <tt class="docutils literal"><span class="pre">'12'</span></tt></td>
</tr>
<tr>
<td>M</td>
<td>月份,3字母短文本格式.</td>

<td><tt class="docutils literal"><span class="pre">'Jan'</span></tt></td>
</tr>
<tr>
<td>n</td>
<td>数字表示的月份,无前导零</td>
<td><tt class="docutils literal"><span class="pre">'1'</span></tt> to <tt class="docutils literal"><span class="pre">'12'</span></tt></td>
</tr>
<tr>
<td>N</td>

<td>出版风格的月份缩写(django 扩展)</td>
<td><tt class="docutils literal"><span class="pre">'Jan.'</span></tt>, <tt class="docutils literal"><span class="pre">'Feb.'</span></tt>, <tt class="docutils literal"><span class="pre">'March'</span></tt>, <tt class="docutils literal"><span class="pre">'May'</span></tt></td>
</tr>
<tr>
<td>O</td>
<td>与格林威治的时间差(以小时计)</td>
<td><tt class="docutils literal"><span class="pre">'+0200'</span></tt></td>

</tr>
<tr>
<td>P</td>
<td>12小时制的小时分钟及’a.m.’/'p.m.’ 分钟数若为零则不显示. 用字符串表示特殊的时间点, 如 ‘midnight’ 和 ‘noon’ (django扩展)</td>
<td><tt class="docutils literal"><span class="pre">'1</span> <span class="pre">a.m.'</span></tt>, <tt class="docutils literal"><span class="pre">'1:30</span> <span class="pre">p.m.'</span></tt>, <tt class="docutils literal"><span class="pre">'midnight'</span></tt>, <tt class="docutils literal"><span class="pre">'noon'</span></tt>, <tt class="docutils literal"><span class="pre">'12:30</span> <span class="pre">p.m.'</span></tt></td>

</tr>
<tr>
<td>r</td>
<td>RFC 822 格式的日期 .</td>
<td><tt class="docutils literal"><span class="pre">'Thu,</span> <span class="pre">21</span> <span class="pre">Dec</span> <span class="pre">2000</span> <span class="pre">16:01:07</span> <span class="pre">+0200'</span></tt></td>

</tr>
<tr>
<td>s</td>
<td>秒数, 带有前导零的数字表示</td>
<td><tt class="docutils literal"><span class="pre">'00'</span></tt> to <tt class="docutils literal"><span class="pre">'59'</span></tt></td>
</tr>
<tr>
<td>S</td>
<td>英语序数后缀,用于一个月的第几天,2个字符</td>

<td><tt class="docutils literal"><span class="pre">'st'</span></tt>, <tt class="docutils literal"><span class="pre">'nd'</span></tt>, <tt class="docutils literal"><span class="pre">'rd'</span></tt> or <tt class="docutils literal"><span class="pre">'th'</span></tt></td>
</tr>
<tr>
<td>t</td>
<td>给定月共有多少天.</td>
<td><tt class="docutils literal"><span class="pre">28</span></tt> to <tt class="docutils literal"><span class="pre">31</span></tt></td>

</tr>
<tr>
<td>T</td>
<td>本机时区.</td>
<td><tt class="docutils literal"><span class="pre">'EST'</span></tt>, <tt class="docutils literal"><span class="pre">'MDT'</span></tt></td>
</tr>
<tr>
<td>U</td>
<td>未实现</td>
<td>&nbsp;</td>

</tr>
<tr>
<td>w</td>
<td>一周中的第几天,没有前导零的数字</td>
<td><tt class="docutils literal"><span class="pre">'0'</span></tt> (Sunday) to <tt class="docutils literal"><span class="pre">'6'</span></tt> (Saturday)</td>
</tr>
<tr>
<td>W</td>

<td>ISO-8601 一年的第多少星期数, 一周从星期一开始</td>
<td><tt class="docutils literal"><span class="pre">1</span></tt>, <tt class="docutils literal"><span class="pre">23</span></tt></td>
</tr>
<tr>
<td>y</td>
<td>Year, 2 位数字表示</td>
<td><tt class="docutils literal"><span class="pre">'99'</span></tt></td>
</tr>
<tr>
<td>Y</td>

<td>Year, 4 位数字表示</td>
<td><tt class="docutils literal"><span class="pre">'1999'</span></tt></td>
</tr>
<tr>
<td>z</td>
<td>一年中的第几天 .</td>
<td><tt class="docutils literal"><span class="pre">0</span></tt> to <tt class="docutils literal"><span class="pre">365</span></tt></td>
</tr>
<tr>

<td>Z</td>
<td>以秒计的时区偏移量. 这个偏移量对UTC西部时区总是负数,而对UTC东部时区则总是正数</td>
<td><tt class="docutils literal"><span class="pre">-43200</span></tt> to <tt class="docutils literal"><span class="pre">43200</span></tt></td>
</tr>
</tbody>
</table>
</blockquote>
<p>例子:</p>
<pre class="literal-block">
It is {% now "jS F Y H:i" %}

</pre>
<p>注意你可以使用反斜线转义一个格式字符串中的敏感字符.(如果你想使用其原始值的话).在下面这个例子里, "f" 被用反斜线转义, 因为 "f" 本身是一个用于显示时间的格式字符. "o" 不需要被转义,因为它不是一个格式字符.:</p>
<pre class="literal-block">
It is the {% now "jS o\f F" %}
</pre>
<p>(显示 "It is the 4th of September" %}</p>
</div>
<div class="section">
</html>


==== regroup ====

Regroup a list of alike objects by a common attribute.

要搞懂这个复杂的标签, 最好还是用一个例子来说明(一幅图胜过千句话): 有一个 people 对象,它是一个 Person 对象(拥有 first_name, last_name 及 gender 属性)的列表. 你想显示一个象下面这样的列表:
  * Male:
    * George Bush
    * Bill Clinton
  * Female:
    * Margaret Thatcher
    * Condoleezza Rice
  * Unknown:
    * Pat Smith

下面的模板代码片断可以完成这个看上去复杂的任务:

<code html>
{% regroup people by gender as grouped %}
<ul>
{% for group in grouped %}
    <li>{{ group.grouper }}
    <ul>

        {% for item in group.list %}
        <li>{{ item }}</li>
        {% endfor %}
    </ul>
{% endfor %}
</ul>
</code>

如同你看到的, {% regroup %} 生成一个变量包含一个对象的列表. 列表中的每个对象都拥有 grouper 和 list 属性. grouper 装有分组的条目; list 包含一系列拥有共同 grouper 属性的对象. 在这个例子里, grouper 可能是 Male, Female 和 Unknown, 而 list 则是属于这几种性别的人的列表.

注意当这个被分组的列表没有按你要分组的键排序时, {% regroup %} 将不能工作! 这就是说你的 people 列表如果没有按 gender 排序, 你就必须得保证在使用它之前先将它排好序,也就是:

{% regroup people|dictsort:"gender" by gender as grouped %}

====  spaceless ====
<html> 
<p>将HTML标签之间的空白格式化为一个空格. 空白包括空格,换行,制表符.</p>
<p>示例:</p>
<pre class="literal-block">
{% spaceless %}
    &lt;p&gt;
        &lt;a href="foo/"&gt;Foo&lt;/a&gt;
    &lt;/p&gt;

{% endspaceless %}
</pre>
<p>这个例子将返回这样的HTML:</p>
<pre class="literal-block">
&lt;p&gt; &lt;a href="foo/"&gt;Foo&lt;/a&gt; &lt;/p&gt;
</pre>
<p>只有 <em>标签</em> 之间的空白被处理 — 标签与文本之间的空白不会被处理.在下面这个例子里, <tt class="docutils literal"><span class="pre">Hello</span></tt> 周围的空白不会被缩小:</p>

<pre class="literal-block">
{% spaceless %}
    &lt;strong&gt;
        Hello
    &lt;/strong&gt;
{% endspaceless %}
</pre>
</div>
<div class="section">
</html>
==== ssi ====
<html>
<p>在页面中输出给定文件的内容.</p>
<p>类似一个简单的 "include" 标签, <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">ssi</span> <span class="pre">%}</span></tt> 包含另一个文件的内容 — 不过必须在当前页面指定一个绝对路径</p>

<pre class="literal-block">
{% ssi /home/html/ljworld.com/includes/right_generic.html %}
</pre>
<p>如果提供了可选的 "parsed" 参数, 被包含文件的内容会使用当前的上下文作为模板代码进行求值处理.:</p>
<pre class="literal-block">
{% ssi /home/html/ljworld.com/includes/right_generic.html parsed %}
</pre>
<p>注意如何你使用 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">ssi</span> <span class="pre">%}</span></tt>, 出于安全考虑, 你需要在你的 <tt class="docutils literal"><span class="pre">Django</span> <span class="pre">settings</span></tt> 文件中定义 <a class="reference" href="http://www.djangoproject.com/documentation/settings/#allowed-include-roots">ALLOWED_INCLUDE_ROOTS</a> .</p>

<p>参阅: <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">include</span> <span class="pre">%}</span></tt>.</p>
</div>
<div class="section">
</html>
==== templatetag ====
<html>
<p>输出一个组成模板标签的字符.</p>
<p>由于模板系统没有 "转义" 的概念, 要显示一个组成模板标签的字符, 你必须使用 <tt class="docutils literal"><span class="pre">{%</span> <span class="pre">templatetag</span> <span class="pre">%}</span></tt> 标签.</p>

<p>用参数告诉标签输出哪些内容:</p>
<blockquote>
<table class="docutils" border="1">
<colgroup>
<col width="72%">
<col width="28%"></colgroup>
<thead valign="bottom">
<tr>
<th class="head">参数</th>
<th class="head">输出</th>
</tr>
</thead>
<tbody valign="top">
<tr>

<td><tt class="docutils literal"><span class="pre">openblock</span></tt></td>
<td><tt class="docutils literal"><span class="pre">{%</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">closeblock</span></tt></td>
<td><tt class="docutils literal"><span class="pre">%}</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">openvariable</span></tt></td>
<td><tt class="docutils literal"><span class="pre">{{</span></tt></td>
</tr>

<tr>
<td><tt class="docutils literal"><span class="pre">closevariable</span></tt></td>
<td><tt class="docutils literal"><span class="pre">}}</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">openbrace</span></tt></td>
<td><tt class="docutils literal"><span class="pre">{</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">closebrace</span></tt></td>
<td><tt class="docutils literal"><span class="pre">}</span></tt></td>

</tr>
</tbody>
</table>
</blockquote>
</div>
<div class="section">
</html>
==== widthratio ====
<html>
<p>要创建柱形图的话, 这个标签计算给定值与最大值的比率再乘以100,四舍五入为整数,最后输出这个整数.</p>
<p>例子:</p>
<pre class="literal-block">
&lt;img src="bar.gif" height="10" width="{% widthratio this_value max_value 100 %}" /&gt;
</pre>
<p>上例中, 如果 <tt class="docutils literal"><span class="pre">this_value</span></tt> 是 175 而 <tt class="docutils literal"><span class="pre">max_value</span></tt> 是 200, 则上例中的图片应该是 88 像素宽 (因为 175/200 = .875; .875 * 100 = 87.5 四舍五入为 88).</p>

</div>
</div>
<div class="section">
<h2><a id="id9" name="id9">内建过滤器参考</a></h2>
<div class="section">
</html>
==== add ====
<html>
<p>返回参数与被处理数据相加的结果.</p>
</div>
<div class="section">
</html>
==== addslashes ====
<html>
<p>给敏感字符添加斜线(转义). 举例,要将一个字符串传递给 JavaScript 时..</p>
</div>

<div class="section">
</html>
==== capfirst ====
<html>
<p>大写被处理数据的第一个字母.</p>
</div>
<div class="section">
</html>
==== center ====
<html>
<p>按给定宽度将待处理数据居中.</p>
</div>
<div class="section">
</html>
==== cut ====
<html>
<p>将待处理数据中的所有子串删除(该子串等于 cut 的参数)</p>

</div>
<div class="section">
</html>
==== date ====
<html>
<p>根据给定的格式(与 <tt class="docutils literal"><span class="pre">now</span></tt> 标签相同)格式化一个日期.</p>
</div>
<div class="section">
</html>
==== default ====
<html>
<p>如果值不可用,使用提供的默认值.</p>
</div>
<div class="section">

</html>
==== default_if_none ====
<html>
<p>如果值为 <tt class="docutils literal"><span class="pre">None</span></tt>, 使用这个给定的默认值.</p>
</div>
<div class="section">
</html>
==== dictsort ====
<html>
<p>接受一个字典列表,返回按给定参数的属性排序后的列表.</p>
</div>
<div class="section">
</html>
==== dictsortreversed ====
<html>
<p>接受一个字典列表,返回按给定参数的属性逆序排序后的列表.</p>

</div>
<div class="section">
</html>
==== divisibleby ====
<html>
<p>如果值可以被参数除尽,则返回 True.</p>
</div>
<div class="section">
</html>
==== escape ====
<html>
<p>对一个字符串的敏感字符进入转义(以用于HTML). 特别是它会做如下替换:</p>
<blockquote>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">"&amp;"</span></tt> to <tt class="docutils literal"><span class="pre">"&amp;amp;"</span></tt></li>

<li><tt class="docutils literal"><span class="pre">&lt;</span></tt> to <tt class="docutils literal"><span class="pre">"&amp;lt;"</span></tt></li>
<li><tt class="docutils literal"><span class="pre">&gt;</span></tt> to <tt class="docutils literal"><span class="pre">"&amp;gt;"</span></tt></li>
<li><tt class="docutils literal"><span class="pre">'"'</span></tt> (double quote) to <tt class="docutils literal"><span class="pre">'&amp;quot;'</span></tt></li>
<li><tt class="docutils literal"><span class="pre">"'"</span></tt> (single quote) to <tt class="docutils literal"><span class="pre">'&amp;#39;'</span></tt></li>

</ul>
</blockquote>
</div>
<div class="section">
</html>
==== filesizeformat ====
<html>
<p>将值格式化为 ‘可读性好的’ 文件大小(比如 <tt class="docutils literal"><span class="pre">'13</span> <span class="pre">KB'</span></tt>, <tt class="docutils literal"><span class="pre">'4.1</span> <span class="pre">MB'</span></tt>, <tt class="docutils literal"><span class="pre">'102bytes'</span></tt> 等等).</p>

</div>
<div class="section">
</html>
==== first ====
<html>
<p>返回列表中的第一个元素.</p>
</div>
<div class="section">
</html>
==== fix_ampersands ====
<html>
<p>将 <tt class="docutils literal"><span class="pre">&amp;</span></tt> 符号替换为 <tt class="docutils literal"><span class="pre">&amp;amp;</span></tt> 实体.</p>

</div>
<div class="section">
</html>
==== floatformat ====
<html>
<p>将一个浮点数四舍五入到小数点后1位 — 如果根本没有小数,小数部分不会显示.例如:</p>
<blockquote>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">36.123</span></tt> 被转换成 <tt class="docutils literal"><span class="pre">36.1</span></tt></li>
<li><tt class="docutils literal"><span class="pre">36.15</span></tt> 被转换成 <tt class="docutils literal"><span class="pre">36.2</span></tt></li>

<li><tt class="docutils literal"><span class="pre">36</span></tt> 被转换成 <tt class="docutils literal"><span class="pre">36</span></tt></li>
</ul>
</blockquote>
</div>
<div class="section">
</html>
==== get_digit ====
<html>
<p>提供一个完整的数, 返回该数中被请求的数字,其中 1 是最右边的数, 2 是从右边数第二个数字等等. 若输入值非法(若输入或参数不是整数, 或者参数小于1)则返回其原始值. 否则输出就总是整数.</p>
</div>
<div class="section">
</html>
==== join ====
<html>

<p>用一个字符串将一个列表连接起来, 类似 Python 的 <tt class="docutils literal"><span class="pre">str.join(list)</span></tt>.</p>
</div>
<div class="section">
</html>
==== length ====
<html>
<p>返回值的长度. 对列表特别有用.</p>
</div>
<div class="section">
</html>
==== length_is ====
<html>
<p>若值的长度与参数相等,返回 True, 否则返回 False.</p>
</div>

<div class="section">
</html>
==== linebreaks ====
<html>
<p>将换行符转化为 &lt;p&gt; 和 &lt;br /&gt;.</p>
</div>
<div class="section">
</html>
==== linebreaksbr ====
<html>
<p>将换行符转化为 &lt;br /&gt;.</p>

</div>
<div class="section">
</html>
==== linenumbers ====
<html>
<p>带行号显示文本.</p>
</div>
<div class="section">
</html>
==== ljust ====
<html>
<p>在给定宽度的域内将文本左对齐.</p>
<p><strong>参数:</strong> 域宽度</p>
</div>

<div class="section">
</html>
==== lower ====
<html>
<p>将字符串转化为小写.</p>
</div>
<div class="section">
</html>
==== make_list ====
<html>
<p>将值转化为一个列表.对一个整数,它是一个数字的列表.对一个字符串,这是一个字符的列表.</p>
</div>
<div class="section">
</html>
==== phone2numeric ====
<html>
<p>将一个电话号码(可能包含字母)转化等价的数字值.比如: <tt class="docutils literal"><span class="pre">'800-COLLECT'</span></tt> 将被转化为 <tt class="docutils literal"><span class="pre">'800-2655328'</span></tt>.</p>

<p>输入不一定非是一个合法号码. 它可以转化任意字符串.</p>
</div>
<div class="section">
</html>
==== pluralize ====
<html>
<p>如果值不是 1 的话返回 ‘s’ 用于 ’1 vote’ vs. ’2 votes’ 这种场合. 例如:</p>
<pre class="literal-block">
you have {{number_messages}} mail{{number_messages|pluralize}}.
(对中国人用处不大，嘿嘿）
</pre>
</div>
<div class="section">
</html>
==== pprint ====
<html>
<p>pprint.pprint 和一个封装器– 仅用于调试.</p>

</div>
<div class="section">
</html>
==== random ====
<html>
<p>返回随机的从列表中返回一个元素</p>
</div>
<div class="section">
</html>
==== removetags ====
<html>
<p>从输出中删除单空格分隔的 [X]HTML标签 列表</p>
</div>
<div class="section">
</html>
==== rjust ====
<html>
<p>在给定宽度的域内将文本右对齐.</p>

<p><strong>参数:</strong> 域大小</p>
</div>
<div class="section">
</html>
==== slice ====
<html>
<p>返回一个列表的片段.</p>
<p>使用与 Python 的 list 相同的语法, 参阅 <a class="reference" href="http://diveintopython.org/native_data_types/lists.html#odbchelper.list.slice">http://diveintopython.org/native_data_types/lists.html#odbchelper.list.slice</a> 以了解更详细的信息.</p>
<p>示例: <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">some_list|slice:":2"</span> <span class="pre">}}</span></tt></p>

</div>
<div class="section">
</html>
==== slugify ====
<html>
<p>转化为小写, 移去非单词字符(字母数字和下划线),将空白转化为连字符,去除前后空白.</p>
</div>
<div class="section">
</html>
==== stringformat ====
<html>
<p>根据给定参数(一个格式字符串)格式化一个变量, 这个格式字符串使用 Python 字符串格式化语法, 例外之处是 "%" 运算符被省略.</p>
<p>参阅 <a class="reference" href="http://docs.python.org/lib/typesseq-strings.html">http://docs.python.org/lib/typesseq-strings.html</a> 以了解 Python 格式字符串</p>

</div>
<div class="section">
</html>
==== striptags ====
<html>
<p>过滤掉[X]HTML标签.</p>
</div>
<div class="section">
</html>
==== time ====
<html>
<p>根据给定的格式, 格式化一个时间(与 <tt class="docutils literal"><span class="pre">now</span></tt> 标签使用的格式相同).</p>
</div>
<div class="section">

</html>
==== timesince ====
<html>
<p>格式化一个日期,这个日期是从给定日期到现在的天数和小时数(比如: "4 days, 6 hours").</p>
<p>接受一个可选的参数，该参数是一个包含比较日期的变量（该参数默认值是 <em>now</em>). 举例来说， 如果 <tt class="docutils literal"><span class="pre">blog_date</span></tt> 是一个日期实例表示 2006-06-01 午夜， 而 <tt class="docutils literal"><span class="pre">comment_date</span></tt> 是一个日期实例表示 2006-06-01 早上8点，那么 <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">comment_date|timesince:blog_date</span> <span class="pre">}}</span></tt> 将返回 "8 hours".</p>

</div>
<div class="section">
</html>
==== timeuntil ====
<html>
<p>类似 <tt class="docutils literal"><span class="pre">timesince</span></tt>, 只是它比较当前时间直到给定日期时间。举例来说，如果今天是 2006-06-01 而 <tt class="docutils literal"><span class="pre">conference_date</span></tt> 是 2006-06-29, 那么 <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">conference_date|timeuntil</span> <span class="pre">}}</span></tt> 将返回 "28 days".</p>

<p>接受一个可选的参数，该参数是一个包含比较日期的变量（该参数默认值是 <em>now</em>). 举例来说， 如果 <tt class="docutils literal"><span class="pre">from_date</span></tt> 是一个日期实例表示 2006-06-22， 那么 <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">conference_date|timeuntil:from_date</span> <span class="pre">}}</span></tt> 会返回 "7 days".</p>
</div>
<div class="section">
</html>
==== title ====
<html>

<p>按标题格式转化一个字符串</p>
</div>
<div class="section">
</html>
==== truncatewords ====
<html>
<p>将一个字符串截短为指定数目的单词.</p>
<p><strong>参数:</strong> 要保留的单词数</p>
</div>
<div class="section">
</html>
==== unordered_list ====
<html>
<p>递归的接受一个自嵌套的列表并返回一个HTML无序列表(此列表可不是pythob语义中的列表) — 只是没有开始和结束的&lt;ul&gt;标签.</p>

<p>假定该列表是合适的格式. 举例来说, 如果 <tt class="docutils literal"><span class="pre">var</span></tt> 的值为 <tt class="docutils literal"><span class="pre">['States',</span> <span class="pre">[['Kansas',</span> <span class="pre">[['Lawrence',</span> <span class="pre">[]],</span> <span class="pre">['Topeka',</span> <span class="pre">[]]]],</span> <span class="pre">['Illinois',</span> <span class="pre">[]]]]</span></tt>, 那么 <tt class="docutils literal"><span class="pre">{{</span> <span class="pre">var|unordered_list</span> <span class="pre">}}</span></tt> 就会返回:</p>

<pre class="literal-block">
&lt;li&gt;States
&lt;ul&gt;
        &lt;li&gt;Kansas
        &lt;ul&gt;
                &lt;li&gt;Lawrence&lt;/li&gt;
                &lt;li&gt;Topeka&lt;/li&gt;

        &lt;/ul&gt;
        &lt;/li&gt;
        &lt;li&gt;Illinois&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
</pre>
</div>

</html>



==== upper ====


将一个字符串全部转为大写.

==== urlencode ====


转义该值以用于 URL.

==== urlize ====


将普通文本的 URL 转化为可点击的链接.

==== urlizetrunc ====


将 URL 转化为一个可点击的链接, 根据给定的字符数截短 URL.

参数: URL长度

==== wordcount ====


返回单词数

==== wordwrap ====


在指定行长将文字折行.

参数: 行长(以字符计)

==== yesno ====


提供一个字符串参数对应着 true, false 和 (可选的) None, 根据被处理的值返回相应的字符串:

<html>
<table class="docutils" border="1">
<colgroup>

<col width="15%">
<col width="33%">
<col width="52%"></colgroup>
<thead valign="bottom">
<tr>
<th class="head">Value</th>
<th class="head">Argument</th>
<th class="head">Outputs</th>
</tr>
</thead>
<tbody valign="top">
<tr>
<td><tt class="docutils literal"><span class="pre">True</span></tt></td>

<td><tt class="docutils literal"><span class="pre">"yeah,no,maybe"</span></tt></td>
<td><tt class="docutils literal"><span class="pre">yeah</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">False</span></tt></td>
<td><tt class="docutils literal"><span class="pre">"yeah,no,maybe"</span></tt></td>
<td><tt class="docutils literal"><span class="pre">no</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">None</span></tt></td>
<td><tt class="docutils literal"><span class="pre">"yeah,no,maybe"</span></tt></td>

<td><tt class="docutils literal"><span class="pre">maybe</span></tt></td>
</tr>
<tr>
<td><tt class="docutils literal"><span class="pre">None</span></tt></td>
<td><tt class="docutils literal"><span class="pre">"yeah,no"</span></tt></td>
<td><tt class="docutils literal"><span class="pre">"no"</span></tt> (如果没有对应 None 的字符串,就将 None 转化为 False 处理</td>
</tr>
</tbody>
</table>
 
</html>

===== 其它 tags 和 filter 库 =====


Django 自带了几个其它的模板 tag 库，要使用这些 tag 库，必须显式的在 INSTALLED_APPS 设置中启用他们，然后在模板中使用 {% load %} tag 载入他们.

==== django.contrib.humanize ====


一堆 Django 模板过滤器，用于生成易读的数据，参阅 humanize documentation.

==== django.contrib.markup ====


一堆模板过滤器，支持以下常见标记语言:：

  * Textile
  * Markdown
  * ReST (ReStructured Text)
Python 俱乐部

用户工具

站点工具

页面工具
