6. Django 模板

最新推荐文章于 2024-08-13 22:31:13 发布

mannixiang

最新推荐文章于 2024-08-13 22:31:13 发布

阅读量123

点赞数

分类专栏： Django基础文章标签： django

本文链接：https://blog.csdn.net/mannixiang/article/details/115495846

版权

Django基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Django 模板

版权声明：本博客来自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。
欢迎访问路飞学城官网：https://www.luffycity.com/

本节重点

模板之变量
模板之过滤器
模板之标签
自定义标签和过滤器
静态文件配置
模板继承

引子

你可能已经注意到我们在上一节例子视图中返回文本的方式有点特别。也就是说，HTML被直接硬编码在 Python代码之中。

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

尽管这种技术便于解释视图是如何工作的，但直接将HTML硬编码到你的视图里却并不是一个好主意。让我们来看一下为什么：

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

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

python的模板：HTML代码＋模板语法

def current_time(req):
    # ================================原始的视图函数
    # import datetime
    # now=datetime.datetime.now()
    # html="<html><body>现在时刻：<h1>%s.</h1></body></html>" %now


    # ================================django模板修改的视图函数
    # from django.template import Template,Context
    # now=datetime.datetime.now()
    # t=Template('<html><body>现在时刻是:<h1>{{current_date}}</h1></body></html>')
    # #t=get_template('current_datetime.html')
    # c=Context({'current_date':str(now)})
    # html=t.render(c)
    #
    # return HttpResponse(html)


    #另一种写法(推荐)
    import datetime
    now=datetime.datetime.now()
    return render(req, 'current_datetime.html', {'current_date':str(now)[:19]})

1. 模板之变量

变量语法：

view：｛"HTML变量名" : "views变量名"｝
HTML：｛｛变量名｝｝

当模版引擎遇到一个变量，它将计算这个变量，然后用结果替换掉它本身。变量的命名包括任何字母数字以及下划线 ("_")的组合。变量名称中不能有空格或标点符号。

在 Django 模板中遍历复杂数据结构的关键是句点字符（.），句点字符（.）在模板语言中有特殊的含义。当模版系统遇到点(".")，它将以这样的顺序查询：

字典查询（Dictionary lookup）
属性或方法查询（Attribute or method lookup）
数字索引查询（Numeric index lookup）

注意事项：

如果计算结果的值是可调用的，它将被无参数的调用。调用的结果将成为模版的值。
如果使用的变量不存在，模版系统将插入 string_if_invalid 选项的值，它被默认设置为’’ (空字符串) 。
句点符也可以用来引用对象的方法(无参数方法):
```
<h4>字典:{{ dic.name.upper }}</h4>
```

实例：

views.py:

def index(request):
    import datetime
    s="hello"
    l=[111,222,333]    # 列表
    dic={"name":"yuan","age":18}  # 字典
    date = datetime.date(1993, 5, 2)   # 日期对象
 
    class Person(object):
        def __init__(self,name):
            self.name=name
 
    person_yuan=Person("yuan")  # 自定义类对象
    person_egon=Person("egon")
    person_alex=Person("alex")
 
    person_list=[person_yuan,person_egon,person_alex] 
 
    return render(request,"index.html",{"s":s,"l":l,"dic":dic,"date":date,"person_list":person_list})

template：

<h4>{{s}}</h4>
<h4>列表:{{ l.0 }}</h4>
<h4>列表:{{ l.2 }}</h4>
<h4>字典:{{ dic.name }}</h4>
<h4>日期:{{ date.year }}</h4>
<h4>类对象列表:{{ person_list.0.name }}</h4>

2. 模板之过滤器

在Django的模板语言中，通过使用过滤器来改变变量的显示。

过滤器语法:

{{ 变量名 | 过滤器：可选参数 }}

使用管道符"|"来应用过滤器。

例如：{{ name|lower }}会将name变量应用lower过滤器之后再显示它的值。lower在这里的作用是将文本全都变成小写。

注意事项：

过滤器支持“链式”操作。即一个过滤器的输出作为另一个过滤器的输入。
过滤器可以接受参数，例如：{{ sss|truncatewords:30 }}，这将显示sss的前30个词。
过滤器参数包含空格的话，必须用引号包裹起来。比如使用逗号和空格去连接一个列表中的元素，如：{{ list|join:’, ’ }}。
'|'左右没有空格没有空格没有空格。

Django的模板语言中提供了大约六十个内置过滤器。

2.1 default

如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。

以下值为 false：

0  0.0  False  0j  ""  []  ()  set()  {}  None

实例：

# 如果value没有传值或者值为空的话就显示nothing
{{ value|default:"nothing"}}

2.2 length

返回值的长度，作用于字符串和列表。

字典返回的是键值对的数量，集合返回的是去重后的长度。

实例：

 {{ value|length }}

返回value的长度，如 value=[‘a’, ‘b’, ‘c’, ‘d’]的话，就显示4。

2.3 filesizeformat

以更易读的方式显示文件的大小（即’13 KB’, ‘4.1 MB’, '102 bytes’等）。字典返回的是键值对的数量，集合返回的是去重后的长度。

实例：

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

2.4 slice

切片

实例：

{{value|slice:"2:-1"}}

2.5 date

根据给定格式对一个日期变量进行格式化。

格式 Y-m-d H:i:s返回 年-月-日小时:分钟:秒 的格式时间。

实例：

{{ value|date:"Y-m-d H:i:s"}}

2.6 truncatechars

如果字符串包含的字符总个数多于指定的字符数量，那么会被截断掉后面的部分。

截断的字符串将以 … 结尾。

实例：

{{ value|truncatewords:9}}

2.7 safe

将字符串标记为安全，不需要转义。

要保证 views.py 传过来的数据绝对安全，才能用 safe。

和后端 views.py 的 mark_safe 效果相同。

Django 会自动对 views.py 传到HTML文件中的标签语法进行转义，令其语义失效。加 safe 过滤器是告诉 Django 该数据是安全的，不必对其进行转义，可以让该数据语义生效。

实例：

# views.py:

from django.shortcuts import render

def runoob(request):
    views_str = "<a href='https://www.runoob.com/'>点击跳转</a>"
    return render(request, "runoob.html", {"views_str": views_str})

# runoob.html 文件代码：
{{ views_str|safe }}

2.8 cut

移除value中所有的与给出的变量相同的字符串

实例：

{{ value|cut:' ' }}

如果value为’i love you’，那么将输出’iloveyou’。

2.9 join

使用字符串连接列表，例如Python的str.join(list)

2.10 timesince

将日期格式设为自该日期起的时间（例如，“4天，6小时”）。

采用一个可选参数，它是一个包含用作比较点的日期的变量（不带参数，比较点为现在）。

例如，如果blog_date是表示2006年6月1日午夜的日期实例，并且comment_date是2006年6月1日08:00的日期实例，则以下将返回“8小时”：

{{ blog_date|timesince:comment_date }}

分钟是所使用的最小单位，对于相对于比较点的未来的任何日期，将返回“0分钟”。

2.11 timeuntil

似于timesince，除了它测量从现在开始直到给定日期或日期时间的时间。例如，如果今天是2006年6月1日，而conference_date是保留2006年6月29日的日期实例，则{{ conference_date | timeuntil }}将返回“4周”。

使用可选参数，它是一个包含用作比较点的日期（而不是现在）的变量。如果from_date包含2006年6月22日，则以下内容将返回“1周”：

{{ conference_date|timeuntil:from_date }}

3. 模板之标签

标签看起来像是这样的： {% tag %}。

标签比变量更加复杂：一些在输出中创建文本，一些通过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。

一些标签需要开始和结束标签，例如{% tag %} ...标签内容 ... {% endtag %}。

3.1 if/else

基本语法格式如下：

{% if condition %}
     ... display
{% endif %}

或者：

{% if condition1 %}
   ... display 1
{% elif condition2 %}
   ... display 2
{% else %}
   ... display 3
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

实例：

views.py:

from django.shortcuts import render

def runoob(request):
    views_num = 88
    return render(request, "runoob.html", {"num": views_num})

runoob.html ：

{%if num > 90 and num <= 100 %}
优秀
{% elif num > 60 and num <= 90 %}
合格
{% else %}
一边玩去～
{% endif %}
                             
# 合格

3.2 for

{% for %}允许我们在一个序列上迭代。

与 Python 的 for 语句的情形类似，循环语法是 for X in Y ，Y 是要迭代的序列而 X 是在每一个特定的循环中使用的变量名称。

每一次循环中，模板系统会渲染在 {% for %} 和 {% endfor %} 之间的所有内容。

例如，给定一个运动员列表 athlete_list 变量，我们可以使用下面的代码来显示这个列表：

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

可以利用{% for obj in list reversed %}反向完成循环。

遍历一个字典：可以直接用字典 .items 方法，用变量的解包分别获取键和值。

{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

注：在{% for %}标签里可以通过{{forloop}}变量获取循环序号：

forloop.counter: 顺序获取循环序号，从 1 开始计算
forloop.counter0: 顺序获取循环序号，从 0 开始计算
forloop.revcounter: 倒叙获取循环序号，结尾序号为 1
forloop.revcounter0: 倒叙获取循环序号，结尾序号为 0
forloop.first（一般配合if标签使用）: 第一条数据返回 True，其他数据返回 False
forloop.last（一般配合if标签使用）: 最后一条数据返回 True，其他数据返回 False

可选的 {% empty %}从句：在循环为空的时候执行（即 in 后面的参数布尔值为 False ）。

{% for i in listvar %}
    {{ forloop.counter0 }}
{% empty %}
    空空如也～
{% endfor %}

可以嵌套使用{% for %}标签：

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

3.3 ifequal/ifnotequal

{% ifequal %} 标签比较两个值，当他们相等时，显示在{% ifequal %} 和{% endifequal %}之中所有的值。

下面的例子比较两个模板变量 user 和 currentuser :

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

和{% if %}类似，{% ifequal %}支持可选的{% else%}标签：

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

3.4 with

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的。

实例：

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

或：

{% with business.employees.count as total %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

3.5 csrf_token

csrf_token 用于form表单中，作用是跨站请求伪造保护。

用法：在页面的form表单里面写上{% csrf_token %}。

如果不用｛% csrf_token %｝标签，在用 form 表单时，要再次跳转页面会报403权限错误。

用了｛% csrf_token %｝标签，在 form 表单提交数据时，才会成功。

解析：

首先，向服务器发送请求，获取登录页面，此时中间件 csrf 会自动生成一个隐藏input标签，该标签里的 value 属性的值是一个随机的字符串，用户获取到登录页面的同时也获取到了这个隐藏的input标签。

然后，等用户需要用到form表单提交数据的时候，会携带这个 input 标签一起提交给中间件 csrf，原因是 form 表单提交数据时，会包括所有的 input 标签，中间件 csrf 接收到数据时，会判断，这个随机字符串是不是第一次它发给用户的那个，如果是，则数据提交成功，如果不是，则返回403权限错误。

3.6 注释

Django 注释使用{# #}。

{# 这是一个注释 #}

3.7 include

{% include %}标签允许在模板中包含其它的模板的内容。

下面这个例子都包含了 nav.html 模板：

{% include "nav.html" %}

3.8 注意事项

Django的模板语言不支持连续判断，即不支持以下写法：

{% if a > b > c %}
...
{% endif %}

Django的模板语言中属性的优先级大于方法：

def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})

如上，我们在使用render方法渲染一个页面的时候，传的字典d有一个key是items并且还有默认的d.items()方法，此时在模板语言中:

{{ data.items }}

默认会取d的items key的值。

4. 自定义标签和过滤器

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

在应用目录下创建 templatetags 目录(与 templates 目录同级，目录名只能是 templatetags)。

HelloWorld/
|-- HelloWorld
|   |-- __init__.py
|   |-- __init__.pyc
|   |-- settings.py
...
|-- manage.py
`-- templatetags
`-- templates

在 templatetags 目录下创建任意 py 文件，如：my_tags.py。

my_tags.py 文件代码如下：

from django import template

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

修改 settings.py 文件的 TEMPLATES 选项配置，添加 libraries 配置：

# settings.py 配置文件
...
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR, "/templates",],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            "libraries":{                          # 添加这边三行配置
                'my_tags':'templatetags.my_tags'   # 添加这边三行配置        
            }                                      # 添加这边三行配置
        },
    },
]
...

利用装饰器 @register.filter 自定义过滤器。

注意： 装饰器的参数最多只能有 2 个。
```
@register.filter
def my_filter(v1, v2):
    return v1 * v2
```

利用装饰器 @register.simple_tag 自定义标签。

@register.simple_tag
def my_tag1(v1, v2, v3):
    return v1 * v2 * v3

在使用自定义标签和过滤器前，要在 html 文件 body 的最上方中导入该 py 文件。
```
{% load my_tags %}
```
在 HTML 中使用自定义过滤器。
```
{{ 11|my_filter:22 }}
```
在 HTML 中使用自定义标签。
```
{% my_tag1 11 22 33 %}
```
语义化标签

在该 py 文件中导入 mark_safe。
```
from django.utils.safestring import mark_safe
```
定义标签时，用上mark_safe 方法，令标签语义化，相当于 jQuery 中的 html() 方法。

和前端HTML文件中的过滤器 safe 效果一样。
```
@register.simple_tag
def my_html(v1, v2):
    temp_html = "<input type='text' id='%s' class='%s' />" %(v1, v2)
    return mark_safe(temp_html)
```
在HTML中使用该自定义标签，在页面中动态创建标签。
```
{% my_html "zzz" "xxx" %}
```

注意：filter可以用在if等语句后，simple_tag不可以

5. 静态文件配置

在项目根目录下创建 statics 目录。

在 settings 文件的最下方配置添加以下配置：

#  settings 文件
STATIC_URL = '/static/' # 别名 
STATICFILES_DIRS = [ 
    os.path.join(BASE_DIR, "statics"), 
]

在 statics 目录下创建 css 目录，js 目录，images 目录，plugins 目录，分别放 css文件，js文件，图片，插件。
把 bootstrap 框架放入插件目录 plugins。
在 HTML 文件的 head 标签中引入 bootstrap。

注意： 此时引用路径中的要用配置文件中的别名 static，而不是目录 statics。

<link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7/dist/css/bootstrap.css">

在模板中使用需要加入 {% load static %}代码，以下实例我们从静态目录中引入图片。

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

引用JS文件时使用：

{% load static %}
<script src="{% static "mytest.js" %}"></script>

某个文件多处被用到可以存为一个变量：

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

6. 模板继承 (extend)

模板可以用继承的方式来实现复用，减少冗余内容。

网页的头部和尾部内容一般都是一致的，我们就可以通过模板继承来实现复用。

父模板用于放置可重复利用的内容，子模板继承父模板的内容，并放置自己的内容。

6.1 父模板

标签 block...endblock: 父模板中的预留区域，该区域留给子模板填充差异性的内容，不同预留区域名字不能相同。

{% block 名称 %} 
预留给子模板的区域，可以设置设置默认内容
{% endblock 名称 %}

6.2 子模板

子模板使用标签 extends 继承父模板：

{% extends "父模板路径"%}

子模板如果没有设置父模板预留区域的内容，则使用在父模板设置的默认内容，当然也可以都不设置，就为空。

子模板设置父模板预留区域的内容：

{ % block 名称 % }
内容 
{% endblock 名称 %}

实例：

# base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}My amazing site{%/span> 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>

这个模版，我们把它叫作 base.html，它定义了一个可以用于两列排版页面的简单HTML骨架。“子模版”的工作是用它们的内容填充空的blocks。

在这个例子中， block 标签定义了三个可以被子模版内容填充的block。 block 告诉模版引擎：子模版可能会覆盖掉模版中的这些位置。

子模版可能看起来是这样的：

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

extends 标签是这里的关键。它告诉模版引擎，这个模版“继承”了另一个模版。当模版系统处理这个模版时，首先，它将定位父模版——在此例中，就是“base.html”。

那时，模版引擎将注意到 base.html 中的三个 block 标签，并用子模版中的内容来替换这些block。根据 blog_entries 的值，输出可能看起来是这样的：

<!DOCTYPE html>
<html 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>

请注意，子模版并没有定义 sidebar block，所以系统使用了父模版中的值。父模版的 {% block %} 标签中的内容总是被用作备选内容（fallback）。

这种方式使代码得到最大程度的复用，并且使得添加内容到共享的内容区域更加简单，例如，部分范围内的导航。

这里是使用继承的一些提示：

如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其他的任何情况下，模版继承都将无法工作。
在base模版中设置越多的 {% block %} 标签越好。请记住，子模版不必定义全部父模版中的blocks，所以，你可以在大多数blocks中填充合理的默认内容，然后，只定义你需要的那一个。多一点钩子总比少一点好。
如果你发现你自己在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。
If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.
为了更好的可读性，你也可以给你的 {% endblock %} 标签一个名字。例如：
```
{% block content %}
...
{% endblock content %}　
```
在大型模版中，这个方法帮你清楚的看到哪一个　 {% block %} 标签被关闭了。
不能在一个模版中定义多个相同名字的 block 标签。

mannixiang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
6. Django 模板

Django 模板版权声明：本博客来自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。欢迎访问路飞学城官网：https://www.luffycity.com/本节重点模板之变量模板之过滤器模板之标签自定义标签和过滤器静态文件配置模板继承引子你可能已经注意到我们在上一节例子视图中返回文本的方式有点特别。也就是说，HTML被直接硬编码在 Python代码之中。def current_datetime(request): now = datetime
复制链接

扫一扫

专栏目录