1. 小白必会三板斧

HttpResponse
render
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加装饰器

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

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

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

用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')

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

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. 过滤器

语法结构：|

default

判断是否有值。

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

否则，使用变量的值。
```
{{ is_value|default:'默认值' }}
```
length

返回值的长度，作用于字符串和列表。
```
{{ s|length }}
```
filesizeformat

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

切片
```
{{ l|slice:'0:5:2' }}
```
date

格式化
```
{{ value|date:"Y-m-d H:i:s"}}
```
safe

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

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。
```
<p>截取文本内容(字符) 截取五个字符 三个点也算:{{ s|truncatechars:5 }}</p>
```

truncatewords

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

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

add

加法

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

4. 标签（逻辑相关）

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

for循环

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

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. 模板的继承

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

{% block content %}
{% endblock %}

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

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

{% extends 'home.html' %}

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

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

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

css区域
html代码区域可以设置多个block
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' %}

Django的视图层和模板层 一、视图层 二、模板层