Django的视图层和模板层

目录

• 一、视图层
  • 1. 小白必会三板斧
  • 2. JsonResponse
  • 3. FBV与CBV
    • 3.1 FVB
    • 3.2 CBV
  • 4. CBV的源码
  • 5. 给CBV加装饰器
• 二、模板层
  • 1. 模板语法
  • 2. 模板传值/取值
  • 3. 过滤器
  • 4. 标签 （逻辑相关）
  • 5. 自定义过滤器和标签
    • 5.1 如何自定义过滤器
    • 5.2 自定义过滤器的使用
  • 6. 模板的继承
  • 7. 模板的导入

一、视图层

1. 小白必会三板斧

1. HttpResponse
2. render
3. redirect

视图函数必须要有一个返回值，并且返回值的数据类型必须是HttpResponse对象。

2. JsonResponse

通常情况下前后端数据交互采用的都是json的字符串(字典)，想要使用json格式的数据，需要进行序列化与反序列化的操作。

python后端：

# json序列化
json.dumps()

# json反序列化
json.loads()

js前端：

// 序列化
JSON.stringify()

// 反序列化
JSON.parse()

在Django项目中，想要将json格式的数据发送到前端，也需要先将数据序列化：

def index(request):
    user_dic = {'name':'爆裂码畜xanxas','password':'123'}
    json_str = json.dumps(user_dic)
    return HttpResponse(json_str)  # 发现中文被转码了

# 让json不自动帮你对中文进行转码
def index(request):
    user_dic = {'name':'爆裂码畜xanxas','password':'123'}
    json_str = json.dumps(user_dic,ensure_ascii=False)
    return HttpResponse(json_str)

发现这样比较麻烦。

因此，，Django帮你做了优化，使用JsonResponse可以直接将数据以json格式发送给前端：

def index(request):
    user_dic = {'name':'爆裂码畜xanxas','password':'123'}
    return JsonResponse(user_dic)

# 同样的，中文也会自动转码，可以看JsonResponse源码中有一个json_dumps_params参数就是专门用来传json.dumps()里面需要的参数的，需要注意的是，要以字典的形式传参
def index(request):
    user_dic = {'name':'爆裂码畜xanxas','password':'123'}
    return JsonResponse(user_dic,json_dumps_params={'ensure_ascii':False})

3. FBV与CBV

3.1 FVB

基于基于函数的视图：function based views

就是普通的视图函数。

3.2 CBV

基于类的视图:class based views

可以自动识别请求方式，根据请求方式调用与请求方式同名的函数。

是写在views视图文件中的一个类，可面向对象编程，可以被路由直接访问：

# CBV

# views.py文件写法
from django.views import View
# 所有自定义的CBV类都需要继承View父类
class MyLogin(View):
    def get(self,request):
        print('我是MyLogin里面的get方法')
        return render(request,'login.html')
    def post(self,request):
        print('我是MyLogin里面的post方法')
        return HttpResponse('post')

# urls文件写法
urlpatterns = [
    # 与FBV有些不同
    url(r'^login/',views.MyLogin.as_view()),
]

4. CBV的源码

为什么CBV能够根据请求方式的不同 自动执行不同的方法？？？

views.MyLogin.as_view()
# 类 .点 函数并调用，说明是一个类在调用类的函数，而且这个函数可以判断是类的绑定方法，但是我们自己写了MyLogin类，并没有写as_view这个函数，说明这个函数是MyLogin类的父类--View，所带的方法。

# 访问属性和方法
# 方法就是函数(函数名加括号执行优先级最高)
# 项目一启动 会自动执行as_view方法

源码：

# as_view源码
@classonlymethod
def as_view(cls, **initkwargs):
    def view(request, *args, **kwargs):  # 闭包函数
        self = cls(**initkwargs)
        # cls是我们自己写的类 MyLogin 实例化出的对象
        # 在看源码的时候,你一定要把握住一个顺序:
        # 1.对象在查找属性和方法的时候,先从对象自身找
        # 2.再去产生对象的类中找
        # 3.再去类的父类中找
        return self.dispatch(request, *args, **kwargs)
    return view  # 返回的是内部函数的函数名
	# MyLogin.as_view() == MyLogin.view

# dispatch源码(******)
def dispatch(self, request, *args, **kwargs):
    # 判断当前请求方式在不在默认的八个方法内
    # http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']
    # 以GET请求为例，先转小写
    if request.method.lower() in self.http_method_names:
        # 利用反射去自己定义的类的对象中查找get属性或者是方法
        # handler = getattr(obj,'get','报错信息')
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        # handler = get方法函数
	else:
		handler = self.http_method_not_allowed
	# 调用get方法
	return handler(request, *args, **kwargs)  

5. 给CBV加装饰器

1. 直接在自定义的类内部的函数上加装饰器

   class MyLogin(View):
       @outter
       def get(self,request):
           print('我是MyLogin里面的get方法')
           return render(request,'login.html')
       @outter
       def post(self,request):
           print('我是MyLogin里面的post方法')
           return HttpResponse('post')
   

2. Django推荐的方法，用method_decorator给函数加装饰器

   from django.utils.decorators import method_decorator
   class MyLogin(View):
   	@method_decorator(outter)  # 推荐方法
       def get(self,request):
           print('我是MyLogin里面的get方法')
           return render(request,'login.html')
   

3. 用method_decorator在类上指定函数家加装饰器

   from django.utils.decorators import method_decorator
   @method_decorator(outter,name='get')
   class MyLogin(View):
       def get(self,request):
           print('我是MyLogin里面的get方法')
           return render(request,'login.html')
   

4. 一次性给类下所有函数加装饰器

   from django.utils.decorators import method_decorator
   @method_decorator(outter,name='dispatch')
   class MyLogin(View):
       # @method_decorator(outter)
       def dispatch(self, request, *args, **kwargs):
           # 如果你想在视图函数执行之前做一些操作
           # 你可以在你的CBV中定义dispatch方法来拦截
           return super().dispatch(request,*args,**kwargs)
   

二、模板层

1. 模板语法

只有两种书写格式

{{}}  # 变量相关  用值
{%%}  # 逻辑相关  用逻辑语句

2. 模板传值/取值

• 可以传的值的类型：

  1. python基本类型全部支持

  2. 函数名（传的时候自动调用，真正传的是函数的返回值）

     模板语法不支持函数传参，如果传的函数需要参数，那传的时候直接不调用，传过去啥也没有。也就意味着,你传给html页面的只能是不需要传参调用的函数。

  3. 类名（传的时候自动加括号实例化产生对象，真正传的是对象的地址）

  4. 对象（方法和属性支持用“.”的方法调用）

  总结:只要是能够加括号调用的，传递到html页面上都会自动加括号调用

• 传值方式：

  1. 指名道姓，键值对字典
  2. locals() 可以将当前所在的名称空间中所有名字全部传递给HTML页面

• 取值方式：只要点点点就行了(不管是列表还是字典，列表就点索引，字典就点key)

  <p>{{ comp_dic.hobby.2.2.age }}</p>
  

3. 过滤器

语法结构：|

1. default

   判断是否有值。

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

   否则，使用变量的值。

   {{ is_value|default:'默认值' }}
   

2. length

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

   {{ s|length }}
   

3. filesizeformat

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

   {{ file_size|filesizeformat }}
   

4. slice

   切片

   {{ l|slice:'0:5:2' }}
   

5. date

   格式化

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

6. safe

   默认情况下,Django是不会自动帮你转换成前端html标签的，防止恶意攻击。

   {{ sss|safe }}
   

7. truncatechars

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

   <p>截取文本内容(字符) 截取五个字符 三个点也算:{{ s|truncatechars:5 }}</p>
   

8. truncatewords

   在一定数量的字后截断字符串。以空格为截止符。

   <p>截取文本内容(按照空格计算) 截取五个单词 三个点不算 :{{ s1|truncatewords:5 }}</p>
   

9. add

   加法

   <p>加法运算(内部异常捕获 支持数字相加 字符串拼接 都不符合返回空):{{ n|add:f }}</p>
   

4. 标签 （逻辑相关）

1. if

   {% for foo in lis %}
       <p>{{ forloop }}</p>
   {% endfor %}
   

2. for循环

   {% if s %}
       <p>s有值</p>
   {% else %}
       <p>s没有值</p>
   {% endif %}
   

3. if&for 连用

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

5. 自定义过滤器和标签

django支持用户自定义

必须要先有三步准备：

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

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

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

from django.template import Library
register = Library()

之后就可以利用register来自定义过滤器和标签

5.1 如何自定义过滤器

注意：

需要先在html页面上加载。

# 自定义过滤器跟默认的过滤器一样，最多只能接受两个参数。
@register.filter(name='baby')
def index(a,b):
    return a + b

# 自定义标签   可以接受任意多个参数
@register.simple_tag(name='mytag')
def mytag(a,b,c,d):
    return '%s?%s?%s?%s'%(a,b,c,d)

# 自定义lusion_tag
"""
是一个函数 能够接受外界传入的参数 然后传递给一个html页面
页面上获取数据 渲染 完成之后
将渲染好的页面 放到调用inclusion_tag的地方
"""

# 自定义inclusion_tag
@register.inclusion_tag('mytag.html',name='xxx')
def index666(n):
    l = []
    for i in range(n):
        l.append('第%s项'%i)
        return locals()  # 将l直接传递给mytag.html页面

5.2 自定义过滤器的使用

{% load mytag %}
{{ 1|baby:1  }}
{{ 1|baby:100  }}

<p>自定义标签的使用 可以接受多个参数 参数与参数之间必须空格隔开</p>
{% load mytag %}
{% mytag 'a' 'b' 'c' 'd' %}

<p>自定义的过滤器可以在逻辑语句使用 而自定义的标签不可以</p>
{% load mytag %}
{% if mytag '1' '2' '3' '4' %}
    <p>有值</p>
{% else %}
    <p>无值</p>
{% endif %}

                                                                <p>自定义inclusion_tag的使用，当你需要使用一些页面组件的时候，并且该页面组件需要参数才能够正常渲染，你可以考虑使用inclusion_tag</p>
                                                                {% load mytag %}
{% xxx 5 %}

6. 模板的继承

1. 先在你想要继承的页面上通过block划定你将来可能要改的区域
2. 在子页面上先继承extends
3. 利用block自动提示 选择你想要修改的内容区域

{% block content %}
{% endblock %}

先在页面上利用block划定你以后可能想改的区域

继承之后,就可以通过名字找到对应的区域进行修改

{% extends 'home.html' %}

{% block content %}
修改模板中content区域内容
{% endblock %}

模板上的block区域越多，页面的扩展性越强

建议你一个模板页面至少有三块区域

1. css区域

2. html代码区域 可以设置多个block

3. js区域

有了这三块区域，就能够实现每一个页面都有自己独立的css和js代码

{% extends 'home.html' %}

{% block css %}
	<style>
    	p {color: green;}
	</style>
{% endblock %}

{% block content %}
	<p>login页面</p>
{% endblock %}

{% block js %}
	<script>
   		alert('login')
	</script>
{% endblock %}

你还可以在子页面上继续沿用父页面的内容

{{ block.super }}

7. 模板的导入

将html页面当做模块的直接导入使用

{% include 'bform.html' %}