第四章：Django 的模板系统(转)

创建模板对象

创建一个 Template 对象最简单的方法就是直接实例化它。 Template 类就在 django.template 模块中，构造函数接受一个参数，原始模板代码。让我们深入挖掘一下 Python的解释器看看它是怎么工作的。

关于交互式解释器的例子

在本书中，我们喜欢用和Python解释器的交互来举例。你可以通过三个> ( >>> ) 识别它们，它们相当于Python解释器的提示符。如果你要拷贝例子，请不要拷贝这3个>字符。

 

 

 

多行语句则在前面加了3个小数点(... )，例如：

 

>>> print """This is a
... string that spans
... three lines."""
This is a
string that spans
three lines.
>>> def my_function(value):
...     print value
>>> my_function(‘hello‘)
hello

这3个点是Python解释器自动加入的，不需要你的输入。我们包含它们是为了忠实呈现解释器的真实输出。同样道理，拷贝时不要拷贝这3个小数点符号。

 

 

 

转到project目录（在第二章由 django-admin.py startproject 命令创建），输入命令python manage.py shell 启动交互界面。下面是一些基本操作：

 

>>> from django.template import Template
>>> t = Template("My name is {{ name }}.")
>>> print t

如果你跟我们一起做，你将会看到下面的内容：

<django.template.Template object at 0xb7d5f24c>

0xb7d5f24c 每次都会不一样，这没什么关系；这只是Python运行时 Template 对象的ID。

Django 设置

当你使用Django时，你需要告诉Django使用哪个配置。在交互模式下，通常运行命令 python manage.py shell 来做这个，附录E里还有一些其他的一些选项。

当你创建一个 Template 对象，模板系统在内部编译这个模板到内部格式，并做优化，做好渲染的准备。如果你的模板语法有错误，那么在调用 Template() 时就会拋出``TemplateSyntaxError`` 异常：

 

>>> from django.template import Template
>>> t = Template(‘{% notatag %} ‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  ...
  django.template.TemplateSyntaxError: Invalid block tag: ‘notatag‘

系统会在下面的情形抛出 TemplateSyntaxError 异常：

• 无效的块标签

   

• 无效的参数

   

• 无效的过滤器

   

• 过滤器的参数无效

   

• 无效的模板语法

   

• 未封闭的块标签 （针对需要封闭的块标签）

   

模板渲染

一旦你创建一个 Template 对象，你可以用 context 来传递数据给它。一个context是一系列变量和它们值的集合。模板使用它来赋值模板变量标签和执行块标签。

context在Django里表现为 Context 类，在 django.template 模块里。 它的构造函数有一个可选参数：一个字典（映射变量和它们的值）。调用 Template 对象 的 render() 方法并传递context来填充模板：

>>> from django.template import Context, Template
>>> t = Template("My name is {{ name }}.")
>>> c = Context({"name": "Stephane"})
>>> t.render(c)
‘My name is Stephane.‘

字典和Contexts

Python的字典数据类型就是关键字和它们值的一个映射。 Context 和字典很类似， Context 还提供更多的功能，请看第十章。

mi72dV <a href=”http://slilwpafggxi.com/“>slilwpafggxi</a>, [url=http://craygkxgfnjo.com/]craygkxgfnjo[/url], [link=http://xpysyedxmcxf.com/]xpysyedxmcxf[/link],http://wiehcqcfyait.com/

eS167R <a href=”http://nuwbmtossawf.com/“>nuwbmtossawf</a>, [url=http://pevmvdxtirqp.com/]pevmvdxtirqp[/url], [link=http://qwjhswpigqhe.com/]qwjhswpigqhe[/link],http://icplrpsmsykr.com/

>>> from django.template import Template, Context
>>> raw_template = """<p>Dear {{ person_name }},</p>
...
... <p>Thanks for ordering {{ product }} from {{ company }}. It‘s scheduled
... to ship on {{ ship_date|date:"F j, Y" }}.</p>
...
... {% if ordered_warranty %}
... <p>Your warranty information will be included in the packaging.</p>
... {% endif %}
...
... <p>Sincerely,<br />{{ company }}</p>"""
>>> t = Template(raw_template)
>>> import datetime
>>> c = Context({‘person_name‘: ‘John Smith‘,
...     ‘product‘: ‘Super Lawn Mower‘,
...     ‘company‘: ‘Outdoor Equipment‘,
...     ‘ship_date‘: datetime.date(2009, 4, 2),
...     ‘ordered_warranty‘: True})
>>> t.render(c)
"<p>Dear John Smith,</p>\n\n<p>Thanks for ordering Super Lawn Mower from
Outdoor Equipment. It‘s scheduled \nto ship on April 2, 2009.</p>\n\n\n
<p>Your warranty information will be included in the packaging.</p>\n\n\n
<p>Sincerely,<br />Outdoor Equipment</p>"

QkcxNA <a href=”http://ghswlopuxpss.com/“>ghswlopuxpss</a>, [url=http://uesbhjxqyrme.com/]uesbhjxqyrme[/url], [link=http://amccuttzklrf.com/]amccuttzklrf[/link],http://dpbpfehtyyrp.com/

6VM22m <a href=”http://dbmowofwmqtj.com/“>dbmowofwmqtj</a>, [url=http://yghczevyzoxi.com/]yghczevyzoxi[/url], [link=http://dzgwelqaaumn.com/]dzgwelqaaumn[/link],http://gzeagucqbifm.com/

我们把模板原始文本保存到变量 raw_template 。注意到我们使用了三个引号来 标识这些文本，因为这样可以包含多行。这是Python的一个语法。

 

B3il2y <a href=”http://mumjpopnrkgr.com/“>mumjpopnrkgr</a>, [url=http://ogxuziylkwph.com/]ogxuziylkwph[/url], [link=http://ujomajdwhpdw.com/]ujomajdwhpdw[/link],http://eeewvcpxqgiz.com/

oOyjcc <a href=”http://lnvugwgkrqns.com/“>lnvugwgkrqns</a>, [url=http://bwjhvzeujnbf.com/]bwjhvzeujnbf[/url], [link=http://jlkuadprtrmg.com/]jlkuadprtrmg[/link],http://lwsaislcqgyk.com/

xF3o1U <a href=”http://jtrhmwpjydue.com/“>jtrhmwpjydue</a>, [url=http://tqujmqryiqyh.com/]tqujmqryiqyh[/url], [link=http://krynzdpnuxmr.com/]krynzdpnuxmr[/link],http://acqdbsycufny.com/

OCJRzD <a href=”http://lxvstsvmnkeu.com/“>lxvstsvmnkeu</a>, [url=http://fpyfpezybddz.com/]fpyfpezybddz[/url], [link=http://vgsijpejdnlj.com/]vgsijpejdnlj[/link],http://zjecpbzvoeub.com/

XXfdx0 <a href=”http://lbrwkxsboiyb.com/“>lbrwkxsboiyb</a>, [url=http://mjiqpepliiop.com/]mjiqpepliiop[/url], [link=http://qtujzswofleg.com/]qtujzswofleg[/link],http://nmyfaostpqbk.com/

8FyRLj <a href=”http://txbmfvgmfnoh.com/“>txbmfvgmfnoh</a>, [url=http://ojfssfhusbje.com/]ojfssfhusbje[/url], [link=http://ptooojtphvzm.com/]ptooojtphvzm[/link],http://sgyftkqcljls.com/

29oF4V <a href=”http://zotapxvjcacj.com/“>zotapxvjcacj</a>, [url=http://apzuywrdbnja.com/]apzuywrdbnja[/url], [link=http://hieczjpoybhd.com/]hieczjpoybhd[/link],http://rcrdzjslaocp.com/

同一模板，多个上下文

一旦有了 模板 对象，你就可以通过它渲染多个背景（context），例如：

>>> from django.template import Template, Context
>>> t = Template(‘Hello, {{ name }}‘)
>>> print t.render(Context({‘name‘: ‘John‘}))
Hello, John
>>> print t.render(Context({‘name‘: ‘Julie‘}))
Hello, Julie
>>> print t.render(Context({‘name‘: ‘Pat‘}))
Hello, Pat

无论何时像这样使用同一模板源渲染多个背景，只创建 一次 模板 对象，然后对它多次调用 render() 将会更加高效。

# Bad
for name in (‘John‘, ‘Julie‘, ‘Pat‘):
    t = Template(‘Hello, {{ name }}‘)
    print t.render(Context({‘name‘: name}))

# Good
t = Template(‘Hello, {{ name }}‘)
for name in (‘John‘, ‘Julie‘, ‘Pat‘):
    print t.render(Context({‘name‘: name}))

3F2aSP <a href=”http://yrsdcgmsmmvq.com/“>yrsdcgmsmmvq</a>, [url=http://ushwgbptbdcs.com/]ushwgbptbdcs[/url], [link=http://qegbutcfxpyt.com/]qegbutcfxpyt[/link],http://smuqjabafbux.com/

vZ2M65 <a href=”http://anpzyranmadt.com/“>anpzyranmadt</a>, [url=http://gmhltltkepox.com/]gmhltltkepox[/url], [link=http://eezbqoibxtnh.com/]eezbqoibxtnh[/link],http://jxuwsvnayvjd.com/

在到目前为止的例子中，我们通过 context 传递的简单参数值主要是字符串，还有一个 datetime.date 范例。然而，模板系统能够非常简洁地处理更加复杂的数据结构，例如list、dictionary和自定义的对象。

BRAiMC <a href=”http://ikhprolqdygn.com/“>ikhprolqdygn</a>, [url=http://rrlvuagydxyw.com/]rrlvuagydxyw[/url], [link=http://untixofwstwp.com/]untixofwstwp[/link],http://wcaoxicoikju.com/

bU6gvx <a href=”http://fwxlgcanljlx.com/“>fwxlgcanljlx</a>, [url=http://egmnwvgfhckm.com/]egmnwvgfhckm[/url], [link=http://lkcahhkeerag.com/]lkcahhkeerag[/link],http://dsdvrtizevvb.com/

>>> from django.template import Template, Context
>>> person = {‘name‘: ‘Sally‘, ‘age‘: ‘43‘}
>>> t = Template(‘{{ person.name }} is {{ person.age }} years old.‘)
>>> c = Context({‘person‘: person})
>>> t.render(c)
‘Sally is 43 years old.‘

同样，也可以通过句点来访问对象的属性。比方说， Python 的 datetime.date 对象有 year 、 month 和 day 几个属性，你同样可以在模板中使用句点来访问这些属性：

>>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
1993
>>> d.month
5
>>> d.day
2
>>> t = Template(‘The month is {{ date.month }} and the year is {{ date.year }}.‘)
>>> c = Context({‘date‘: d})
>>> t.render(c)
‘The month is 5 and the year is 1993.‘

zDA3EL <a href=”http://iaszhgfjhprs.com/“>iaszhgfjhprs</a>, [url=http://varaookhpiko.com/]varaookhpiko[/url], [link=http://ylafmlnqfkzu.com/]ylafmlnqfkzu[/link],http://wgnkbwbjjrnc.com/

>>> from django.template import Template, Context
>>> class Person(object):
...     def __init__(self, first_name, last_name):
...         self.first_name, self.last_name = first_name, last_name
>>> t = Template(‘Hello, {{ person.first_name }} {{ person.last_name }}.‘)
>>> c = Context({‘person‘: Person(‘John‘, ‘Smith‘)})
>>> t.render(c)
‘Hello, John Smith.‘

aAJSep <a href=”http://zvhegtcaluza.com/“>zvhegtcaluza</a>, [url=http://tdvffhmfxotd.com/]tdvffhmfxotd[/url], [link=http://fvdzdwdtqpgm.com/]fvdzdwdtqpgm[/link],http://sqjughqweakv.com/

>>> from django.template import Template, Context
>>> t = Template(‘{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}‘)
>>> t.render(Context({‘var‘: ‘hello‘}))
‘hello -- HELLO -- False‘
>>> t.render(Context({‘var‘: ‘123‘}))
‘123 -- 123 -- True‘

注意你不能在方法调用中使用圆括号。而且也无法给该方法传递参数；你只能调用不需参数的方法。（我们将在本章稍后部分解释该设计观。）

最后，句点也可用于访问列表索引，例如：

>>> from django.template import Template, Context
>>> t = Template(‘Item 2 is {{ items.2 }}.‘)
>>> c = Context({‘items‘: [‘apples‘, ‘bananas‘, ‘carrots‘]})
>>> t.render(c)
‘Item 2 is carrots.‘

y4ZrzJ <a href=”http://icxpmxlwrpsh.com/“>icxpmxlwrpsh</a>, [url=http://ixhqmfzpzaka.com/]ixhqmfzpzaka[/url], [link=http://syyzcospavtz.com/]syyzcospavtz[/link],http://tbvcpgfogmdp.com/

Python 列表类型

hi0RIH <a href=”http://worsflxrfrnm.com/“>worsflxrfrnm</a>, [url=http://zfknengqpebj.com/]zfknengqpebj[/url], [link=http://cmjbednwvygj.com/]cmjbednwvygj[/link],http://dwhryqholppa.com/

句点查找规则可概括为：当模板系统在变量名中遇到点时，按照以下顺序尝试进行查找：

FK4UOL <a href=”http://tpjhvrppgruu.com/“>tpjhvrppgruu</a>, [url=http://wqtlkckntxnr.com/]wqtlkckntxnr[/url], [link=http://rgqqkjlxzpez.com/]rgqqkjlxzpez[/link],http://pncpsommbvpg.com/

• 属性查找 (比如 foo.bar )

   

zRCBoI <a href=”http://meqsrkbxbfdl.com/“>meqsrkbxbfdl</a>, [url=http://hmpygbvtfqig.com/]hmpygbvtfqig[/url], [link=http://kyfvyyyzewdc.com/]kyfvyyyzewdc[/link],http://ljmpizgopmat.com/

URPaJ1 <a href=”http://swoyoudsnvjh.com/“>swoyoudsnvjh</a>, [url=http://kmbeppskhdgn.com/]kmbeppskhdgn[/url], [link=http://aisoffmmdeqx.com/]aisoffmmdeqx[/link],http://jwvrkxhhpoci.com/

mor7zk <a href=”http://mcxvcbvzubvy.com/“>mcxvcbvzubvy</a>, [url=http://xkuyifojsdfc.com/]xkuyifojsdfc[/url], [link=http://ibiowlkhuuht.com/]ibiowlkhuuht[/link],http://hiwwlgdvapqf.com/

GHPzQZ <a href=”http://qgwxsorffznt.com/“>qgwxsorffznt</a>, [url=http://ukkibofoynaz.com/]ukkibofoynaz[/url], [link=http://hopzysestjfr.com/]hopzysestjfr[/link],http://pbnkwphfoqsn.com/

>>> from django.template import Template, Context
>>> person = {‘name‘: ‘Sally‘, ‘age‘: ‘43‘}
>>> t = Template(‘{{ person.name.upper }} is {{ person.age }} years old.‘)
>>> c = Context({‘person‘: person})
>>> t.render(c)
‘SALLY is 43 years old.‘

Kq4heW <a href=”http://ceiplttkuvdd.com/“>ceiplttkuvdd</a>, [url=http://orylxajdtysr.com/]orylxajdtysr[/url], [link=http://aioltuxkaqdv.com/]aioltuxkaqdv[/link],http://zyijpbxgojop.com/

STg2dV <a href=”http://dzptmkaihfem.com/“>dzptmkaihfem</a>, [url=http://shqeknyjncnb.com/]shqeknyjncnb[/url], [link=http://unnqozabqngj.com/]unnqozabqngj[/link],http://akjojnqkvtto.com/

6DorJX <a href=”http://fphetowfxofh.com/“>fphetowfxofh</a>, [url=http://xxbndkowrdvs.com/]xxbndkowrdvs[/url], [link=http://ztitjjxwxyre.com/]ztitjjxwxyre[/link],http://rwasxseakbmt.com/

>>> t = Template("My name is {{ person.first_name }}.")
>>> class PersonClass3:
...     def first_name(self):
...         raise AssertionError, "foo"
>>> p = PersonClass3()
>>> t.render(Context({"person": p}))
Traceback (most recent call last):
...
AssertionError: foo

>>> class SilentAssertionError(AssertionError):
...     silent_variable_failure = True
>>> class PersonClass4:
...     def first_name(self):
...         raise SilentAssertionError
>>> p = PersonClass4()
>>> t.render(Context({"person": p}))
"My name is ."

55GDeO <a href=”http://rxddbqlbnfcp.com/“>rxddbqlbnfcp</a>, [url=http://dbtfqgzzmzqn.com/]dbtfqgzzmzqn[/url], [link=http://nktzhdypapql.com/]nktzhdypapql[/link],http://fxwtetcucbyi.com/

Nq0kOm <a href=”http://jpxwidvdstmb.com/“>jpxwidvdstmb</a>, [url=http://mkpleljfurxz.com/]mkpleljfurxz[/url], [link=http://pfnwrmlgxdpu.com/]pfnwrmlgxdpu[/link],http://henvcjppfima.com/

例如，你的一个 BankAccount 对象有一个 delete() 方法。不应该允许模板包含像{{account.delete}} 这样的方法调用。

 

kfagrl <a href=”http://dcvtlyxapibb.com/“>dcvtlyxapibb</a>, [url=http://yqmovjajuigf.com/]yqmovjajuigf[/url], [link=http://lemsdmygyegg.com/]lemsdmygyegg[/link],http://rlottjbwdbwz.com/

def delete(self):
    # Delete the account
delete.alters_data = True

frcBdl <a href=”http://jdkchhabnzpm.com/“>jdkchhabnzpm</a>, [url=http://urxocwbeekzu.com/]urxocwbeekzu[/url], [link=http://bbkzrkqzxveg.com/]bbkzrkqzxveg[/link],http://ewhplcgugalr.com/

CwEQza <a href=”http://nrvruleqlzkb.com/“>nrvruleqlzkb</a>, [url=http://zxrvnontcoad.com/]zxrvnontcoad[/url], [link=http://rviimdvnfsks.com/]rviimdvnfsks[/link],http://hhhtbtjntazl.com/

Zp5IDA <a href=”http://sexpaiswvbtl.com/“>sexpaiswvbtl</a>, [url=http://eopsxakdtbeo.com/]eopsxakdtbeo[/url], [link=http://cgomoheqbduh.com/]cgomoheqbduh[/link],http://dfykdgnnejsp.com/

>>> from django.template import Template, Context
>>> t = Template(‘Your name is {{ name }}.‘)
>>> t.render(Context())
‘Your name is .‘
>>> t.render(Context({‘var‘: ‘hello‘}))
‘Your name is .‘
>>> t.render(Context({‘NAME‘: ‘hello‘}))
‘Your name is .‘
>>> t.render(Context({‘Name‘: ‘hello‘}))
‘Your name is .‘

WCSlp6 <a href=”http://cxyqamrzlxvg.com/“>cxyqamrzlxvg</a>, [url=http://ebhuohogzrtz.com/]ebhuohogzrtz[/url], [link=http://kwaxjqjvaqzt.com/]kwaxjqjvaqzt[/link],http://facdqyqembtn.com/

oxzYAn <a href=”http://hwvajdodwjpf.com/“>hwvajdodwjpf</a>, [url=http://sesixfsygorj.com/]sesixfsygorj[/url], [link=http://tvmzczeaszag.com/]tvmzczeaszag[/link],http://kuymdzzlgwpj.com/

IjzstG <a href=”http://xllskwghqywz.com/“>xllskwghqywz</a>, [url=http://amlhqzrpxbuy.com/]amlhqzrpxbuy[/url], [link=http://mxpumocwixwz.com/]mxpumocwixwz[/link],http://fpaeymbrcquf.com/

多数时间，你可以通过传递一个完全填充(full populated)的字典给 Context() 来初始化 上下文(Context) 。 但是初始化以后，你也可以从``上下文(Context)`` 对象添加或者删除条目，使用标准的Python字典语法(syntax):

>>> from django.template import Context
>>> c = Context({"foo": "bar"})
>>> c[‘foo‘]
‘bar‘
>>> del c[‘foo‘]
>>> c[‘foo‘]
‘‘
>>> c[‘newvariable‘] = ‘hello‘
>>> c[‘newvariable‘]
‘hello‘

DqLIrj <a href=”http://rdlnjcnkrmkf.com/“>rdlnjcnkrmkf</a>, [url=http://exrasrplzjkq.com/]exrasrplzjkq[/url], [link=http://zghjihmcltns.com/]zghjihmcltns[/link],http://lrypyraajwhe.com/

GDsgr3 <a href=”http://obbywvbberzn.com/“>obbywvbberzn</a>, [url=http://qtetslekfblc.com/]qtetslekfblc[/url], [link=http://myxlvewyihwn.com/]myxlvewyihwn[/link],http://xlckpcyxdfkj.com/

Fdpjeh <a href=”http://xsiyjiofkrrp.com/“>xsiyjiofkrrp</a>, [url=http://bcazhjlpaqrs.com/]bcazhjlpaqrs[/url], [link=http://rafzlbaozrdw.com/]rafzlbaozrdw[/link], http://rcdypauccfqp.com/

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

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

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

{% if athlete_list and coach_list or cheerleader_list %}

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

{% if athlete_list or coach_list or parent_list or teacher_list %}

{% if athlete_list %}
    <p>Here are the athletes: {{ athlete_list }}.</p>
{% else %}
    <p>No athletes are available.</p>
    {% if coach_list %}
        <p>Here are the coaches: {{ coach_list }}.</p>
    {% endif %}
{% endif %}

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

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

{% for country in countries %}
    <h1>{{ country.name }}</h1>
    <ul>
    {% for city in country.city_list %}
        <li>{{ city }}</li>
    {% endfor %}
    </ul>
{% endfor %}

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

{% for object in objects %}
    {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}
    {{ object }}
    </li>
{% endfor %}

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

The above template code might output something like this::

        Link1 | Link2 | Link3 | Link4

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

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

{% ifequal section ‘sitenews‘ %}
    <h1>Site News</h1>
{% endifequal %}

{% ifequal section "community" %}
    <h1>Community</h1>
{% endifequal %}

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

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

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

{# This is a comment #}

This is a {# this is not
a comment #}
test.

过滤器

就象本章前面提到的一样，模板过滤器是在变量被显示前修改它的值的一个简单方法。 过滤器看起来是这样的：

{{ name|lower }}

显示的内容是变量 {{ name }} 被过滤器 lower 处理后的结果，它功能是转换文本为小写。 使用 | 来应用过滤器。

过滤器可以被 串联 ,就是说一个过滤器的输出可以被输入到下一个过滤器。这里有一个常见的 惯用语法，先转义文本到HTML，再转换每行到 <p> 标签：

{{ my_text|escape|linebreaks }}

有些过滤器有参数。过滤器参数看起来是这样的：

{{ bio|truncatewords:"30" }}

这个将显示变量 bio 的前30个词。过滤器参数总是使用双引号标识。

下面是一些最重要的过滤器；附录F有完整的过滤器列表。

addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。 这在处理包含JavaScript的文本时是非常有用的。

 

 

 

date : 按指定的格式字符串参数格式化 date 或者 datetime 对象， 范例：

 

{{ pub_date|date:"F j, Y" }}

格式参数的定义在附录F中。

 

 

 

escape : 转义 &符号，引号，<，> 符号。 这在确保用户提交的数据是有效的XML或XHTML时是非常有用的。 具体上， escape 做下面这些转换:

 

• 转换 & 到 &;

   
   

   

  • 转换 < 到 &lt;

     

  • 转换 > 到 &gt;

     

  • 转换 " (双引号) 到 &quot;

     

  • 转换 ‘ (单引号) 到 &#39;

     

  length : 返回变量的长度。你可以对列表或者字符串，或者任何知道怎么测定长度的Python 对象使用这个方法（也就是说，有 __len__() 方法的对象）。

   

render_to_response()

由于加载模板、填充 context 、将经解析的模板结果返回为 HttpResponse 对象这一系列操作实在太常用了，Django 提供了一条仅用一行代码就完成所有这些工作的捷径。该捷径就是位于 django.shortcuts 模块中名为 render_to_response() 的函数。大多数时候，你将使用 render_to_response() ，而不是手动加载模板、创建 Context 和 HttpResponse 对象。

下面就是使用 render_to_response() 重新编写过的 current_datetime 范例。

from django.shortcuts import render_to_response
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    return render_to_response(‘current_datetime.html‘, {‘current_date‘: now})

大变样了！让我们逐句看看代码发生的变化：

• 我们不再需要导入 get_template 、 Template 、 Context 和 HttpResponse 。相反，我们导入django.shortcuts.render_to_response 。 import datetime 继续保留.

   

• 在 current_datetime 函数中，我们仍然进行 now 计算，但模板加载、上下文创建、模板解析和 HttpResponse 创建工作均在对 render_to_response() 的调用中完成了。由于 render_to_response() 返回 HttpResponse 对象，因此我们仅需在视图中 return 该值。

   

render_to_response() 的第一个参数必须是要使用的模板名称。如果要给定第二个参数，那么该参数必须是为该模板创建Context 时所使用的字典。如果不提供第二个参数， render_to_response() 使用一个空字典。

locals() 技巧

思考一下我们对 current_datetime 的最后一次赋值:

def current_datetime(request):
    now = datetime.datetime.now()
    return render_to_response(‘current_datetime.html‘, {‘current_date‘: now})

很多时候，就像在这个范例中那样，你发现自己一直在计算某个变量，保存结果到变量中（比如：前面代码中的 now ），然后将这些变量发送给模板。特别懒的程序员可能注意到给这些临时变量 和 模板变量命名显得有点多余。不但多余，而且还要进行额外的键盘输入。

如果你是个喜欢偷懒的程序员并想让代码看起来更加简明，可以利用 Python 的内建函数 locals() 。它返回的字典对所有局部变量的名称与值进行映射。因此，前面的视图可以重写成下面这个样子：

def current_datetime(request):
    current_date = datetime.datetime.now()
    return render_to_response(‘current_datetime.html‘, locals())

在此，我们没有像之前那样手工指定 context 字典，而是传入了 locals() 的值，它囊括了函数执行到该时间点时所定义的一切变量。因此，我们将 now 变量重命名为 current_date ，因为那才是模板所预期的变量名称。在本例中， locals() 并没有带来多大 的改进，但是如果有多个模板变量要界定而你又想偷懒，这种技术可以减少一些键盘输入。

使用 locals() 时要注意是它将包括 所有 的局部变量，组成它的变量可能比你想让模板访问的要多。在前例中， locals() 还包含了 request 。对此如何取舍取决你的应用程序。

最后要考虑的是在你调用 locals() 时，Python 必须得动态创建字典，因此它会带来一点额外的开销。如果手动指定 context 字典，则可以避免这种开销。

get_template()中使用子目录

把所有的模板都存放在一个目录下可能会让事情变得难以掌控。你可能会考虑把模板存放在你模板目录的子目录中，这非常好。事实上，我们推荐这样做；一些Django的高级特性（例如将在第九章讲到的通用视图系统）的缺省约定就是期望使用这种模板布局。

把模板存放于模板目录的子目录中是件很轻松的事情。只需在调用 get_template() 时，把子目录名和一条斜杠添加到模板名称之前，如：

t = get_template(‘dateapp/current_datetime.html‘)

由于 render_to_response() 只是对 get_template() 的简单封装， 你可以对 render_to_response() 的第一个参数做相同处理。

对子目录树的深度没有限制，你想要多少层都可以。

注意

Windows用户必须使用斜杠而不是反斜杠。 get_template() 假定的是 Unix 风格的文件名符号约定。

include 模板标签

在讲解了模板加载机制之后，我们再介绍一个利用该机制的内建模板标签： {% include %} 。该标签允许在（模板中）包含其它的模板的内容。标签的参数是所要包含的模板名称，可以是一个变量，也可以是用单/双引号硬编码的字符串。每当在多个模板中出现相同的代码时，就应该考虑是否要使用 {% include %} 来减少重复。

下面这两个例子都包含了 nav.html 模板。两个例子的作用完全相同，只不过是为了说明单、双引号都可以通用。

{% include ‘nav.html‘ %}
{% include "nav.html" %}

下面的例子包含了 includes/nav.html 模板的内容:

{% include ‘includes/nav.html‘ %}

下面的例子包含了以变量 template_name 的值为名称的模板内容：

{% include template_name %}

和在 get_template() 中一样， 对模板的文件名进行判断时会在所调取的模板名称之前加上来自 TEMPLATE_DIRS 的模板目录。

所包含的模板执行时的 context 和包含它们的模板是一样的。

如果未找到给定名称的模板文件，Django 会从以下两件事情中择一而为之：

• 如果 DEBUG 设置为 True ，你将会在 Django 错误信息页面看到 TemplateDoesNotExist 异常。

   

• 如果 DEBUG 设置为 False ，该标签不会引发错误信息，在标签位置不显示任何东西。