Django Rest framework 框架

一、开发模式：　　

　　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就写完了。以不同的方式来执行，就会有不同的函数自动帮你执行了。

四、列表生成式　

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是关键字，表示类
创建对象，类名称后加括号即可

面向对象三大特性

一、封装

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

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

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

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

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

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

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

 1 class Foo:
 2  
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6  
 7 obj1 = Foo('wupeiqi', 18)
 8 print obj1.name    # 直接调用obj1对象的name属性
 9 print obj1.age     # 直接调用obj1对象的age属性
10  
11 obj2 = Foo('alex', 73)
12 print obj2.name    # 直接调用obj2对象的name属性
13 print obj2.age     # 直接调用obj2对象的age属性

View Code

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

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

 1 class Foo:
 2   
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6   
 7     def detail(self):
 8         print self.name
 9         print self.age
10   
11 obj1 = Foo('wupeiqi', 18)
12 obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
13   
14 obj2 = Foo('alex', 73)
15 obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

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

Django Rest framework 框架

面向对象三大特性

猜你喜欢