Django基础之template

1. 模板系统的介绍

def current_datetime(request):

    now = datetime.datetime.now()

    html = "<html><body>It is now %s.</body></html>" % now

    return HttpResponse(html)

在这个例子视图中返回文本的方式有点特别，HTML直硬编码在Python代码之中。

尽管这种技术便于解释视图是如何工作的，但直接将HTML硬编码到你的视图里却不是一个好方法。原因如下：

对页面设计进行的任何改变都必须对Python代码进行相应的修改。站点设计的修改往往比底层Python代码的修改要频繁得多，因此，如果可以在不进行Python代码修改的情况下变更设计，那将会方便的多。
Python代码编写和HTML设计是两项不同的工作。大多数专业的网站开发环境都将它们分配给不同的人员（甚至不同的部门）来完成。设计者和HTML/CSS的编码人员不应该被要求去编辑Python的代码来完成他们的工作。
程序编写Python代码和设计人员制作模板两项工作同时进行的效率是最高的，远胜于让一个人等待另一个人完成对某个既包含Python又包含HTML的文件的编辑工作。

基于这些原因，将页面的设计和Python代码分离开来，会更干净简洁容易维护。我们可以使用Django的模板系统(Template System)来实现这种模式。

Pyhton的模板：HTML代码 + 逻辑控制代码。

2. 模板支持的语法

2.1 变量（使用双打括号来引用变量）

语法格式如下：
>{{ var_name }}

======================Template和Context对象=========================

>>>python manange.py shell      #进入该django项目的环境

>>>from django.template import Context, Template

>>>t = Template("My name is {{name}}.")

>>>c = Context({"name": "Stephane"})

>>>t.render(c)

执行结果为：

"My name is Stephane."

同一模板，多个上下文，一旦有了模板对象，就可以通过它渲染多个context，无论何时我们都可以像这样使用同一模板渲染多个context。

只进行一次模板创建，然后多次调用render()方法渲染会更为搞笑。

不好的代码：

>>>for name in ("John", "Julie", "Pat")：

>>>    t = Template("Hello {{ name }}")

>>>    print(t.rander(Context({"name": name}>>>)))

>>>

好的代码是这样写的：

>>>t = Template("Hello, {{ name }}")

>>>for name in ("John", "Julie", "Pat")：

>>>    print(t.rander(Context({"name": name})))

Django模板解析非常快捷。大部分的解析工作都是在后台通过对简短正则表达式一次性调用来完成。这和基于XML的模板引擎形成鲜明对比，那些引擎承担了XML解析器的开销，且往往比Django模板渲染引擎要慢上几个数量级。

from django.shortcuts import render,HttpResponse

from django.template.loader import get_template #记得导入

# Create your views here.

import datetime

from django.template import Template,Context

# def current_time(req):

    #原始的视图函数

    # now=datetime.datetime.now()

    # html="<html><body>现在时刻：<h1>%s.</h1></body></html>" %now

    # return HttpResponse(html)

# def current_time(req):

      #django模板修改的视图函数

#     now=datetime.datetime.now()

#     t=Template('<html><body>现在时刻是:<h1 style="color:red">{{current_date}}</h1></body></html>')

      #t=get_template('current_datetime.html')

#     c=Context({'current_date':now})

#     html=t.render(c)

#     return HttpResponse(html)

#另一种写法(推荐)

def current_time(req):

    now=datetime.datetime.now()

    return render(req, 'current_datetime.html', {'current_date':now})

2.2 深度变量的查找(万能的句点号)

在到目前为止的例子中，我们通过context传递的简单参数值主要是字符串，然而模板系统能够非常简洁地处理更加复杂的数据结构，例如list, dictionary和自定义的对象。在Django模板中遍历复杂数据结构的关键是句点字符(.)。

2.2.1 句点可用于访问列表索引

```Python
from django.template import Template, Context
t = Template("Item 2 is {{ item.2}}")
c = Context({"items": ["apples", "bananas", "carrots"]})
t.render(c)
```
执行结果为：
```Python
Item 2 is carrots.
```

2.2.2 向模板传递一个Python字典，通过字典键访问该字典的值

```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)
```
执行结果为：
```Python
Sally is 43 years old.
```

2.2.3 通过句点来访问对象的属性

比如说，Python中的datetime.date对象有year，month和day几个属性，那么可以在模板中使用句点来访问这些属性。
```Python
>>>from django.template import Template, Context
>>>import datetime
>>>d = datetime.date(1993, 5, 2)
>>>t = Template("the month is {{ date.monte}} and the year is {{ date.year }}.")
>>>c = Context("date": d)
>>>t.render(c)
```
执行结果为：
```Python
>>>The month is 5 and the year is 1993.
```

2.2.4 编写自定义的类，通过实例化加点来访问它的属性

这个方法适用于任意的对象
```Python
>>>from django.template import Template, Context
>>>class Person(object):
>>> def __init__(self, first_name, last_name):
>>> self.first_name = first_name
>>> self.last_name = last_name
>>>t = Template("Hello, {{ person.first_name }} {{ person.last_name }}.")
>>>c = Context({"person": Person("yang", "wei")})
>>>t.render(c)
```
执行结果为：
```Python
>>>Hello, yang wei.
```

2.2.5 引用对象的方法

例如，每个Python字符串都有upper()和isdigit()方法，那么在模板中可以使用同样的句点语法来调用它们：
```Python
>>>from django.template import Template, Context
>>>t = Template("{{ var }}--{{ var.upper}}--{{var.isdigig}}")
>>>t.render(Context({"var": "hello"}))
>>>t.render(Context({"var": "123"}))
```
执行结果为：
```Python
>>>hello -- HELLO -- False
>>>123 -- 123 -- True
```
这里有一点要注意的是，模板语法和python语法在调用方法时是不一样的。

模板语法在调用方法时，并没有使用圆括号，而且也没有办法给该方法传递参数。

所以，在模板语法中只能调用不需要参数的方法。

2.3 变量的过滤器(filter)的使用

>语法格式： {{ obj|filter:param }}

语法有：

(1)add　　　　　　:　　给变量加上相应的值

(2)addslasher　　 :　　给变量中的引号前加上斜线

(3)capfirst　　　　:　　首字母大写

(4)cut　　　　　　:　　从字符串中移除指定的字符

(5)date　　　　　 :　　格式化日期字符串

(6)default　　　　 :　　如果值是False，就替换成设置的默认值，否则就是用本来的值

(7)default_if_none :　　如果值是None，就替换成设置的默认值，否则就使用本来的值

(7)truncatewords:5　　保留5个单词长度，其余为...

(8)truncatechars:5　　保留5个字符长度，其余为...

2.3.1 upper

#value1 = "aBcDe"

{{ value1|upper }}

执行结果为：

ABCDE

2.3.2 add

```Python
#value2 = 5
{{ value2|add:3}}
```
执行结果为：
```Python
8
```

2.3.3 cut

```Python
#value3 = "he llo wo r ld"
value3|cut: " "
```
执行结果为：
```Python
helloworld
```

2.3.4 date

```Python
#import datetime
#value4 = datetime.detetime.now()
{{ value4|date:"Y-m-d"}}
```
执行结果为：
```Python
2018-09-10
```

2.3.5 default

```Python
#value5=[]
{{ value5|default:"nothing"}}
```
执行结果为：
```Python
nothing
```

2.3.6 自动转义

```Python
#value6='跳转'
{{ value6 }}
```
执行结果为：
```Python
跳转
```

2.3.7 去掉自动转义

去掉自动转义有两种方法：

一种方法是：
```Python
#value6='跳转'
{% autoescape off %}
{{ value6 }}
{% endautoescape %}
```
另一种方法是：
```Python
#value6='跳转'
{{value6|safe}}
```

2.3.8 striptags

striptags作用：去掉value中的所有html值
```Python
#value6='跳转'
{{ value|striptags }}
```
执行结果为：
```Python
跳转
```

2.3.9 filesizeformat

filesizeformat作用：转化为kb格式
```Python
#value7='1234'
value7|filesizeformat：{{ value7|filesizeformat }}
```
执行结果为：
```Python
value7|filesizeformat:1.2KB
```

2.3.10 first

first作用：获取第一个字符
```Python
#value7='1234'
value7|first:{{ value7|first }}
```
执行结果为：
```Python
value7|first:1
```

2.3.11 length

length: 长度
```Python
#value7='1234'
value7|length:{{ value7|length }}
```
执行结果为：
```Python
value7|length:4
```

2.3.12 slice

slice：切片
```Python
#value7='1234'
{{ value7|slice:":-1" }}
```
执行结果为：
```Python
value7|slice:":-1"123
```