4、列表生成式
class Foo:
pass
class Bar:
pass

v = []
for i in [Foo,Bar]:
obj = i()
v.append(obj)
v = [item() for item in [Foo,Bar]]
v 对象列表

5、面向对象
- 继承
- 多态
- 封装 
- 对同一类方法进行封装   
class File: 文件增删改查方法  
def __init__(self,a1,a2):
self.a1 = a1
self.xx = a2
def get(self):
pass
def add(self):
pass
obj1 = File(123,666)
obj2 = File(456,999)

from django.shortcuts import render

# Create your views here.


class Resquest(object):

    def __init__(self,obj):
        self.obj = obj

    @property
    def user(self):
        return self.obj.authticate()

class Auth(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def authticate(self):
        return self.name

class APIView(object):
    def dispatch(self):
        self.f2()

    def f2(self):
        a = Auth('alex',18)
        b = Auth('oldboy',11)
        req = Resquest(b)
        print(req.user)

obj = APIView()
obj.dispatch()

方法一：
csrf时需要使用
- @method_decorator(csrf_exempt)
- dispatch
在CBV中 配置方法
class StudentsView(MyBaseView, View):
    @method_decorator(csrf_exempt)
    def dispatch(self, request, *args, **kwargs):
        return super(StudentsView, self).dispatch(request, *args, **kwargs)

方法二
@method_decorator(csrf_exempt, name='dispatch')
class StudentsView(MyBaseView, View):
    pass

urlpatterns = [
    url(r'^users/', views.user),
    url(r'^students/', views.StudentsView.as_view()),
    url(r'^get_order/', views.get_order),
    url(r'^add_order/', views.add_order),
    url(r'^update_order/', views.update_order),
    url(r'^del_order/', views.del_order),
    url(r'^order/', views.order),

    ]

def order(request):

    if request.method == 'GET':
        return HttpResponse('获取订单')
    elif request.method == 'POST':
        return HttpResponse('创建订单')
    elif request.method == 'PUT':
        return HttpResponse('更定订单')
    elif request.method == "DELETE":
        return HttpResponse('删除订单')

urlpatterns = [
    url(r'^users/', views.user),
    url(r'^students/', views.StudentsView.as_view()),
    url(r'^get_order/', views.get_order),
    url(r'^add_order/', views.add_order),
    url(r'^update_order/', views.update_order),
    url(r'^del_order/', views.del_order),
    url(r'^order/', views.OrderView.as_view()),

    ]

class OrderView(View):
    def get(self,request,*args,**kwargs):
        return HttpResponse('获取订单')

    def post(self, request, *args, **kwargs):
        return HttpResponse('创建订单')

    def put(self, request, *args, **kwargs):
        return HttpResponse('更新订单')

    def delete(self, request, *args, **kwargs):
        return HttpResponse('删除订单')

PI与用户的通信协议，总是使用HTTPs协议。
域名 
https://api.example.com                         尽量将API部署在专用域名（会存在跨域问题）
https://example.org/api/                        API很简单
版本
URL，如：https://api.example.com/v1/
请求头                                                  跨域时，引发发送多次请求

class OrderView(View):
    def get(self,request,*args,**kwargs):

        ret = {
            'code':10000,
            'msg': 'xxx',
        }

        return HttpResponse(json.dumps(ret),status=201)

处理 error
返回结果
GET /collection：返回资源对象的列表（数组）
GET /collection/resource：返回单个资源对象
POST /collection：返回新生成的资源对象
PUT /collection/resource：返回完整的资源对象
PATCH /collection/resource：返回完整的资源对象
DELETE /collection/resource：返回一个空文档

/order/
[
{'id',1,
'name':'苹果',
url: http://www.myjishu.com/1/
},
{'id',2,
'name':'橘子'}
]

否则就需要
/order/1/ 来访问

这些就是restful定义的规范，可以不遵循
谈谈自己对restful api 规范的认识
会restful之前
定义一些规范 更好的处理 url体现出对api的操作
没用之前....，用了之后....
多url 增删改查 == 合并成一个url，单url代表CRUD 
版本、状态码（2xx/4xx/5xx）、method（CRUD）
cors 跨域问题  跨源资源共享  jsonp  
协同开发统一，更加规范
10个规则

不引用drf 也可以通过django实现 restful规范，只是比较麻烦，要自己去实现对应的restful规则

2、django rest framework 框架
 pip3 install djangorestframework

class APIView(View):
pass

class OrderView(APIView):
pass

继承APIView，获取的功能越多，之前类的继承，注意继承的顺序，从左到右 == 》 

a. cbv 执行dispatch 

http://127.0.0.1:8000/app01/dog/?token=123

a. 用户认证
仅使用
源码流程
self.dispatch

生成器、迭代器、装饰器、反射
中间件
csrf token
CBV本质 dispatch 反射实现  
restful规范 
- 10条规范  
- 认识
Djangorestframework框架
- 如何验证（基于数据库实现用户认证）
- 源码流程 (面向对象回顾流程) 继承 封装 
- 列表生成式
- 类的封装、继承

用户验证  基于数据库实现

@csrf_exempt
def user(request):
    # getattr(obj.request.method)
    user_list = ['alex', 'oldboy']
    return HttpResponse(json.dumps((user_list)))


class MyBaseView(object):
    def dispatch(self, request, *args, **kwargs):
        print('before')
        if request.method == 'GET':
            print('after')
        ret = super(StudentsView, self).dispatch(request, *args, **kwargs)
        return ret

1、 中间件  
2、csrf原理  views 判断是否通过csrf   全局、局部   返回一个随机字符串  验证 匹配就通过  
3、rest 10个规范   api、版本、https、status码、method、错误码、url传参、返回结果、加域名前面 跨域（jsonp），带参数URL  
4、面向对象  属性方法封装到类   继承    多态 本身就是多态

封装
1、将构造方法封装到类中
2、将重复方法提取到一个类中

继承
共同的属性和方法 提取到基类中实现
多继承 从左到右  经典类 新式类   广度优先深度优先
从根部开始找，谁实例化对象就从谁开始找
多态 本身就是多态
点出方法，就支持这个功能

5、django请求生命周期 包含rest framework框架
uwsgi -》中间件 -》 url -》 views 视图 FBV、CBV（dispatch反射找到对应函数） -》 templates / models  
-》 view rest framework 重写dispatch  实现 
csrf token  装饰器添加方式 CBV

1、认证类，必须继承 from rest_framework.authentication import BaseAuthentication
2、其他认证类，BasicAuthentication 认证  通过用户名和密码认证 

一般自定义实现，通过token来实现认证

这里中间件想到了什么，
对了，就是思考这个全局的配置认证登录是不是通过中间件实现的？
不是基于中间件，就是通过url进来，之后访问到视图CBV，在通过APIView类 -》认证 self.dispatch 来实现的   
drf自带的基本的认证

梳理：
认证 一个类 
1、使用
    - 创建类 继承 BaseAuthentication  实现 authenticate
- 返回值
- None  我不管了，下一个认证来执行
- exceptions.AuthenticationFailed('用户认证失败')
- （元素1，元素2） # 元素1赋值给request.user , 元素2 赋值给 request.auth
- 局部使用

2、源码流程
- dispatch  
- 封装request
- 获取定义的认证类(全局/局部)，通过列表生成式创建对象
- initial
- perform_authentication
    request.user(内部循环...)

回顾那些数据在body里面
记起来了，ajax提交的时候会提交的数据，这里可以用request.POST.get() 获取  
$.ajax({
url:url,
method: 'post',
data: {
username: 'ceshi',
password: '123',
},
success:function(res){

}
})

这种方式会提交到request.body中，获取的就是字符串，必须手动json.loads() 再用对象处理  如果返回直接json.dumps() 返回获取也是字符串，js中需要用JSON.stringify() 进行转对象处理 
$.ajax({
    type: "POST",
    url: "/Service/ListString",
    contentType: "application/json",
    dataType: "json",
    data: JSON.stringify({
        "BuIds": ["1", "2", "3"]
    }),
    success: function(jsonResult) {
        alert(jsonResult);
    }
});

问题：不同视图用不同的权限来访问
基本使用  跟认证类似  
源码流程

梳理：
1、基本使用
-  类： 继承 BasePermission  必须 实现 has_permission方法
- 返回值：
True：有权访问
FALSE: 无权访问 
- 局部

-全局  settings
2、源码流程

自己写视图 or 中间件都可以实现，只是用restful framework组价就在他的里面实现

限制访问频率 （节流） 控制访问频率 
访问记录 = {
身份证号: [12:10:10,12:10:9,12:10:8,12:10:7,12:10:6,12:10:5]
}

访问记录 = {
用户IP: [....]
}
匿名用户 -- 换ip  没招
注册用户 --绑定人  
注册10w用户 ---  绑定手机号，唯一标识

所有都是通过ip限制 ：也可以基于用户名

内置控制类

梳理：
匿名 ip会换
登录用户  注册大量账号  绑定手机号  限制
a. 基础使用
- 类，继承：BaseThrottle  实现 alow_request wait 方法
- 类，继承：SimpleRateThrottle 实现 get_cache_key 、scope = ‘luffy’ （配置文件中的key）

b. 局部
# throttle_classes = [VisitThrottle, ]
c、全局
settings

记返回值 or 源码（认证、权限、节流）

内容概要：
1、版本  *
2、解析器   contenttype = application/x-www-form-urlencoded *
3、序列化  ****
- 请求数据进行校验
- Queryset进行序列化
4、分页  **
5、路由  自动路由 **
6、视图 CBV  APIView   FBV @APIView   **
7、渲染器 *

认证、权限、节流
10个规范
10个组件

内容回顾
谈谈面向对象 
封装 相同属性和方法封装到一个类  构造方法状态到一个类中     自定义分页  restful 源码  request封装 新request 
继承  基类、派生类  公共实现    多继承  经典类 新式类  APiView -》VIew   form表单 -》form -》 modelform
多态 鸭子模型  鸭子呱呱叫 就是 鸭子  函数.方法   

class WX:
def send():
pass
class email:
def send():
pass
class Msg():
pass

def func(arg):
arg.send()

obj = Email()
func(obj)
arg多种形态，不管是wx还是email，传什么对象执行对应的send方法，鸭子，只要能send都能允许

django生命周期  
uwsgiref wsgi协议 django约束 -》中间件 -》url -》 views视图FBV  -》 templates /models
wsgi
wsgi 是协议 == 参数  
wsgiref，是实现了wsgi协议的一个模块，模块本质，一个socket服务端，性能太低
werkzeug  是实现了wsgi协议的一个模块，模块本质，一个socket服务端 flask框架
tornado  是实现了wsgi协议的一个模块，模块本质，一个socket服务端  自己写的socket 实现wsgi协议
uwsgi，是实现了wsgi协议的一个模块，模块本质，一个socket服务端
基于wsgi实现

中间件 -》url -》视图 CBV dispatch as_view() -> view() -> dispatch  -> 请求封装Request封装 -》认证 -> 权限 -》节流 -》  反射执行method func执行 -》返回经过中间件
注意 不是用中间件实现的，全局配置是通过配置文件实现的，只要走了dispatch 就会找setting中的配置，有就会全局应用 or 视图局部应用
csrf token 这里在全局设置（中间件） 局部视图CBV排除方式不同

详细
1、版本
a.URL中通过get传参
自定义：
http://127.0.0.1:8000/api/user/?version=v2


b. 在URL中传参(推荐使用)
版本在认证、权限、节流之前

总结：
使用：
配置文件
路由系统
视图

2、解析器
Request.POST     
request.body   请求体 -》转换 dict 
请求头 contenttype
前戏： django  request.POST / request.body 
1、请求头要求：
Content-Type:application/x-www-form-urlencoded'   # 默认类型  会传递到request.POST中 
PS: 如果请求头中的 Content-Type:application/x-www-form-urlencoded'  request.POST中才有值 去Request.body中解析数据
2、数据格式要求：
name=alex&age=18&gender=男

如
a. form表单提交
<form method.....>
input...
</form>

b.ajax提交
$.ajax({
url:...
type:POST,
data:{name=alex,age=18}  # 内部转化 name=alex&age=18&gender=男
})

情况一
$.ajax({
url:...
type:POST,
headers:{Content-Type:application/json'}
data:{name=alex,age=18}   # 内部转化 name=alex&age=18&gender=男   ajax提交会用 
})
# body有值，POST无  因为头部类型不对   无法转换为字典格式  只能变成 "name=alex&age=18&gender=男" 字符串

情况二：
$.ajax({
url:...
type:POST,
headers:{Content-Type:application/json'}
data:JSON.stringfy({name=alex,age=18})     # {name:alex,age:18}   JSON.parse()  前端需要格式化为JSON数据在传递

})
# body有值，POST无   头类型不对，格式也不对
json.loads(request.body) # 转化字典
在drf中，解析器 request.data 直接获取解析后的字典

PS: 实际测试json格式的如果数据类型不行json，restful解析器会报错，要能够解析，前端传过来必须是格式化的json数据，没有name=123&b=2 这种格式的无法解析 
    "detail": "JSON parse error - Expecting property name enclosed in double quotes: line 1 column 2 (char 1)"

rest_framework  解析器，对请求体数据进行解析
总结：使用配置
全局配置
使用 request.data

源码流程 & 本质
a.本质
请求头  主要包含 url。method、状态码、cookie、refre 防盗链、contenttype、post、accept 期望的返回格式、User-Agent
请求方法
状态码 
b.源码流程
dispatch() request封装  解析器封装 
- request.data   parse  解析器解析   
ajax 这里也需要格式化 JSON.stringfy() 才能获取到request.data。在常规中json.loads(request.body) 得到json的字典  
注意要传递json格式 就要预先格式化，否则就是字符串 a=2&b=1 在request.body中，不能作为字典对象使用
上传文件 参考：https://www.cnblogs.com/wupeiqi/articles/7805382.html

3、序列化
- 请求数据认证
- query_set序列化
类似写form 直接格式化  
choice 显示里面的值  stark已实现 model 有个对应方法 get_userinfo_display() 获取到choice的值

a. gp = serializers.CharField(source='group.title')  # 外键  
b.自定义显示
rls = serializers.SerializerMethodField()  # 自定义显示
class Meta:
    model = models.UserInfo
    # fields = "__all__"
    fields = ['id','username','password','ooo','rls']
    # extra_kwargs = {'group':{'source':'group'},}

def get_rls(self, row):
    role_obj_list = row.role.all()
    ret = []
    for item in role_obj_list:
        ret.append({'id': item.id, 'title': item.title})
    return ret

今日内容概要：
0. 序列化源码  搞清楚怎么查找的，永远从self 对象开始找，就不会错，从头开始， 源码可以多过几遍  
1、分页
a. 分页，看第n页，每页显示n条数据  page max  size  一页显示多少条数据 
b. 分页，在n个位置，向后查看n条数据  limit  offset
c. 加密分页，只能看到上一页和下一页，一千万页也不会慢  记录 id最大值 id最小值  只扫10条  
一千万数据 分页  越到后面越慢  索引只能优化  不能解决 

总结：
设计表结构  insert 数据  连表查询 group by  基础
数据量比较大  分页如何做？
- 数据库性能相关？索引优化  最近看过....   话题转换到rest formwork 分页 跟这个有关系  原生sql，数据量大后变慢，可以通过记住最大值最小值id解决，但是url上直接输入99999会有问题，发现fromwork源码里面url页码进行了加密，做的挺好的
- 话题转移后开始介绍  10个组件、10个规范  源码流程  请求封装  版本 .... django请求生命周期 

2、视图  继承关系 
继承 APIVIew 继承 django View  
继承6个类 CRUD 局部更新 继承其他类 -> 2个 -> 1个

a.过去

b.现在

c.无用

d. GenericViewSet

总结：
单条、多条  GenericViewSet
a. 增删改查 ModelViewSet
b. 增删 CreateModelMixin DestroyModelMixin   GenericViewSet
c. 复杂逻辑 GenericViewSet 或 APIView

PS：还债

3、路由  as_view()   自动分发  
一个API 4个URL  至少2个URL 
官网 20行代码实现

会根据url进行分发，全部在get中好一些，减少一些判断，比如查询多条，单条，需要做判断   直接在url区分  到不同视图  

4、渲染器  友好的显示 和 序列化返回数据

5、django组件：contenttype

内容回顾：
1、rest规范 url https 版本 资源名词 过滤条件  请求头 method  域名 状态码返回 结果集 headlemidderware  10个规范
2、rest framework 框架 其他语言也有  10个组件  前4个  CBV -》 view -》 dispatch -》request请求封装 -》认证  parse -》 解析器 
initialize_request  initial返回视图  版本 认证 权限 节流  
版本控制  get传参  请求头  namespace  url上 一般放在url上  视图都相同  在全局配置上
认证 方法 返回值 出错  元祖 None
权限判断  True FALSE
节流 True  False  匿名用户 代理ip/ip来做 登录用户用用户来做
反射执行视图函数  解析器 请求头contenttype不同获取值不同  
request.body  json/application  
request.POST  有值  没有值 看request.body
解析器 可以解析多种格式数据
序列化     数据校验   Queryset序列化返回给用户
2种 ：Serializer  modelSerializer  
字段三类：CharField IntegerField  、MyCharField 、自定义 HyperlinkedIdentityField
 url 小bug   group = serializers.HyperlinkedIdentityField(view_name='gp', lookup_field='group_id', lookup_url_kwarg='xxx')
使用 应用Serializer 先实例化Serializer  传入instance    ser.data 获取数据 
ser = UserInfoSerializer(instance=users, many=True)
ret = json.dumps(ser.data, ensure_ascii=False)
请求校验
ser = UserGroupSerializer(data=request.data)
if ser.is_valid():
    print(ser.validated_data['title'])
else:
    print(ser.errors)

- 前4个组件源码流程  
- 序列化
url 版本 解析器 都是一次性配置

work：
1、序列化 == 源码  get_query() / 
2、视图继承流程  page组件里面的序列化流程  
3、写代码 
- jQuery 发送ajax请求
a.Vue
- 看到登录页面
- 数据用户名和密码，发送ajax请求
- 用户列表页面  双向绑定展示  将用户数据显示在页面中
- 学生详细信息 
b.django rest framework 
- /auth/
返回token 
- /students/ （认证）
返回学生列表
- /students/\d+/
返回学生详细信息
c.节流  
控制
- 匿名用户 2分钟访问10次
- 正常用户 2分钟访问20次
权限
PS：CORS  端口不同跨域，解决设置响应头 不用jsonp