django模板层

模板简介

模板变量

模板过滤器

模板标签

自定义过滤器

模板导入

模板继承

静态文件

模板简介

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 深度查询 用句点符

　　　　2 过滤器

　　标签：｛｛%  % ｝｝

后端朝前端页面传递数据的方式：
　　# 第一种
　　　　return render(request,'index.html',{'n':n})
　　# 第二种
　　　　return render(request,'index.html',locals())
　　　　# 将当前所在的名称空间中的名字全部传递给前端页面

后端传函数名到前端，会自动加括号调用，但是不支持传参


后端传对象到前端，就相当于打印了这个对象


前端获取后端传过来的容器类型的内部元素 统一采用句点符(.)
('关某某','谢某某','陈某某','容嬷嬷')>>>:{{ t }},{{ t.1 }} 数字对应的就是数据的索引


前端能够调用python后端数据类型的一些不需要传参的内置方法
模板语法的注释

不会展示到前端页面:{#调用python自带的内置方法,可以调用不需要传参的一些内置方法#}
原生html的注释
会展示到前端:<!--我是原生的html注释-->

模板语法之变量

在 Django 模板中遍历复杂数据结构的关键是句点字符, 语法：｛｛变量名｝｝

views.py

def template_test(request):
    name = 'lqz'
    li = ['lqz', 1, '18']
    dic = {'name': 'lqz', 'age': 18}
    ll2 = [
        {'name': 'lqz', 'age': 18},
        {'name': 'lqz2', 'age': 19},
        {'name': 'egon', 'age': 20},
        {'name': 'kevin', 'age': 23}
    ]
    ll3=[]
    class Person:
        def __init__(self, name):
            self.name = name

        def test(self):
            print('test函数')
            return 11

        @classmethod
        def test_classmethod(cls):
            print('类方法')
            return '类方法'

        @staticmethod
        def static_method():
            print('静态方法')
            return '静态方法'

    lqz = Person('lqz')
    egon = Person('egon')
    person_list = [lqz, egon]
    bo = True
    te = test()
    import datetime
    now=datetime.datetime.now()
    link1='<a href="https://www.baidu.com">点我<a>'
    from django.utils import safestring
    link=safestring.mark_safe(link1)
    # html特殊符号对照表（http://tool.chinaz.com/Tools/htmlchar.aspx）

    # 这样传到前台不会变成特殊字符，因为django给处理了
    dot='&spades;'


    # return render(request, 'template_index.html', {'name':name,'person_list':person_list})
    return render(request, 'template_index.html', locals())
View Code

html

<p>{{ name }}</p>
            <p>{{ li }}</p>
            <p>{{ dic }}</p>
            <p>{{ lqz }}</p>
            <p>{{ person_list }}</p>
            <p>{{ bo }}</p>
            <p>{{ te }}</p>

            <hr>
            <h3>深度查询句点符</h3>
            <p>{{ li.1 }}</p>
            <p>{{ dic.name }}</p>
            <p>{{ lqz.test }}</p>
            <p>{{ lqz.name }}</p>
            <p>{{ person_list.0 }}</p>
            <p>{{ person_list.1.name }}</p>

            <hr>
            <h3>过滤器</h3>
            {#注意：冒号后面不能加空格#}
            <p>{{ now | date:"Y-m-d H:i:s" }}</p>

            {#如果变量为空，设置默认值,空数据，None，变量不存在，都适用#}
            <p>{{ name |default:'数据为空' }}</p>
            {#计算长度，只有一个参数#}
            <p>{{ person_list |length }}</p>
            {#计算文件大小#}
            <p>{{ 1024 |filesizeformat }}</p>

            {#字符串切片，前闭后开，前面取到，后面取不到#}
            <p>{{ 'hello world lqz' |slice:"2:-1" }}</p>
            <p>{{ 'hello world lqz' |slice:"2:5" }}</p>

            {#截断字符，至少三个起步，因为会有三个省略号（传负数，1，2，3都是三个省略号）#}
            <p>{{ '刘清政 world lqz' |truncatechars:"4" }}</p>
            {#截断文字，以空格做区分，这个不算省略号#}
            <p>{{ '刘清政   是      大帅比 谢谢' |truncatewords:"1" }}</p>

            <p>{{ link1 }}</p>
            <p>{{ link1|safe }}</p>
            <p>{{ link }}</p>

            <p>&spades;</p>
            <p>{{ dot }}</p>

            {#add   可以加负数，传数字字符串都可以#}
            <p>{{ "10"|add:"-2" }}</p>
            <p>{{ li.1|add:"-2" }}</p>
            <p>{{ li.1|add:2 }}</p>
            <p>{{ li.1|add:"2" }}</p>
            <p>{{ li.1|add:"-2e" }}</p>

            {#upper#}
            <p>{{ name|upper }}</p>
            <p>{{ 'LQZ'|lower }}</p>
            <hr>
            <h3>模版语法之标签</h3>
            {#for 循环 循环列表，循环字典，循环列表对象#}
            <ui>
                {% for foo in dic %}
                    {{ foo }}
                {% endfor %}
                {#也可以混用html标签#}
                {% for foo in li %}
                    <ul>foo</ul>

                {% endfor %}
            </ui>
            {#表格#}
            <table border="1">

                {% for foo in ll2 %}
                    <tr>
                        <td>{{ foo.name }}</td>
                        <td>{{ foo.age }}</td>
                    </tr>
                {% endfor %}
            </table>
            <table border="1">
                {#'parentloop': {}, 'counter0': 0, 'counter': 1, 'revcounter': 4, 'revcounter0': 3, 'first': True, 'last': False}#}
                {% for foo in ll2 %}
                    <tr>
                        <td>{{ forloop.counter }}</td>
                        <td>{{ foo.name }}</td>
                        <td>{{ foo.age }}</td>
                    </tr>
                {% endfor %}


            </table>



            {% for foo in ll5 %}
                <p>foo.name</p>
            {% empty %}
                <p>空的</p>
            {% endfor %}

            <hr>
            <h3>if判断</h3>
            {% if name %}
                <a href="">hi {{ name }}</a>
                <a href="">注销</a>
            {% else %}
                <a href="">请登录</a>
                <a href="">注册</a>
            {% endif %}
            {#还有elif#}
            <hr>
            <h3>with</h3>
            {% with ll2.0.name as n %}
                {{ n }}
            {% endwith %}
            {{ n }}


            {% load my_tag_filter %}

            {{ 3|multi_filter:3 }}

            {#传参必须用空格区分#}
            {% multi_tag 3 9 10 %}

            {#可以跟if连用#}
            {% if 3|multi_filter:3 > 9 %}
                <p>大于</p>
            {% else %}
                <p>小于</p>
            {% endif %}
View Code

注意：句点符也可以用来引用对象的方法(无参数方法):

<h4>字典:{{ dic.name.upper }}</h4>

模板之过滤器

语法：

{{obj|filter__name:param}}  变量名字|过滤器名称：变量

default

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

{{ value|default:"nothing" }}
前端获取数据如果是空就返回default后面默认的参数值

length

返回值的长度。它对字符串和列表都起作用。例如：

{{ value|length }
前端统计字符串的长度

如果 value 是 ['a', 'b', 'c', 'd']，那么输出是 4。

filesizeformat

将值格式化为一个 “人类可读的” 文件尺寸 （例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：

{{ value|filesizeformat }}
将数字格式化成表示文件大小的单位

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

date

如果 value=datetime.datetime.now()

{{ value|date:"Y-m-d" }}　
将时间格式化 2019-06-11

slice

如果 value="hello world"

{{ value|sliec:"0:8" }}
字符串的切片操作 hello wo

truncatechars(截取固定的长度的字符串）

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。

里面的‘9’ 的意思是总共取九位数，但是'...' 占了三位

{{ value|truncatechars:9 }}
截取固定的长度的字符串 三个点也算

truncatewords

里面的‘4‘ 意思是取到第四个空格

{{ value|truncatewords:4 }}
按照空格截取文本内容

safe

前后端取消转义(*****)

　　前端:

　　value|safe

　　后端: 　　　

　from django.utils.safestring import mark_safe
　xxx = mark_safe('<h1>我是h1标签</h1>')

其他过滤器

过滤器 描述 示例
upper 以大写方式输出 {{ user.name | upper }}
add 给value加上一个数值 {{ user.age | add:”5” }}
addslashes 单引号加上转义号  
capfirst 第一个字母大写 {{ ‘good’| capfirst }} 返回”Good”
center 输出指定长度的字符串，把变量居中 {{ “abcd”| center:”50” }}
cut 删除指定字符串 {{ “You are not a Englishman” | cut:”not” }}
date 格式化日期  
default 如果值不存在，则使用默认值代替 {{ value | default:”(N/A)” }}
default_if_none 如果值为None, 则使用默认值代替  
dictsort 按某字段排序，变量必须是一个dictionary {% for moment in moments | dictsort:”id” %}
dictsortreversed 按某字段倒序排序，变量必须是dictionary  
divisibleby 判断是否可以被数字整除 
{{ 224 | divisibleby:2 }}  返回 True
escape 按HTML转义，比如将”<”转换为”&lt”  
filesizeformat 增加数字的可读性，转换结果为13KB,89MB,3Bytes等 
{{ 1024 | filesizeformat }} 返回 1.0KB
first 返回列表的第1个元素，变量必须是一个列表  
floatformat 转换为指定精度的小数，默认保留1位小数 {{ 3.1415926 | floatformat:3 }} 返回 3.142  四舍五入
get_digit 从个位数开始截取指定位置的数字 {{ 123456 | get_digit:’1’}}
join 用指定分隔符连接列表 {{ [‘abc’,’45’] | join:’*’ }} 返回 abc*45
length 返回列表中元素的个数或字符串长度  
length_is 检查列表，字符串长度是否符合指定的值 {{ ‘hello’| length_is:’3’ }}
linebreaks 用<p>或<br>标签包裹变量 {{ “Hi\n\nDavid”|linebreaks }} 返回<p>Hi</p><p>David</p>
linebreaksbr 用<br/>标签代替换行符  
linenumbers 为变量中的每一行加上行号  
ljust 输出指定长度的字符串，变量左对齐 {{‘ab’|ljust:5}}返回 ‘ab   ’
lower 字符串变小写  
make_list 将字符串转换为列表  
pluralize 根据数字确定是否输出英文复数符号  
random 返回列表的随机一项  
removetags 删除字符串中指定的HTML标记 {{value | removetags: “h1 h2”}}
rjust 输出指定长度的字符串，变量右对齐  
slice 切片操作， 返回列表 {{[3,9,1] | slice:’:2’}} 返回 [3,9]
{{ 'asdikfjhihgie' | slice:':5' }} 返回 ‘asdik’
slugify 在字符串中留下减号和下划线，其它符号删除，空格用减号替换 
{{ '5-2=3and5 2=3' | slugify }} 返回 5-23and5-23
stringformat 字符串格式化，语法同python  
time 返回日期的时间部分  
timesince 以“到现在为止过了多长时间”显示时间变量 结果可能为 45days, 3 hours
timeuntil 以“从现在开始到时间变量”还有多长时间显示时间变量  
title 每个单词首字母大写  
truncatewords 将字符串转换为省略表达方式 
{{ 'This is a pen' | truncatewords:2 }}返回
This is ...
truncatewords_html 同上，但保留其中的HTML标签 
{{ '<p>This is a pen</p>' | truncatewords:2 }}返回
<p>This is ...</p>
urlencode 将字符串中的特殊字符转换为url兼容表达方式 {{ ‘http://www.aaa.com/foo?a=b&b=c’ | urlencode}}
urlize 将变量字符串中的url由纯文本变为链接  
wordcount 返回变量字符串中的单词数  
yesno 将布尔变量转换为字符串yes, no 或maybe 
{{ True | yesno }}
{{ False | yesno }}
{{ None | yesno }} 
返回 
yes
no 
maybe

 

模板之标签

for 标签

遍历每一个元素：

{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}

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

遍历一个字典：

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

注：循环序号可以通过｛｛forloop｝｝显示　　

VariableDescription
forloop.counter 当前循环的索引值（从1开始）
forloop.counter0 当前循环的索引值（从0开始）
forloop.revcounter 当前循环的倒序索引值（从1开始）
forloop.revcounter0 当前循环的倒序索引值（从0开始）
forloop.first 当前循环是不是第一次循环（布尔值）
forloop.last 当前循环是不是最后一次循环（布尔值）
forloop.parentloop 本层循环的外层循环

 

for ... empty

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。

当你的for循环对象为空的时候会自动走empty代码块儿的内容
后端:
　　l = None
前端:
　　{% for foo in l %}
　　　　　　{% if forloop.first %}
　　　　　　<p>这是我的第一次</p>
　　　　{% elif forloop.last %}
　　　　　　<p>这是最后一次了啊</p>
　　　　{% else %}
　　　　　　<p>嗨起来！！！</p>
　　　　{% endif %}
　　　　{% empty %}
　　　　　　<p>你给我的容器类型是个空啊，没法for循环</p>
　　{% endfor %}

 

if 标签

{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

{% if num > 100 or num < 0 %}
    <p>无效</p>
{% elif num > 80 and num < 100 %}
    <p>优秀</p>
{% else %}
    <p>凑活吧</p>
{% endif %}

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

with

定义一个中间变量，多用于给一个复杂的变量起别名。

注意等号左右不要加空格。

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

或

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

 

csrf_token

这个标签用于跨站请求伪造保护。

在页面的form表单里面写上{% csrf_token %}

注释

{# ... #}

注意事项

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

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

 

2. 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的值。

自定义 

自定义过滤器必须做的三件事
1.在应用名下新建一个名为templatetags文件夹(必须叫这个名字)
2.在该新建的文件夹内新建一个任意名称的py文件
3.在该py文件中需要固定写下面两句代码
　　　　from django import template
　　　　register = template.Library()

自定义过滤器

  @register.filter(name='XBB')     
  def index(a,b):
      return a+b

自定义标签

    @register.simple_tag
    def plus(a,b,c):
        return a+b+c

自定义inclusion_tag

  @register.inclusion_tag('login.html',name='login')
  def login(n):
                # l = []
                # for i in range(n):
                #     l.append('第%s项'%i)
       l = [ '第%s项'%i for i in range(n)]
       return {'l':l}
        # login.html
        <ul>
            {% for foo in l %}
            <li>{{ foo }}</li>
            {% endfor %}
         </ul>
    # 调用
    {% login 5 %}

注意 :要想使用自定义的过滤器 标签 inclusion_tag 必须先在需要使用的html页面加载你的py文件

模板导入和继承

模版导入：

　　语法：{% include '模版名称' %}

　　如：{% include 'adv.html' %}

 

<div class="adv">
    <div class="panel panel-default">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
    <div class="panel panel-danger">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
    <div class="panel panel-warning">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
</div>

adv.html
adv,html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css">
    {#    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">#}
    <style>
        * {
            margin: 0;
            padding: 0;
        }

        .header {
            height: 50px;
            width: 100%;
            background-color: #369;
        }
    </style>
</head>
<body>
<div class="header"></div>

<div class="container">
    <div class="row">
        <div class="col-md-3">
            {% include 'adv.html' %}


        </div>
        <div class="col-md-9">
            {% block conn %}
                <h1>你好</h1>
            {% endblock %}

        </div>
    </div>

</div>

</body>
</html>

base.html
base.html
{% extends 'base.html' %}

{% block conn %}
    {{ block.super }}
是啊

{% endblock conn%}

order.html
order.html

 模板

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>

注意：我们通常会在母板中定义页面专用的CSS块和JS块，方便子页面替换。

继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends 'layouts.html' %}

块（block）

通过在母板中使用{% block  xxx %}来定义"块"。

在子页面中通过定义母板中的block名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。

{% include 'navbar.html' %}

静态文件相关

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

{% get_static_prefix %}

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

或者

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

simple_tag

和自定义filter类似，只不过接收更灵活的参数。

定义注册simple tag

@register.simple_tag(name="plus")
def plus(a, b, c):
    return "{} + {} + {}".format(a, b, c)

使用自定义simple tag

{% load app01_demo %}

{# simple tag #}
{% plus "1" "2" "abc" %}

inclusion_tag

多用于返回html代码片段

示例：

templatetags/my_inclusion.py

from django import template
register = template.Library()
@register.inclusion_tag('result.html')
def show_results(n):
    n = 1 if n < 1 else int(n)
    data = ["第{}项".format(i) for i in range(1, n+1)]
    return {"data": data}

templates/snippets/result.html

<ul>
  {% for choice in data %}
    <li>{{ choice }}</li>
  {% endfor %}
</ul>

templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>inclusion_tag test</title>
</head>
<body>

{% load inclusion_tag_test %}

{% show_results 10 %}
</body>
</html>
posted @ 2019-06-11 17:36  为此努力  阅读(146)  评论(0)  编辑  收藏  举报