Django-06-模板(Template)

悠悠 2021-10-24 03:16 276阅读 0赞

# 一、模板组成 #

***HTML代码+逻辑控制代码***

# 二、逻辑控制代码 #

## 1. 变量 ##

语法格式：       {
         {var_name}}

**Template和Context对象**

D:\python\Project\django_test>python manage.py shell
    Python 3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 23:09:28) [MSC v.1916 64 bit (AMD64)]
    Type 'copyright', 'credits' or 'license' for more information
    IPython 7.3.0 -- An enhanced Interactive Python. Type '?' for help.
    
    In [1]: from django.template import Template, Context
    In [2]: t = Template('my name is {
         { name}}')
    In [3]: c = Context({'name':'Tom'})
    In [4]: t.render(c)
    Out[4]: 'my name is Tom'

# 同一模板，多个上下文，一旦有了模板对象，你就可以通过它渲染多个context，无论何时我们都可以
    # 像这样使用同一模板源渲染多个context，只进行 一次模板创建然后多次调用render()方法渲染会
    # 更为高效：
    # Low
    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}))

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})

**深度变量的查找（万能的句点号）**

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

在 Django 模板中遍历复杂数据结构的关键是句点字符 (.)。

#最好是用几个例子来说明一下。
    # 首先，句点可用于访问列表索引，例如：
    
    >>> 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'
    
    # 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数；你只能调用不需参数的方法。

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

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

# 1  add          ：   给变量加上相应的值
       #
       # 2  addslashes   :    给变量中的引号前加上斜线
       #
       # 3  capfirst     :    首字母大写
       #
       # 4  cut          ：   从字符串中移除指定的字符
       #
       # 5  date         ：   格式化日期字符串
       #
       # 6  default      ：   如果值是False,就替换成设置的默认值，否则就是用本来的值
       #
       # 7  default_if_none:  如果值是None，就替换成设置的默认值，否则就使用本来的值
    
    
    #实例:
    
    #value1="aBcDe"
    {
         { value1|upper }}<br>
    
    #value2=5
    {
         { value2|add:3 }}<br>
    
    #value3='he  llo wo r ld'
    {
         { value3|cut:' ' }}<br>
    
    #import datetime
    #value4=datetime.datetime.now()
    {
         { value4|date:'Y-m-d' }}<br>
    
    #value5=[]
    {
         { value5|default:'空的' }}<br>
    
    #value6='<a href="#">跳转</a>'
    
    {
         { value6 }}
    
    {% autoescape off %}
      {
         { value6 }}
    {% endautoescape %}
    
    {
         { value6|safe }}<br>
    
    {
         { value6|striptags }}
    
    #value7='1234'
    {
         { value7|filesizeformat }}<br>
    {
         { value7|first }}<br>
    {
         { value7|length }}<br>
    {
         { value7|slice:":-1" }}<br>
    
    #value8='http://www.baidu.com/?a=1&b=3'
    {
         { value8|urlencode }}<br>
        value9='hello I am yuan'

## 2. 标签(Tag) ##

语法：	{% tags %}

**\{% if %\}**

\{% if %\}标签计算一个变量值，如果是“true”，即它存在、不为空并且不是false的boolean值,系统则会显示\{% if %\}和\{% endif %\}间的所有内容

{% if num >= 100 and 8 %}
        {% if num > 200 %}
            <p>num大于200</p>
        {% else %}
            <p>num大于100小于200</p>
        {% endif %}
    {% elif num < 100%}
        <p>num小于100</p>
    {% else %}
        <p>num等于100</p>
    {% endif %}
    
    
    {% if %} 标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
    {% if %} 标签不允许同一标签里同时出现and和or，否则逻辑容易产生歧义，例如下面的标签是不合法的：
    
    # {% if obj1 and obj2 or obj3 %}

**\{% for %\}**

\{% for %\}标签允许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染\{% for %\}和\{% endfor %\}之间的所有内容

<ul>
    {% for obj in list %}
        <li>{
         { obj.name }}</li>
    {% endfor %}
    </ul>
    
    #在标签里添加reversed来反序循环列表：
        {% for obj in list reversed %}
        ...
        {% endfor %}
    
    #{% for %}标签可以嵌套：
        {% for country in countries %}
            <h1>{
         { country.name }}</h1>
            <ul>
             {% for city in country.city_list %}
                <li>{
         { city }}</li>
             {% endfor %}
            </ul>
        {% 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
    4，forloop.revcounter0
    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变量仍然可用
    
    
    #{% empty %}
    {
         {li }}
          {%  for i in li %}
              <li>{
         { forloop.counter0 }}----{
         { i }}</li>
          {% empty %}
              <li>this is empty!</li>
          {% endfor %}
    
    #         [11, 22, 33, 44, 55]
    #            0----11
    #            1----22
    #            2----33
    #            3----44
    #            4----55

**\{%csrf\_token%\}**

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

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

**\{% url %\}**

引用路由配置的地址

<form action="{% url "bieming"%}" >
              <input type="text">
              <input type="submit"value="提交">
              {%csrf_token%}
    </form>

**\{% with %\}**

用更简单的变量名替代复杂的变量名

{% with total=fhjsaldfhjsdfhlasdfhljsdal %} {
         { total }} {% endwith %}

**\{% verbatim %\}**

禁止render

{% verbatim %}
             {
         { hello }}
    {% endverbatim %}

**\{% load %\}**

加载标签库

{% load staticfiles %}

# 三、自定义filter和simple\_tag #

## 1. 创建 ##

*  在app中创建templatetags包
 *  在包中创建任意py文件
 *  编写代码

from django import template
    from django.utils.safestring import mark_safe
    
    register = template.Library()   #register的名字是固定的,不可改变
    
    @register.filter
    def filter_multi(v1,v2):
        return  v1 * v2
    
    @register.simple_tag
    def simple_tag_multi(v1,v2):
        return  v1 * v2
    
    @register.simple_tag
    def my_input(id,arg):
        result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
        return mark_safe(result)

## 2. 使用 ##

*  在使用自定义simple\_tag和filter的html文件中导入之前创建的 **my\_tags.py ：\{% load my\_tags %\}（必须在首行导入）**
 *  使用filter和simple\_tag

-------------------------------.html
    {% load xxx %}   #首行
        
        
     # 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不可以

{% if num|filter_multi:30 > 100 %}
        {
         { num|filter_multi:30 }}
    {% endif %}

# 四、模板继承 #

## 1. include 模板标签 ##

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

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        {% load staticfiles %}
        <title>Title</title>
    </head>
    <body>
        <h1>hello {
         { name}} 时间 {
         { t }}</h1>
    {#    <script src="/static/jquery-3.4.1.js"></script>#}
        <script src="{% static 'jquery-3.4.1.js' %}"></script>
        <script>
            $("h1").css("color", "red")
        </script>
    </body>
    </html>
    {% include "test.html" %}
    
    # test.html
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <p>hello world</p>
    </body>
    </html>

![1720767-20190808114117073-2141565591.png][]

## 2. extend继承 ##

到目前为止，我们的模板范例都只是些零星的 HTML 片段，但在实际应用中，你将用 Django 模板系统来创建整个 HTML 页面。 这就带来一个常见的 Web 开发问题： 在整个网站中，如何减少共用页面区域（比如站点导航）所引起的重复和冗余代码？

解决该问题的传统做法是使用 *服务器端的 includes* ，你可以在 HTML 页面中使用该指令将一个网页嵌入到另一个中。 事实上， Django 通过刚才讲述的 \{% include %\} 支持了这种方法。 但是用 Django 解决此类问题的首选方法是使用更加优雅的策略—— *模板继承* 。

本质上来说，模板继承就是先构造一个基础框架模板，而后在其子模板中对它所包含站点公用部分和定义块进行重载。

让我们通过修改 current\_datetime.html 文件，为 current\_datetime 创建一个更加完整的模板来体会一下这种做法：