Django 模板 template

组成：HTML代码＋逻辑控制代码

逻辑控制代码的组成

1、变量　　{{  var_name }}

深度变量的查找:万能的句点号

#最好是用几个例子来说明一下。
# 首先，句点可用于访问列表索引，例如：

>>> 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.'

#假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值，可使用一个句点：
>>> 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
>>> d.month
>>> d.day
>>> 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.'

# 这个例子使用了一个自定义的类，演示了通过实例变量加一点(dots)来访问它的属性，这个方法适
# 用于任意的对象。
>>> 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.'

# 点语法也可以用来引用对象的方法。 例如，每个 Python 字符串都有 upper() 和 isdigit()
# 方法，你在模板中可以使用同样的句点语法来调用它们：
>>> 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'

# 注意这里调用方法时并没有使用圆括号 而且也无法给该方法传递参数；你只能调用不需参数的方法。

变量的过滤器  {{obj|filter:param}}

(1)add

        使用形式为：{{ value | add: "2"}}
        意义：将value的值增加2

• 1
• 2
• 3

(2)addslashes

        使用形式为：{{ value | addslashes }}
        意义：在value中的引号前增加反斜线

• 1
• 2
• 3

(3)capfirst

        使用形式为：{{ value | capfirst }}
        意义：value的第一个字符转化成大写形式

• 1
• 2
• 3

(4)cut

         使用形式为：{{ value | cut:arg}}， 例如，如果value是“String with spaces” arg是" "那么输出是"Stringwithspaces"
         意义：从给定value中删除所有arg的值

• 1
• 2
• 3

(5)date

         使用形式为：：
             (a) {{ value | date:"D d M Y" }}，例如，如果value是一个datetime对象(datetime.datetime.now())那么输出将是字符串"Wed 09 Jan 2008"
             (b) {{ value | date }}，这种形式没有格式化字符串，这时候，格式化字符串会自动采用DATE_FORMAT所设置的形式。
         意义：将日期格式数据按照给定的格式输出

• 1
• 2
• 3
• 4
• 5

(6)default

         使用形式：{{ value | default: "nothing" }}，例如，如果value是“”，那么输出将是nothing
         意义：如果value的意义是False，那么输出使用缺省值

• 1
• 2
• 3

(7)default_if_none

         使用形式：{{ value | default_if_none:"nothing" }}，例如，如果value是None，那么输出将是nothing
         意义：如果value是None，那么输出将使用缺省值

• 1
• 2
• 3

(8)dictsort

         意义：如果value的值是一个字典，那么返回值是按照关键字排序的结果
         使用形式：{{ value | dictsort:"name"}}，例如，
         如果value是：

• 1
• 2
• 3
• 4

[ 
{‘name’: ‘zed’, ‘age’: 19}, 
{‘name’: ‘amy’, ‘age’: 22}, 
{‘name’: ‘joe’, ‘age’: 31}, 
] 
那么，输出是： 
[ 
{‘name’: ‘amy’, ‘age’: 22}, 
{‘name’: ‘joe’, ‘age’: 31}, 
{‘name’: ‘zed’, ‘age’: 19}, 
]

(9)dictsortreversed

意义：如果value的值是一个字典，那么返回值是按照关键字排序的结果的反序 
使用形式：与上述(8)完全相同。

(10)divisibleby

使用形式：{{ value | divisibleby:arg}}，如果value是21，arg是3，那么输出将是True 
意义：如果value能够被arg整除，那么返回值将是True

(11)escape

使用形式：{{ value | escape}} 
意义：替换value中的某些字符，以适应HTML格式，包括： 
< is converted to < 
> is converted to > 
’ (single quote) is converted to ' 
” (double quote) is converted to " 
& is converted to &

escape仅仅在输出的时候才起作用，所以escape不能够用在链式过滤器的中间， 
他应该总是最后一个过滤器，如果想在链式过滤器的中间使用，那么可以使用force_escape

(12)escapejs

使用形式：{{ value | escapejs }} 
意义：替换value中的某些字符，以适应JAVASCRIPT和JSON格式。

(13)filesizeformat

使用形式：{{ value | filesizeformat }} 
意义：格式化value，使其成为易读的文件大小，例如：13KB，4.1MB等。

(14)first

使用形式：{{ value | first }} 
意义：返回列表中的第一个Item，例如，如果value是列表[‘a’,’b’,’c’]，那么输出将是’a’。

(15)floatformat

使用形式：{{ value | floatformat}}或者{{value|floatformat:arg}}， 
arg可以是正数也可以是负数。没有参数的floatformat相当于floatformat:-1 
(1)如果不带arg，那么引擎会四舍五入，同时最多只保留一位小数。

34.23234 {{ value|floatformat }} 34.2 
34.00000 {{ value|floatformat }} 34 
34.26000 {{ value|floatformat }} 34.3

(2)如果arg是正数，那么引擎会四舍五入，同时保留arg位的小数。

34.23234 {{ value|floatformat:3 }} 34.232 
34.00000 {{ value|floatformat:3 }} 34.000 
34.26000 {{ value|floatformat:3 }} 34.260

(3)如果arg是负数，那么引擎会四舍五入，如果有小数部分，那么保留arg位小数；否则，则没有任何小数部分。

34.23234 {{ value|floatformat:”-3” }} 34.232 
34.00000 {{ value|floatformat:”-3” }} 34 
34.26000 {{ value|floatformat:”-3” }} 34.26

(16)get_digit

使用形式：{{ value | get_digit:”arg”}}，例如，如果value是123456789，arg是2，那么输出是8 
意义：给定一个数字，返回，请求的数字，记住：1代表最右边的数字，如果value不是合法输入， 
那么会返回所有原有值。

(17)iriencode

使用形式：{{value | iriencode}} 
意义：如果value中有非ASCII字符，那么将其进行抓化成URL中适合的编码，如果value已经进行过URLENCODE， 
改操作就不会再起作用。

(18)join

使用形式：{{ value | join:”arg”}}，如果value是[‘a’,’b’,’c’]，arg是’//’那么输出是a//b//c 
意义：使用指定的字符串连接一个list，作用如同python的str.join(list)

(19)last

使用形式：{{ value | last }} 
意义：返回列表中的最后一个Item

(20)length

使用形式：{{ value | length }} 
意义：返回value的长度。

(21)length_is

使用形式：{{ value | length_is:”arg”}} 
意义：返回True，如果value的长度等于arg的时候，例如：如果value是[‘a’,’b’,’c’]，arg是3，那么返回True

(22)linebreaks

使用形式：{{value|linebreaks}} 
意义：value中的” ”将被<br/>替代，并且整个value使用</p>包围起来，从而适和HTML的格式

(23)linebreaksbr

使用形式：{{value |linebreaksbr}} 
意义：value中的” ”将被<br/>替代

(24)linenumbers

使用形式：{{value | linenumbers}} 
意义：显示的文本，带有行数。

(25)ljust

使用形式：{{value | ljust}} 
意义：在一个给定宽度的字段中，左对齐显示value

(26)center

使用形式：{{value | center}} 
意义：在一个给定宽度的字段中，中心对齐显示value

(27)rjust

使用形式：{{value | rjust}} 
意义：在一个给定宽度的字段中，右对齐显示value

(28)lower

使用形式：{{value | lower}} 
意义：将一个字符串转换成小写形式

(29)make_list

使用形式：{{value | make_list}} 
意义：将value转换成一个list，对于字符串，转换成字符list；对于整数，转换成整数list 
例如value是Joel，那么输出将是[u’J’,u’o’,u’e’,u’l’]；value是123，那么输出将是[1,2,3]

(30)pluralize

使用形式：{{value | pluralize}}，或者{{value | pluralize:”es”}}，或者{{value | pluralize:”y,ies”}} 
意义：如果value不是1，则返回一个复数后缀，缺省的后缀是’s’

(31)random

使用形式：{{value | random}} 
意义：从给定的list中返回一个任意的Item

(32)removetags

使用形式：{{value | removetags:”tag1 tag2 tag3…”}} 
意义：删除value中tag1,tag2….的标签。例如，如果value是<b>Joel</b> <button>is</button> a <span>slug</span> 
tags是”b span”，那么输出将是：Joel <button>is</button> a slug

(33)safe

使用形式：{{value | safe}} 
意义：当系统设置autoescaping打开的时候，该过滤器使得输出不进行escape转换

(34)safeseq

与上述safe基本相同，但有一点不同的就是：safe是针对字符串，而safeseq是针对多个字符串组成的sequence

(35)slice

使用形式：{{some_list | slice:”:2”}} 
意义：与python语法中的slice相同，:2表示第一的第二个元素

(36)slugify

使用形式：{{value | slugify}} 
意义：将value转换成小写形式，同事删除所有分单词字符，并将空格变成横线 
例如：如果value是Joel is a slug，那么输出将是joel-is-a-slug

(37)stringformat

这个不经常用，先不说 
{{ value|stringformat:”E” }} 
If value is 10, the output will be 1.000000E+01.

(38)striptags

使用形式：{{value | striptags}} 
意义：删除value中的所有HTML标签

(39)time

使用形式：{{value | time:”H:i”}}或者{{value | time}} 
意义：格式化时间输出，如果time后面没有格式化参数，那么输出按照TIME_FORMAT中设置的进行。

(40)title

转换一个字符串成为title格式。

(41)truncatewords

使用形式：{{value | truncatewords:2}} 
意义：将value切成truncatewords指定的单词数目 
例如，如果value是Joel is a slug 那么输出将是：Joel is …

(42)truncatewords_html

使用形式同(41) 
意义：truncation点之前如果某个标签打开了，但是没有关闭，那么在truncation点会立即关闭。 
因为这个操作的效率比truncatewords低，所有只有在value是html格式时，才考虑使用。

(43)upper

转换一个字符串为大写形式

(44)urlencode

将一个字符串进行URLEncode

(45)urlize

意义：将一个字符串中的URL转化成可点击的形式。 
使用形式：{{ value | urlize }} 
例如，如果value是Check out www.djangoproject.com，那么输出将是： 
Check out <a href=”http://www.djangoproject.com”>www.djangoproject.com</a>

(46)urlizetrunc

使用形式：{{ value | urlizetrunc:15}} 
意义：与(45)相同，但是有一点不同就是现实的链接字符会被truncate成特定的长度，后面以…现实。

(47)wordcount

返回字符串中单词的数目

(48)wordwrap

使用形式：{{value | wordwrap:5}} 
意义：按照指定的长度包装字符串 
例如，如果value是Joel is a slug，那么输出将会是： 
Joel 
is a 
slug

(49)timesince

使用形式：{{value | 
since:arg}} 
意义：返回参数arg到value的天数和小时数 
例如，如果 blog_date 是一个日期实例表示 2006-06-01 午夜， 而 comment_date 是一个日期实例表示 2006-06-01 早上8点， 
那么 {{ comment_date|timesince:blog_date }} 将返回 “8 hours”.

(50)timeuntil

使用形式：{{value | timeuntil}} 
意义：与(50)基本相同，一个不同点就是，返回的是value距离当前日期的天数和小时数。

#实例:

#value1="aBcDe"
{{ value1|upper }}<br>　　ABCDE

#value2=5
{{ value2|add:3 }}<br>　　8

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}<br>　　helloworld

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}<br>　　2018-05-11

#value5=[]
{{ value5|default:'空的' }}<br>　　空的 # 如果前面的值为空，则显示default中的内容

#value6='<a href="#">跳转</a>'

{{ value6 }}　　# 前端显示<a href='#'>跳转</a> 这是一种安全机制

{% autoescape off %}　　 # 范围取消安全机制
  {{ value6 }}　　　　　　# 这会显示正常的a标签
{% endautoescape %}

{{ value6|safe }}<br>　　# 与上面的方法一样，不是范围而已

{{ value6|striptags }}　　跳转　# 取消所有html标签

#value7='1234'
{{ value7|first }}<br>　　1　　# 取第一个
{{ value7|length }}<br>　　4　　# 取长度
{{ value7|slice:":-1" }}<br>　　4321　# 切片　

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}<br>

# value = 'CPTTTTTTTTTTTT'

{{ value|truncatechars:3 }}   # 那么输出的时候，会输出'CPT'

2、标签　　{%  tag %}

(1)    {%if 条件%}

　　　　执行的代码

　　 {%elif 条件%}

　　　　执行的代码

　　 {%else%}

　　　　执行的代码

　　 {%endif%}

(2)  {%for 变量 in 对象%}　　　　{%for 变量 in 对象 reversed%} : 同样，{% for %}模板标签也可使用reversed反向迭代列表

       　　循环的代码

　　{%empty%}

　　　　为空时的代码

　　{%endfor%}

　　#系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量，

#这个变量含有一些属性可以提供给你一些关于循环的信息　

　　1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1: {% for item in todo_list %} <p>{{ forloop.counter }}: {{ item }}</p> {% endfor %} 　　2，forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0 　　3，forloop.revcounter　　将forloo9p的值倒过来 　　4，forloop.revcounter0 类似于forloop.reccouter，最后一次循环设为0 　　5，forloop.first当第一次循环时值为True，在特别情况下很有用： {% for object in objects %} {% if forloop.first %}<li class="first">{% else %}<li>{% endif %} {{ object }} </li> {% endfor %} 　　# 富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了 　　# 如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它 　　# Django会在for标签的块中覆盖你定义的forloop变量的值 　　# 在其他非循环的地方，你的forloop变量仍然可用

(3) {%csrf_token%} (post提交时生效)

 

用于生成csrf_token的标签，用于防治跨站攻击验证。注意如果你在view的index里用的是render_to_response方法，不会生效

     其实，这里是会生成一个input标签，和其他表单标签一起提交给后台的。

 

（4）{% url %}:  引用路由配置的地址别名（参考urls.py）

（5）{% with %}:用更简单的变量名替代复杂的变量名

with total=fhjsaldfhjsdfhlasdfhljsdal %} {{ total }} {% endwith %}  # 使用total变量名代替fhjsaldfhjsdfhlasdfhljsdal变量名

（6）{% verbatim %}: 禁止render

{% verbatim %}

         {{ hello }}　　　　# 页面直接显示{{ hello }}

{% endverbatim %}

 (7) {% load %}: 加载标签库 

{% load staticfiles %} 加载静态文件
{% load xxx %} 加载自定义的filter
自定义filter和tag
1、在app中创建名称为templatetags的包(必须的)
2、在里面创建任意 .py 文件，如：my_tags.py
3、写my_tags.pyfrom django import template

from django.utils.safestring import mark_safe

register = template.Library()   #register的名字是固定的,不可改变


@register.filter　　# 自定义的filter
def filter_multi(v1,v2):
    return  v1 * v2　　　　　　


@register.simple_tag　　# 自定义的tag
def simple_tag_multi(v1,v2):
    return  v1 * v2


@register.simple_tag　　# 自定义的tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

4、在模板中调用自己写的filter

{% load my_tags%}

 # num=12

{{ num|filter_multi:2 }} #24

{{ num|filter_multi:"[22,333,4444]" }}


{% simple_tag_multi 2 5 %}  参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}

# filter可以用在if等语句后，simple_tag不可以

注意：在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.

3、 {% include %} 

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

{% include 'test.html' %}

4、模板的继承

第一步是定义 基础模板,该框架之后将由子模板所继承。 以下是我们目前所讲述范例的基础模板：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<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>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<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 框架文档，我们将在本站点的所有页面中使用。 子模板的作用就是重载、添加或保留那些块的内容。 （如果你一直按顺序学习到这里，保存这个文件到你的template目录下，命名为 base.html .）

我们使用模板标签： {% block %} 。 所有的 {% block %} 标签告诉模板引擎，子模板可以重载这些部分。 每个{% block %}标签所要做的是告诉模板引擎，该模板下的这一块内容将有可能被子模板覆盖。

现在我们已经有了一个基本模板，我们可以修改 current_datetime.html 模板来 使用它：

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

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

再为 hours_ahead 视图创建一个模板，看起来是这样的：

{% extends "base.html" %}
 
{% block title %}Future time{% endblock %}
 
{% block content %}
<p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
{% endblock %}

{% extends "base.html" %}
 
{% block title %}Future time{% endblock %}
 
{% block content %}
<p>In {{ hour_offset }} hour(s), it will be {{ next_time }}.</p>
{% endblock %}

看起来很漂亮是不是？ 每个模板只包含对自己而言 独一无二 的代码。 无需多余的部分。 如果想进行站点级的设计修改，仅需修改 base.html ，所有其它模板会立即反映出所作修改。

<1>如果在模板中使用 {% extends %} ，必须保证其为模板中的第一个模板标记。 否则，模板继承将不起作用。

<2>一般来说，基础模板中的 {% block %} 标签越多越好。 记住，子模板不必定义父模板中所有的代码块，因此 你可以用合理的缺省值对一些代码块进行填充，然后只对子模板所需的代码块进行（重）定义。 俗话说，钩子越 多越好。

<3>如果发觉自己在多个模板之间拷贝代码，你应该考虑将该代码段放置到父模板的某个 {% block %} 中。 如果你需要访问父模板中的块的内容，使用 {{ block.super }}这个标签吧，这一个魔法变量将会表现出父模 板中的内容。 如果只想在上级代码块基础上添加内容，而不是全部重载，该变量就显得非常有用了。

<4>不允许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是因为block 标签的工作方式是双向的。 也就是说，block 标签不仅挖了一个要填的坑，也定义了在父模板中这个坑所填充的内容。如果模板中出现了两个 相同名称的 {% block %} 标签，父模板将无从得知要使用哪个块的内容。