模板层

模板层

模板语法

　　两大类

　　　　{{ }}        变量相关

　　　　{% %}    逻辑相关

为模板传值

前端:
{#<p>{{ n }}</p>#}
{#<p>{{ f }}</p>#}
{#<p>{{ s }}</p>#}
{#<p>{{ l }}</p>#}
{#<p>{{ d }}</p>#}
{#<p>{{ t }}</p>#}
{#<p>{{ se }}</p>#}
{#<p>传函数名,会自动加括号调用该函数,前端展示的是函数调用之后的返回值:{{ index }}#}
{#    注意:如果函数需要参数的话  那么不好意思 模板语法不支持#}
{#</p>#}
{#<p>{{ obj }}</p>#}
{#<p>{{ obj.get_self }}</p>#}
{#<p>{{ obj.get_cls }}</p>#}
{#<p>{{ obj.get_static }}</p>#}
{#<p>总结:django的模板语法 不支持给函数传参!!!</p>#}

后端:
def reg(request):
　　# 先验证是否python所有的数据类型都可以被传递到前端
　　n = 0
　　f = 1.11
　　s = '你妹的'
　　l = [1,2,3,4,5,6,[12,3,4,{'name':'heiheihei'}]]
　　d = {"name":'jason','password':123}
　　t = (1,2,3,4,5)
　　se = {1,2,3,4,5,6,7,}

　　

　　def index(xxx):
　　　　print(xxx)
　　　　print('index')
　　　　return '我是index函数的返回值'

　　class Demo(object):
　　　　def get_self(self):
　　　　　　return '绑定给对象的方法'
　　　　@classmethod
　　　　def get_cls(cls):
　　　　　　return '绑定给类的方法'
　　　　@staticmethod
　　　　def get_static():
　　　　　　return '我是静态方法 其实就是函数'
　　obj = Demo()

# 给模板传值的方式
    # 方式1
    # 通过字典的键值对 指名道姓的一个个的传
    # return render(request,'reg.html',{'n':n,'f':f})
    # 方式2
    # locals会将它所在的名称空间中的所有的名字全部传递给前端
    # 该方法虽然好用 但是在某些情况下回造成资源的浪费
    # return render(request,'reg.html',locals())

模板语法之过滤器:内部原理(会将|前面的当做第一个参数传入标签中)

过滤器:   |

前端:

{#<p>{{ l|length }}</p>#}
{#<p>{{ n|length }}</p>#}
{#<p>{{ ss|default:'当|左边的变量为空就会返回|右边的值' }}  default跟你后端get方法很想</p>#}
{#<p>{{ ss|default:'' }} default必须要有两个参数</p>#}
{#<p>{{ file_size|filesizeformat }}</p>#}
{#<p>{{ info|truncatewords:3 }} 就是按空格截取  三个点不算</p>#}
{#<p>{{ info1|truncatewords:3 }}</p>#}
{##}
{#<p>{{ info|truncatechars:6 }}按字符截取内容 三个点也算</p>#}
{##}
{#<p>{{ xxx|safe }}</p>#}
{#<p>{{ yyy|safe }}</p>#}
{#<p>{{ zzz }}</p>#}
{##}
{##}
{#<p>{{ ctime }}</p>#}
{#<p>{{ ctime|date:'Y-m-d' }} 只需要掌握年月日就可以了</p>#}
{##}
{##}
{#<p>{{ n|add:100 }}</p>#}
{#<p>{{ s|add:'hahah 翻车啦' }}</p>#}

<p>{{ l|slice:'0:3' }}</p>
<p>{{ l|slice:'0:5:2' }}</p>


后端:
def reg(request):
    n = 0
    s = '你妹的'
    l = [1,2,3,4,5,6,[12,3,4,{'name':'heiheihei'}]]
    file_size = 12312312
    info = 'my name is jason and my age is 18'
    info1 = '傻大姐 撒旦 技术 大 萨达 了 奥斯卡 的健康两 三点卡是考虑到'
    xxx = '<h1>波波棋牌室</h1>'
    yyy = '<script>alert(123)</script>'
    from django.utils.safestring import mark_safe
    zzz = mark_safe('<h1>阿萨德搜啊第三款垃圾袋</h1>')
    from datetime import datetime
    ctime = datetime.now()

    return render(request,'reg.html',locals())

前后端取消转义:

　　前端:

　　　　|safe

　　后端:

　　　　from django.utils.safestring import mark_safe
　　　　zzz = mark_safe('<h1>hahahahaah</h1>')

|safe
|filesizeformat
|date

模板语法之标签(逻辑相关)   {%%}

前端:
<h1>模板语法之标签(逻辑相关)</h1>
{#{% for foo in l %}#}
{#    <p>{{ forloop }}</p>#}
{#{% endfor %}#}
{##}
{##}
{#{% if '' %}#}
{#<p>xxx条件为true</p>#}
{#    {% else %}#}
{#    <p>xxx条件为false</p>#}
{#{% endif %}#}

{##}
{#{% for foo in '' %}#}
{#    {% if forloop.first %}#}
{#        <p>这是我的第一次</p>#}
{#        {% elif forloop.last %}#}
{#        <p>这是最后一次了啊</p>#}
{#        {% else %}#}
{#        <p>来啊来啊!!!</p>#}
{#    {% endif %}#}
{#    {% empty %}#}
{#    <p>当for循环的对象为空的时候 会走empty</p>#}
{#{% endfor %}#}

{##}
{#<p>#}
{#    django模板语法在取值的时候 统一使用句点符(大白话就是 点号   .)#}
{#    {% with l.6.3.name as ttt %}  可以给一个比较复杂的取值操作取一个别名 之后在with语句中 就可以使用该别名#}
{#        {{ ttt }}#}
{#        {{ l.6.3.name }}#}
{#    {% endwith %}#}
{#</p>#}


{#{% for foo in d.keys %}#}
{#    <p>{{ foo }}</p>#}
{#{% endfor %}#}
{#{% for foo in d.values %}#}
{#    <p>{{ foo }}</p>#}
{#{% endfor %}#}
{#{% for foo in d.items %}#}
{#    <p>{{ foo }}</p>#}
{#{% endfor %}#}

for循环里面的forloop对象
if判断

自定义标签  过滤器  inclusion_tag

自定义固定的三步走战略:　　

　　1.必须在你的应用下新建一个名为templatetags文件夹

　　2.在该文件夹内新建一个任意名称的py文件

　　3.在该py文件中固定先写下面两句代码

from django import template
register = template.Library()

from django import template
register = template.Library()


# 自定义过滤器
@register.filter(name='baby')
def index(a,b):
# 该过滤器只做一个加法运算  是|add建议版本
"""
|length
|add
|default
|filesizeformat
|truncatewords
|truncatechars
|safe
|slice
"""
    print('下午刚起床 一脸懵逼')
    return a + b


# 自定义标签
# 支持传多个值
@register.simple_tag(name='jason')
def xxx(a,b,c,year):
    return '%s?%s|%s{%s'%(a,b,c,year)


# 自定义inclusion_tag
"""
接收用户传入的参数  然后作用于一个html页面
在该页面上渲染数据 之后将渲染好的页面
放到用户调用inclusion_tag的地方
        """
# 自定义inclusion_tag
@register.inclusion_tag('bigplus.html')
def bigplus(n):
    l = []
    for i in range(n):
        l.append('第%s项'%i)
    return {'l':l}

{#<h1>自定义过滤器的使用#}
{#自定义过滤器 只能由两个形参#}
{#    但是你可以在给第二个参数传值的时候 传一个字符串#}

{#{{ 123|baby:'1|2|3|4|5|6'}}#}
{#</h1>#}
{#{% load mytag %}#}
{#{{ 123|baby:1}}#}

{#<h1>自定义标签#}
{#支持传多个参数  参数与参数之间 空格隔开即可#}
{#</h1>#}
{##}
{#{% load mytag %}#}
{#{% jason 1 2 3 year=2 %}#}

<h1>自定义inclusion_tag
当你的页面上有一部分html代码需要经常被各个地方使用  并且需要传参才能渲染出来
那么你可以把该html代码部分制作成一个inclusion_tag
任何页面都能使用


</h1>
{% load mytag %}
{% bigplus 5 %}

<br>
{% bigplus 10 %}

模板的继承

当多个页面整体的样式都大差不差的情况下 可以设置一个模板文件
在该模板文件中 使用block块划分多个区域
之后子版在使用模板的时候 可以通过block块的名字 来选定到底需要修改哪一部分区域

模板一般情况下 应该至少有三个可以被修改的区域

{% block css %}
子页面自己的css代码
{% endblock %}
                
{% block content %}
子页面自己的html代码
{% endblock %}
                
{% block js %}
子页面自己的js代码
{% endblock %}

模板的继承   使用方式

{%extends 'home.html'%}
{% block css %}
<style>
    h1 {
        color: red;
        }
</style>
{% endblock %}


{% block content %}
<h1>登陆页面</h1>
<form action="">
    <p>username:<input type="text" class="form-control"></p>
    <p>password:<input type="text" class="form-control"></p>
    <input type="submit" class="btn btn-danger">
</form>
{% endblock %}

{% block js %}

{% endblock %}
# 一般情况下 模板上的block越多 页面的可扩展性就越强

模板的导入

{% include 'beautiful.html' %}

当你写了一个特别好看的form表单/列表标签等
可以将它当成一个模块 哪个地方需要 就直接导入使用即可

模型层的单表操作

　　1.单表操作
　　create_time = models.DateField()
　　关键性的参数
　　　　1.auto_now:每次操作数据 都会自动刷新当前操作的时间
　　　　2.auto_now_add:在创建数据的时候 会自动将创建时间记录下来 后续的修改不会影响该字段

　　增删改查

# 增
    # 方式1： create
    # book_obj  = models.Book.objects.create(title='三国',price=19.99,create_time='2019-11-11')
    # print(book_obj.title)
    # 方式2：对象点save()方法
    # from datetime import datetime
    # ctime = datetime.now()
    # book_obj = models.Book(title='红楼梦',price=96.66,create_time=ctime)
    # book_obj.save()

    # 查
    # print(models.Book.objects.all())
    # print(models.Book.objects.get(id=1))
    # print(models.Book.objects.get(pk=1))
    """
    pk会自动查找到当前数据的主键字段
    """
    # print(models.Book.objects.filter(pk=2))

    # 改
    # 1.update
    # models.Book.objects.filter(pk=1).update(title='三国演义')
    # 2.对象.save()
    # book_obj = models.Book.objects.get(pk=1)
    # book_obj.price = 666.66
    # book_obj.save()

    # 删除  delete()
    # models.Book.objects.filter(pk=2).delete()

    # < 1 > all(): 查询所有结果

    # < 2 > filter(**kwargs): 它包含了与所给筛选条件相匹配的对象
    # < 3 > get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。（源码就去搂一眼～诠释为何只能是一个对象）
    # < 4 > exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象
    # print(models.Book.objects.exclude(pk=1))  # 只要pk不是1的数据全部查询出来


    # < 5 > order_by(*field): 对查询结果排序('-id') / ('price')
    # print(models.Book.objects.order_by('price'))  # 默认是升序
    # print(models.Book.objects.order_by('-price'))  # 加负号就是降序


    # < 6 > reverse(): 对查询结果反向排序 >> > 前面要先有排序才能反向
    # print(models.Book.objects.order_by('price').reverse())

    # < 7 > count(): 返回数据库中匹配查询(QuerySet)的对象数量。

　　 # print(models.Book.objects.count()) # 对查询出来的结果进行一个计数 

    # < 8 > first(): 返回第一条记录 # print(models.Book.objects.filter(pk=1).first()) 

　　 # < 9 > last(): 返回最后一条记录 # print(models.Book.objects.all()) # print(models.Book.objects.all().last())

 　　# < 10 > exists(): 如果QuerySet包含数据，就返回True，否则返回False 
　　 # print(models.Book.objects.filter(pk=1000)) 
　　 # print(models.Book.objects.filter(pk=1000).exists())

 　　# < 11 > values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 # model的实例化对象，而是一个可迭代的字典序列
    # print(models.Book.objects.values('title','price')) # 得到的结果是列表套字典 

　　# < 12 > values_list(*field): 它与values() 
　　 # print(models.Book.objects.values_list('title','price')) 
    # 得到的结果是列表套元组 # 非常相似，它返回的是一个元组序列，values返回的是一个字典序列 

　　# < 13 > distinct(): 从返回结果中剔除重复纪录 """ 去重的前提是 一定要有完全重复的数据 才能去重 """ 
　　# print(models.Book.objects.filter(title='三国演义').distinct())
   # print(models.Book.objects.values('title','price','create_time').distinct())

13个必会操作总结

返回QuerySet对象的方法有

all()

filter()

exclude()

order_by()

reverse()

distinct()

特殊的QuerySet

values()       返回一个可迭代的字典序列

values_list() 返回一个可迭代的元祖序列

返回具体对象的

get()

first()

last()

返回布尔值的方法有：

exists()

返回数字的方法有

count()