一、开发模式:  

  1. 普通开发方式(前后端放在一起写)

  2. 前后端分离(前后台通过ajaxo交互)

    后端(django rest framework写的) <----ajaxo--->  前端(vue写的) <----- >  用户

    好处:

二、后端开发

    为前端提供url(API的开发或者接口的开发)

    注:永远返回HttpResponse

路由

from django.conf.urls import url
from django.contrib import admin from app01 import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^users/', views.users),
]

视图   ( FBV:function base view   基于函数的视图 如下)

import json

from django.shortcuts import render,HttpResponse

# Create your views here.

def users(request):
user_list = ['zgr','oldboy']
return HttpResponse(json.dumps(user_list))

后端的开发   http://127.0.0.1:8000/users/  只要访问这个URL就返回所有用户列表如下: 这就是接口的开发!

三、Django中的FBV和CBV

  FBV:function base view   基于函数的视图

    函数作为视图函数

    当访问URL时,函数执行了

  CBV:class base view       基于类的视图    基于反射实现根据请求方式不同,执行不同的方法。

    当访问URL的时候,这个类里面还可以写很多方法,这个类里那个方法被执行了?先.这个类再点这个方法。函数嵌套类里面。如果以GET 方式请求,就会执行get方法就会自动会被执行。

视图:

# 这个类必须继承django的这个View
from django.views import View class StudentsView(View):
def get(self, request, *args, **kwargs):
return HttpResponse('GET') def post(self, request, *args, **kwargs):
return HttpResponse('POST') def delete(self, request, *args, **kwargs):
return HttpResponse('DELETE') def put(self, request, *args, **kwargs):
return HttpResponse('PUT') def putch(self, request, *args, **kwargs):
return HttpResponse('PUTCH')

路由:

from app01 import views
urlpatterns = [
url(r'^admin/', admin.site.urls),# 路由这里必须是类.as_view() 这是固定搭配
url(r'^students/', views.StudentsView.as_view()),
]

这样一个CBV就写完了。以不同的方式来执行,就会有不同的函数自动帮你执行了。

HTTP请求的本质基于socket来做的,浏览器发一个请求本质上发了一堆字符串/r/n分割 ,做路由匹配,匹配成功,如果是FBV的话执行它对应的函数。但是如果是CBV怎么找到方法?通过反射!

反射

什么是反射?

  用在属性操作,之前是通过点操作属性。

  在python3中,统一了类与类型的概念(定义一个类就是一个类型,基本的数据类型字符串,列表。。。都是类)。

  通过字符串来反射到真正的属性身上,来进行属性操作。---->通过字符串来操作类或对象的属性。

  让客户自己输入要执行的操作,输入的是字符串,就要用字符串来反射到真正的属性(数据属性,函数属性...)身上.

python中的反射功能是由以下四个内置函数提供:hasattr、getattr、setattr、delattr,这四个函数分别用于对对象内部执行:检查是否含有某成员、获取成员、设置成员、删除成员。

isinstance 用它来判断是否是一个实例。也可以用来判断数据类型

issubclass 判断一个类是否是另一个类的子类。

在python3中,统一了类与类型的概念(定义一个类就是一个类型,基本的数据类型字符串,列表。。。都是类)。

Python中一切皆对象。

class Foo(object):

    def __init__(self):
self.name = 'wupeiqi' def func(self):
return 'func' obj = Foo() # #### 检查是否含有成员 ####
hasattr(obj, 'name')
hasattr(obj, 'func') # #### 获取成员 ####
getattr(obj, 'name')
getattr(obj, 'func') # #### 设置成员 ####
setattr(obj, 'age', 18)
setattr(obj, 'show', lambda num: num + 1) # #### 删除成员 ####
delattr(obj, 'name')
delattr(obj, 'func')
那么问题来了?
a、上述访问对象成员的 name 和 func 是什么? 
答:是变量名
b、obj.xxx 是什么意思? 
答:obj.xxx 表示去obj中或类中寻找变量名 xxx,并获取对应内存地址中的内容。
c、需求:请使用其他方式获取obj对象中的name变量指向内存中的值 “alex”

d、比较三种访问方式

  • obj.name
  • obj.__dict__['name']
  • getattr(obj, 'name')

四、列表生成式 

class Foo:
pass class Bar:
pass v=[item() for item in [Foo,Bar]]
print(v) v就是对象列表里面,就是Foo的对象和Bar的对象。 打印结果:
[<__main__.Foo object at 0x1029d1358>, <__main__.Bar object at 0x1029d1320>]
v=[]
for i in [Foo,Bar]:
obj=i()
v.append(obj)

五、面向对象编程   类    封装

  • 面向对象:对函数进行分类和封装,让开发“更快更好更强...”

  面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。

  类就是一个模板,模板里可以包含多个函数,函数里实现一些功能

  对象则是根据模板创建的实例,通过实例对象可以执行类中的函数

  • class是关键字,表示类
  • 创建对象,类名称后加括号即可

面向对象三大特性

一、封装

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以,在使用面向对象的封装特性时,需要:

  • 将内容封装到某处
  • 从某处调用被封装的内容

第一步:将内容封装到某处

# 对同一类方法封装到了同一类里面
class File:
文件的增删改查 class DB:
数据库的增删改查 # 将数据封装到对象中(一个类实例化就是执行类的init方法得到一个对象)
class File:
def __init__(self,a1,a2): # self=obj
self.a1=a1 #obj.a1=a1
self.xxx=a2 #obj.xxx=a2
def get..
def put..
def delete..
def post.. obj1 = File(123,234)

self 是一个形式参数,当执行 obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj1

当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2

所以,内容其实被封装到了对象 obj1 和 obj2 中,每个对象中都有 name 和 age 属性,在内存里类似于下图来保存。

 class Foo:

     def __init__(self, name, age):
self.name = name
self.age = age obj1 = Foo('wupeiqi', 18)
print obj1.name # 直接调用obj1对象的name属性
print obj1.age # 直接调用obj1对象的age属性 obj2 = Foo('alex', 73)
print obj2.name # 直接调用obj2对象的name属性
print obj2.age # 直接调用obj2对象的age属性

2、通过self间接调用被封装的内容

执行类中的方法时,需要通过self间接调用被封装的内容

 class Foo:

     def __init__(self, name, age):
self.name = name
self.age = age def detail(self):
print self.name
print self.age obj1 = Foo('wupeiqi', 18)
obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18 obj2 = Foo('alex', 73)
obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78

综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容。

req.obj是Auth对象 
class Request(object):
def __init__(self, obj):
self.obj = obj class Auth(object):
def __init__(self, name, age):
self.name = name
self.age = age class APIView(object):
def dispatch(self):
self.f2() def f2(self):
a = Auth('zrg', 18)
req = Request(a)
print(req.obj) obj = APIView()
obj.dispatch()

类似源码

class Request(object):
def __init__(self, obj): #req a
self.obj = obj #req.a=a @property #执行时不用加括号
def user(self): #第三步 req.obj.authenticate()=a.authenticate()
return self.obj.authenticate() class Auth(object):
def __init__(self, name, age): #a,zrg,18
self.name = name #a.name=zrg,a.age=18
self.age = age def authernticate(self): #第四步 a.name
# return True
# 在源码里
return self.name class APIView(object):
def dispatch(self): #传入对象自己obj
self.f2() #obj.f2() def f2(self):
a = Auth('zrg', 18) #第一步 实例化得到Auth对象a,把'zrg', 18封装进去 可以a.name a.age a.authernticate()
req = Request(a) #第二步 实例化得到Request对象 req Request里面有个obj是Auth的对象a 可以req.obj req.user
print(req.user) #第五步 对象里有什么就能点出来什么! obj = APIView() #实例得到APIView的对象obj
obj.dispatch() #执行对象的dispatch方法

CBV

框架基于反射来实现--->根据method的不同执行不同的方法。

反射的代码写在哪里?在View里面!

在路由系统里面永远是URL对应一个函数,类的对应的是这样的:

自己当前请求的类里面没有as_view方法,

没有去父类找,找到了。并且返回了个view

所以在路由那里执行as_view实际上是执行view方法,只不过这个函数里面有了cls,就是当前请求的类,类后面加括号,就是把这个类实例化

所以相当于self = StudentsView(),实例化对象,指定dispatch方法,并有返回值,就是HttpResponse,render.....(因为视图函数要么返回。。。。)

所以谁定义了dispatch,在定义的dispatch里面也有那些返回值。所以对CBV来说请求进来,执行里面的view函数可以忽略掉,直接执行dispatch。(不管什么请求进来都执行dispatch)

class StudentsView(View):
def dispatch(self, request, *args, **kwargs):
# request.method #可以获得请求方法
func = getattr(self,request.method.lower()) #去这个对象里面通过反射找到他不同的方法
ret = func(request, *args, **kwargs) #找到不同的方法可以执行一下,把它的参数都传进去。要有返回值,返回给客户
return ret
# return HttpResponse('父类的dispatch') def get(self, request, *args, **kwargs):
return HttpResponse('GET') def post(self, request, *args, **kwargs):
return HttpResponse('POST') def delete(self, request, *args, **kwargs):
return HttpResponse('DELETE') def put(self, request, *args, **kwargs):
return HttpResponse('PUT') def putch(self, request, *args, **kwargs):
return HttpResponse('PUTCH')

但是以上代码不用自己写,父类(view)的的dispatch已经写好了

 http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

CBV原理跟流程:路由----->view方法------>dispatch方法(根据反射执行其他方法,get,post,put......)。

如果自己当前类自己有dispatch方法,父类不会执行,但是如果想让父类执行dispatch方法怎么做?

class StudentsView(View):
def dispatch(self, request, *args, **kwargs):
ret = super(StudentsView,self).dispatch(request, *args, **kwargs) #父类的dispatch方法会反射不同的方式,ret就是HttpResponse(请求对象)
return ret

执行顺序是这样的,

class StudentsView(View):
print('before')
def dispatch(self, request, *args, **kwargs):
print('before')
ret = super(StudentsView,self).dispatch(request, *args, **kwargs) #父类的dispatch方法会反射不同的方式,ret就是HttpResponse(请求对象)
print('after')
return ret def get(self, request, *args, **kwargs):
return HttpResponse('GET') def post(self, request, *args, **kwargs):
return HttpResponse('POST') def delete(self, request, *args, **kwargs):
return HttpResponse('DELETE') def put(self, request, *args, **kwargs):
return HttpResponse('PUT') def putch(self, request, *args, **kwargs):
return HttpResponse('PUTCH')

所有请求来了先执行before,在执行视图函数,在执行after。--->跟装饰器相似

class StudentsView(View):def dispatch(self, request, *args, **kwargs):
print('before')
ret = super(StudentsView,self).dispatch(request, *args, **kwargs) #父类的dispatch方法会反射不同的方式,ret就是HttpResponse(请求对象)
print('after')
return ret

假如还有很多什么什么view,如果都需要先做before年最后做after,在下面写视图的时候,又得拷贝一遍。怎么办?

  写个基类,继承(多个类公用的功能,为了避免重复编写)。多继承左边优先。

class MyBaseView(object):
def dispatch(self, request, *args, **kwargs):
print('before')
ret = super(MyBaseView,self).dispatch(request, *args, **kwargs) #父类的dispatch方法会反射不同的方式,ret就是HttpResponse(请求对象)
print('after')
return ret
class StudentsView(MyBaseView,View): def get(self, request, *args, **kwargs):
     print('get方法')
return HttpResponse('GET') def post(self, request, *args, **kwargs):
return HttpResponse('POST') def delete(self, request, *args, **kwargs):
return HttpResponse('DELETE') def put(self, request, *args, **kwargs):
return HttpResponse('PUT') def putch(self, request, *args, **kwargs):
return HttpResponse('PUTCH')

super不是简单的只找父类,会根据super(MyBaseView,self)这个self对象整个的继承关系找到下一个继承对象里的方法。

Django请求生命周期:

请求进来先走wsgi--->中间件------>视图(FBV/CBV)----->如果是cbv进来走dispatch,然后反射找到试图函数返回。

Django请求生命周期(包含rest framework框架):

请求进来先走wsgi--->中间件------>视图(FBV/CBV)----->如果是cbv进来走dispatch,然后反射返回。---->重新写成Django的rest framework的dispatch了(添加了一部分功能)。

ps:dispatch

Django Rest framework 框架的更多相关文章

  1. Django REST framework框架介绍和基本使用

    Django REST framework介绍 Django REST framework是基于Django实现的一个RESTful风格API框架,能够帮助我们快速开发RESTful风格的API. 官 ...

  2. Django Rest framework 框架之认证使用和源码执行流程

    用这个框架需要先安装: pip3 install djangorestframework 如果写了一个CBV的东西,继承了View. # 继承Django里面View class APIView(Vi ...

  3. Django Rest Framework框架 ---- url控制器

    Django Rest Framework框架 ---- url控制器

  4. web前端Vue+Django rest framework 框架 生鲜电商项目实战视频教程 ☝☝☝

    web前端Vue+Django rest framework 框架 生鲜电商项目实战视频教程    web前端Vue+Django rest framework 框架 生鲜电商项目实战视频教程 学习 ...

  5. web前端Vue+Django rest framework 框架 生鲜电商项目实战✍✍✍

    web前端Vue+Django rest framework 框架 生鲜电商项目实战  整个课程都看完了,这个课程的分享可以往下看,下面有链接,之前做java开发也做了一些年头,也分享下自己看这个视频 ...

  6. Django Rest Framework框架源码流程

    在详细说django-rest-framework源码流程之前,先要知道什么是RESTFUL.REST API . RESTFUL是所有Web应用都应该遵守的架构设计指导原则. REST是Repres ...

  7. Django rest framework框架中有哪些组件

    认证 权限(授权) 用户访问次数/频率限制 版本 解析器(parser) 序列化 分页 路由系统 视图 渲染器 认证 自定义认证的类 """ from rest_fram ...

  8. Django Rest framework 框架之解析器

    解析器 序列化***** 请求数据进行校验 对queryset进行序列化处理 分页 路由 视图 渲染器

  9. Django rest framework框架——APIview源码分析

    一.什么是rest REST其实是一种组织Web服务的架构,而并不是我们想象的那样是实现Web服务的一种新的技术,更没有要求一定要使用HTTP.其目标是为了创建具有良好扩展性的分布式系统. 可用一句话 ...

随机推荐

  1. IOS解析XML文件

    这里使用NSXMLParser来解析,这个是apple自带的xml解析库,有个參考文章:http://www.raywenderlich.com/553/xml-tutorial-for-ios-ho ...

  2. SecureCRT 使用 rz命令提示waiting to receive.**B0100000023be50

    SecureCRT 远程连接Linux服务器,使用 rz命令提示waiting to receive.**B0100000023be50,或者使用sz命令提示: **B0100000023be50 解 ...

  3. 使用readAsDataURL方法预览图片

    使用FileReader接口的readAsDataURL方法实现图片的预览. 在FileReader出现之前,前端的图片预览是这样实现的:把本地图片上传到服务器,服务器把图片地址返回,并把它替换到图片 ...

  4. ZooKeeper典型应用场景概览

    ZooKeeper是一个高可用的分布式数据管理与系统协调框架.基于对Paxos算法的实现,使该框架保证了分布式环境中数据的强一致性,也正是基于这样的特性,使得ZooKeeper解决很多分布式问题.网上 ...

  5. windows 增加右键功能 -->用命令行打开

    windows 增加右键功能 -->用命令行打开 实现 注册表 以管理员权限CMD 到指定文件夹 Windows Registry Editor Version 5.00 [HKEY_CLASS ...

  6. php 依赖注入的实现

    当A类需要依赖于B类,也就是说需要在A类中实例化B类的对象来使用时候,如果B类中的功能发生改变,也会导致A类中使用B类的地方也要跟着修改,导致A类与B类高耦合.这个时候解决方式是,A类应该去依赖B类的 ...

  7. 七、Oracle 数据库设计

    1. 原始单据与实体之间的关系 可以是一对一.一对多.多对多的关系.在一般情况下,它们是一对一的关系:即一张原始单据对应且只对应一个实体. 在特殊情况下,它们可能是一对多或多对一的关系,即一张原始单证 ...

  8. ENQ: KO - FAST OBJECT CHECKPOINT tips

    ENQ: KO - FAST OBJECT CHECKPOINT tips Question: What does the wait event ENQ: KO - FAST OBJECT CHECK ...

  9. jacoco+ant安装部署篇(统计代码覆盖率,适用自动化测试)

    1:什么是jacoco? JaCoCo是一个开源的覆盖率工具(官网地址:http://www.eclemma.org/JaCoCo/),它针对的开发语言是java,其使用方法很灵活,可以嵌入到Ant. ...

  10. 论文笔记---Deblurring Shaken and Partially Saturated Images

    抖动和部分饱和图像去模糊 摘要 我们解决了由相机抖动造成的模糊和饱和或过度曝光像素导致的图像去模糊的问题.饱和像素对于现有的非盲去模糊算法是一个问题,因为它们不符合图像形成过程是线性的这一假设,并且经 ...