Django一页通-续

视图函数，View

FBV - function based view

CBV - class based view

views.py

class MyView(View):
    # 默认支持options方法，作用是查询当前框架支持哪些请求方法。
    # 最多支持这些方法：get、post、put、patch、delete、head、options、trace
    # 其他7种方法需要手写

    info=None # urls.py路由中的参数要提前在类中定义

    # 支持get就支持head
    def get(self,request):
        return HttpResponse(f'get方法，{self.info}')

    def post(self,request):
        # 需要注释掉settings中的csrf中间件代码
        return HttpResponse('post方法')

    def put(self,request):
        return HttpResponse('put方法')

    def patch(self,request):
        return HttpResponse('patch方法')

    def delete(self,request):
        return HttpResponse('delete方法')

    def head(self,request):
        # head方法只传头信息，这些消息体收不到。
        return HttpResponse('head方法，自定义，不用get的方法')

    # def options(self,request):
    #     return HttpResponse('自定义options方法')

    # postman里无trace方法
    def trace(self,request):
        return HttpResponse('trace方法')

    # Django中不支持copy方法
    def copy(self,request):
        return HttpResponse('postman里有的copy方法')

urls.py

    # 相同路由，写在前面的有效，后面的不起作用。
    path('myview/',views.MyView.as_view()), # 类中定义的参数路由中也可以不传，但不能传未定义的参数。
    path('myview/',views.MyView.as_view(info='今天是个好天气')), # 传参必须提前在类为定义

用类视图实现登录

views.py

class Login(View):
    def get(self,request):
        return render(request,'login.html',locals())

    def post(self,request):
        username=request.POST.get('username')
        password=request.POST.get('password')
        return HttpResponse(f'登录成功，用户名：{username}，密码：{password}')

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
<form action="/myapp/login/" method="post">
    {% csrf_token %}
    <input type="text" placeholder="请输入账号" name="username">
    <input type="password" placeholder="请输入密码" name="password">
    <button>登录</button>
</form>
</body>
</html>

urls.py path('login/',views.Login.as_view()),

TemplateView，以下演示代码只能get请求

使用方式一

views.py

class Login(TemplateView):
    template_name = 'login.html'

urls.py path('login/',views.Login.as_view()),

使用方式二

views.py

class Login(TemplateView):
    pass

urls.py path('login/',views.Login.as_view(template_name='login.html')),

ListView

models.py

class Notice(models.Model):
    info=models.CharField(max_length=16)

urls.py path('notice/',views.List.as_view()),

方式一：

view.py

class List(ListView):
    template_name = 'notice.html'
    model = Notice

notice.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>列表清单</title>
</head>
<body>
    <ul>
        {% for notice in notice_list %} {# 写法一 #}
            <li>{{ notice.info }}</li>
        {% endfor %}
    </ul>
</body>
</html>

方式二：

views.py

class List(ListView):
    model = Notice

/mypro/templates/myapp/notice_list.html 自动获取的命名规范：模板目录/应用名/模型名小写_list.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>自动获取列表</title>
</head>
<body>
    <ul>
        {% for notice in object_list %} {# 写法二 #}
            <li>{{ notice.info }}</li>
        {% endfor %}
    </ul>
</body>
</html>

静态资源

mypro/static/home.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
    静态资源
    {# 和模板html的区别：不支持模板语法 #}
</body>
</html>

配置settings.py

STATICFILES_DIRS=[
    os.path.join(BASE_DIR,'static')
]

然后可直接在浏览器访问：http://127.0.0.1:8000/static/home.html

静态资源，css举例：

urls.py path('home/',views.home),

views.py

def home(request):
    return render(request,'home.html')

settings.py

STATICFILES_DIRS=[
    os.path.join(BASE_DIR,'static')
]

mypro/static/css/home.css

h1{
    background-color: red;
}

mypro/templates/home.html ，html模板中含有模板语法，只能放到templates目录中，用视图函数或视图类方法调用。

{% load static %} {# 写法二：相对路径 #}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
    {# 写法一：绝对路径 #}
<!--    <link rel="stylesheet" href="/static/css/home.css">-->
    {# 写法二：相对路径 #}
    <link rel="stylesheet" href="{% static 'css/home.css' %}">
</head>
<body>
<h1>静态资源</h1>
    {# 和模板html的区别：不支持模板语法 #}
</body>
</html>

面向切面编程，AOP，aspect oriented programming

红色加粗为可切入点：

浏览器 -> process_request -> urls路由 -> process_view views视图函数/类方法 -> process_template_response -> templates -> process_response -> 浏览器

其中：views -> models -> views -> templates 不可切。

mypro/middleware/myMiddleware.py

from django.http import HttpResponse
from django.utils.deprecation import MiddlewareMixin


class MyMiddleware(MiddlewareMixin):
    def process_request(self,request):
        print('process_request：在执行视图前被调用，每个请求都会调用，不主动返回或返回HttpResponse对象')

    def process_view(self,request,view_func,view_args,view_kwargs):
        print('process_view：在执行视图前被调用，每个请求都会调用，不主动返回或返回HttpResponse对象')

    def process_template_response(self,request,response):
        # 实验无效果，未打印如下信息
        print('在执行完视图后调用，每个请求都会调用，不主动返回或返回HttpResponse对象')

    # def process_response(self,request,response):
        # 实验异常，浏览器显示：A server error occurred.  Please contact the administrator.
        # print('响应浏览器前调用，每个请求都会调用，不主动返回或返回HttpResponse对象')

    def process_exception(self,request,response):
        print('视图异常时调用，不主动返回或返回HttpResponse对象')
        return HttpResponse('视图异常时的返回')

settings.py

MIDDLEWARE = [
    'middleware.myMiddleware.MyMiddleware',
    ……    
]

AOP应用，频率控制

mypro/middleware/myMiddleware.py

from time import time
from django.http import HttpResponse
from django.utils.deprecation import MiddlewareMixin
from myapp.models import AccessLog

class MyMiddleware(MiddlewareMixin):
    def process_request(self,request):
        ip=request.META.get('REMOTE_ADDR')
        accessLogs=AccessLog.objects.filter(ip=ip)if request.path=='/myapp/home/':
            if accessLogs.exists():
                accessLog=accessLogs.last()
                if time()-accessLog.time<=10:
                    return HttpResponse('访问频繁，请10秒后再访问。')
            else:
                accessLog=AccessLog()
                accessLog.ip=ip
            accessLog.time=time()
            accessLog.save()

models.py

class AccessLog(models.Model):
    ip=models.CharField(max_length=16)
    time=models.FloatField()

文件上传，方式一：此方式上传同名文件到同一个目录会直接覆盖，应用场景：修改用户图像，直接将用户图像上传到同户图像目录，每次修改直接覆盖前一个。

views.py

class Upload(TemplateView):
    template_name = 'upload.html' # 写了此行后就默认支持get请求
    def post(self,request):
        # <MultiValueDict: {'mypic': [<InMemoryUploadedFile: 我的图片.png (image/png)>], 'myexcel': [<InMemoryUploadedFile: 我的表格.xlsx (application/vnd.openxmlformats-officedocument.spreadsheetml.sheet)>]}>
        print('request.FILES=',request.FILES)
        
        mypic=request.FILES.get('mypic')
        print('mypic=',mypic) # 显示【文件名】，实际为一个文件对象
        print('type(mypic)=',type(mypic)) # <class 'django.core.files.uploadedfile.InMemoryUploadedFile'>，多个文件为<class 'NoneType'>

        myexcel=request.FILES.get('myexcel')
        print(type(myexcel)) # <class 'django.core.files.uploadedfile.InMemoryUploadedFile'>
        print(myexcel) # 显示【文件名】，实际为一个文件对象
        print(myexcel.name) # 真正的文件名
        print(type(myexcel.name)) # <class 'str'>

        pic_path=os.path.join(BASE_DIR,f'static/pics/{mypic.name}')
        excel_path=os.path.join(BASE_DIR,f'static/excels/{myexcel.name}')

        with open(pic_path,'wb') as f:
            for part in mypic.chunks():
                f.write(part)
                f.flush()

        with open(excel_path,'wb') as f:
            for part in myexcel.chunks():
                f.write(part)
                f.flush()

        return HttpResponse(f'上传成功：{request.FILES}')

upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上传文件</title>
</head>
<body>
<form action="/myapp/upload/" method="post" enctype="multipart/form-data">
    {% csrf_token %}
    <input type="file" name="mypic"> {# 一定要写name，否则上传不了 #}
    <input type="file" name="myexcel">
    <button>上传</button>
</form>
</body>
</html>

urls.py path('upload/',views.Upload.as_view()),

文件上传，方式二

models.py

class Files(models.Model):
    # 上传图片在生成迁移文件时会提示安装Pillow包，提示中有安装方式
    # 存储的是相对于媒体中心的相对位置路径，同名文件会自动加随机串
    pic=models.ImageField(upload_to='pics/%Y/%m/%d') # 以年月日建子目录
    excel=models.FileField(upload_to='excels/%H/%M/%S') # 以时分秒建子目录

views.py

class Upload(TemplateView):
    template_name = 'upload.html' # 写了此行后就默认支持get请求
    def post(self,request):
        mypic=request.FILES.get('mypic')
        myexcel=request.FILES.get('myexcel')
        files=Files()
        files.pic=mypic
        files.excel=myexcel
        files.save()
        return HttpResponse(f'上传成功：{mypic.name}、{myexcel.name}')

urls.py path('upload/',views.Upload.as_view()),

settings.py MEDIA_ROOT=os.path.join(BASE_DIR,'static/uploadedFiles') 媒体中心。

获取图片

urls.py path('getfiles/',views.getfiles)

settings.py MEDIA_URL_PREFIX='/static/uploadedFiles/'

displayPic.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>显示图片</title>
</head>
<body>
<img src="{{ picurl }}" alt="我的图片">
</body>
</html>

views.py

def getfiles(request):
    files=Files.objects.last()
    print('类型=',type(files.pic)) # <class 'django.db.models.fields.files.ImageFieldFile'>
    print(files.pic) # 显示的是表中存储的相对媒体中心的路径，实际是文件对象
    print(files.pic.path) # 文件在工程项目主机上的绝对路径
    print(files.pic.url) # 相对媒体中心的相对路径，即网络路径
    print(files.pic.size) # 文件大小，单位字节

    # picurl=os.path.join(BASE_DIR,'static/uploadedFiles',files.pic.url) # 错误写法，本地绝对路径
    # picurl=os.path.join(BASE_DIR,'static/uploadedFiles','pics/x.png') # 错误写法，本地绝对路径
    # picurl='static/uploadedFiles/pics/x.png' # 错误写法，相对路径
    picurl=MEDIA_URL_PREFIX+files.pic.url # 正确写法，网络路径
    print('picurl=',picurl) # /static/uploadedFiles/pics/%E6%88%91%E7%9A%84%E5%9B%BE%E7%89%87_ytvTw5m.png
    # return HttpResponse(f'获取文件成功：{files.pic}，{files.excel}')
    return render(request,'displayPic.html',locals())

生成验证码

urls.py path('generateVerifyCode/',views.generateVerifyCode),

views.py

def generateVerifyCode(request):
    # 需要安装Pillow
    image=Image.new('RGB',(70,40),(100,200,250)) # 画布，RGB必须大写
    draw=ImageDraw.Draw(image,'RGB') # 画笔，RGB必须大写

    font=ImageFont.truetype(os.path.join(BASE_DIR,'static/fonts/SIMLI.TTF'),30)
    # font=ImageFont.truetype(os.path.join(BASE_DIR,'static/fonts/STCAIYUN.TTF'),30)
    # font=ImageFont.truetype(os.path.join(BASE_DIR,'static/fonts/STXINGKA.TTF'),30)

    draw.text((5,5),'ABCD',font=font,fill=(200,0,0)) # 绘制

    buffer=BytesIO() # from io import BytesIO
    image.save(buffer,'png')
    verifyCode=buffer.getvalue()
    return HttpResponse(verifyCode,content_type='image/png')

随机生成并获取验证码

urls.py path('login/',views.login),

static/js/login.js

$(function () {
    var verifyImg=$("#verifyImg");
    verifyImg.click(function () {
        console.log('获取验证码')
        verifyImg.attr("src","/myapp/generateVerifyCode/?t="+Math.random())
    })
})

{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
    {# 此jquery脚本不能少，否则js脚本运行异常 #}
    <script type="text/javascript" src="https://cdn.bootcss.com/jquery/1.11.1/jquery.js"></script>
    <script type="text/javascript" src="{% static 'js/login.js' %}"></script>
</head>
<body>
<form action="/myapp/login/" method="post">
    {% csrf_token %}
    <input type="text" placeholder="请输入账号" name="username">
    <input type="password" placeholder="请输入密码" name="password">
    <input type="text" name="verifyCode" placeholder="请输入验证码">
    <img src="/myapp/generateVerifyCode/" id="verifyImg">
    <button>登录</button>
</form>
</body>
</html>

views.py

def generateVerifyCode(request):
    # 需要安装Pillow
    image=Image.new('RGB',(100,50),getColor()) # 画布，RGB必须大写
    draw=ImageDraw.Draw(image,'RGB') # 画笔，RGB必须大写

    font=ImageFont.truetype(os.path.join(BASE_DIR,'static/fonts/SIMLI.TTF'),30)
    verifyStr='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    verifyCode=''
    for i in range(4):
        char=random.choice(verifyStr)
        verifyCode+=char
        x=random.randrange(10)+25*i
        draw.text((x,random.randrange(15)),char,font=font,fill=getColor()) # 绘制

    for i in range(100):
        draw.point((random.randrange(100),random.randrange(50)),fill=getColor())

    request.session['verifyCode']=verifyCode

    buffer=BytesIO() # from io import BytesIO
    image.save(buffer,'png')
    verifyCode=buffer.getvalue()
    return HttpResponse(verifyCode,content_type='image/png')

def getColor():
    red=random.randrange(256)
    green=random.randrange(256)
    blue=random.randrange(256)
    return red,green,blue

def login(request):
    if request.method=='GET':
        return render(request,'login.html')
    elif request.method=='POST':
        verifyCode=request.POST.get('verifyCode')
        username=request.POST.get('username')
        password=request.POST.get('password')
        verifyCodeSrc=request.session.get('verifyCode')
        if verifyCode.lower()!=verifyCodeSrc.lower():
            return HttpResponse('验证码错误')
        return HttpResponse('验证码正确')

富文本，RTF，Rich Text Format

pip install django-tinymce

settings.py

INSTALLED_APPS = [
    ……
    'tinymce',
]

TINYMCE_DEFAULT_CONFIG={
    'theme':'advanced',
    'width':'800',
    'height':'600',
}

站点管理

创建超级用户，终端输入： python manage.py createsuperuser 然后根据提示输入用户名、邮箱、密码等等。登录http://127.0.0.1:8000/admin/看效果。

在应用的admin.py中注册：

from myapp.models import Person

admin.site.register(Person) # 关键代码

登录http://127.0.0.1:8000/admin/看效果。

修改后台表（模型）默认展示信息：

class Person(models.Model):
    # 关键代码
    def __str__(self):
        return self.name
    ……

shell用法

命令：

(venv) D:桌面mypro>python manage.py shell
Python 3.8.2 (tags/v3.8.2:7b3ab59, Feb 25 2020, 23:03:10) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from myapp.models import Person
>>> person=Person()
>>> person.name='后台添加的人'
>>> person.save()

站点管理：自定义管理类

models.py

class Person(models.Model):
    def __str__(self):
        return self.name

    # verbose_name为自定义后台管理页面显示的字段（列或属性）
    name = models.CharField(max_length=32,verbose_name='姓名')
    age=models.IntegerField(default=18,verbose_name='年龄')
    sex=models.NullBooleanField(default=False,verbose_name='性别')
    info=models.TextField(default='',verbose_name='个人信息')
    isStudent=models.BooleanField(default=False,verbose_name='是否学生')
    birth=models.DateTimeField(auto_now=True,verbose_name='生日')

admin.py

from django.contrib import admin

# Register your models here.
from myapp.models import Person

# 创建管理类
class PersonAdmin(admin.ModelAdmin):
    def gender(self):
        if self.sex:
            return '男'
        elif self.sex==False:
            return '女'
        else:
            return '保密'

    gender.short_description = '性别'

    # 显示规则
    # 显示字段
    list_display = 'name','age',gender,'info','isStudent','birth'
    # 过滤字段，不能像显示字段那样使用方法名，如gender
    list_filter = 'info','isStudent'
    # 搜索字段
    search_fields = 'name','age','sex'
    # 分页，默认每页100条数据
    list_per_page = 10
    # 排序 ordering
    ordering = 'name','age','sex','info','isStudent','birth'
    # 分组，不可编辑字段不能添加到分组，如birth自动取添加时的日期
    fieldsets=(
        ('基本信息',{'fields':('name','age','sex')}),
        ('其他信息',{'fields':('info','isStudent')}),
    )

    # 修改规则：fields显示的字段，exclude不显示的字段。

# 注册管理类
admin.site.register(Person,PersonAdmin)

站点管理，外键约束，设置新增主表一条记录，必须同时新增n条从表记录

models.py

from django.db import models

class Company(models.Model):
    name=models.CharField(max_length=16,verbose_name='公司名')

class Employee(models.Model):
    name=models.CharField(max_length=16,verbose_name='员工名')
    company=models.ForeignKey(Company,null=True,on_delete=models.SET_NULL)

admin.py

from django.contrib import admin

from myapp.models import Company, Employee

class EmployeeInfo(admin.TabularInline):
    model = Employee
    extra = 1 # 新增公司时至少附带新增一个员工

class CompanyAdmin(admin.ModelAdmin):
    inlines = [EmployeeInfo]

admin.site.register(Company,CompanyAdmin)
admin.site.register(Employee)

站点管理，修改登录界面样式、文字、颜色等

在templates模板目录中创建admin目录

复制Libsite-packagesdjangocontribadmin emplatesadminlogin.html到mypro/templates/admin/目录中，并修改为：

{% extends 'admin/login.html' %}

{% load static %}

{# 修改字体颜色 #}
{% block extrastyle %}
  {{ block.super }}
  <link rel="stylesheet" href="{% static 'css/login.css' %}">
{% endblock %}

{# 修改登录框标题 #}
{% block branding %}
<h1 id="site_name"><a href="" id="site_name_color">我的后台管理</a></h1>
{% endblock %}

mypro/static/css/login.css

#site_name_color{
    color:red !important;
}

自定义站点管理

mypro/myapp/admin.py

from django.contrib import admin

from myapp.models import Company, Employee

class EmployeeInfo(admin.TabularInline):
    model = Employee
    extra = 1 # 新增公司时至少附带新增一个员工

class CompanyAdmin(admin.ModelAdmin):
    inlines = [EmployeeInfo]

# admin.site.register(Company,CompanyAdmin)
# admin.site.register(Employee)

class MySite(admin.AdminSite):
    site_header = '我的自定义站点' # 登录后的头部标题，非浏览器标题
    site_title = '浏览器标题'
    site_url = 'http://sogo.com' # 默认http://127.0.0.1:8000/即/

site=MySite()
site.register(Company,CompanyAdmin)
site.register(Employee)

mypro/urls.py

from django.contrib import admin
from django.urls import path, include

from myapp.admin import site

urlpatterns = [
    # path('admin/', admin.site.urls),
    path('admin/',site.urls),
]

可网上搜其他站点界面插件，更改默认站点管理UI界面样式。

缓存

views.py

from time import sleep
from django.http import HttpResponse
from django.views.decorators.cache import cache_page

@cache_page(30) # 缓存保留多长时间，根据具体业务需求设置
def hi(request):
    sleep(5) # 模拟复杂的业务逻辑，第1次访问需要5秒才能显示页面，从第2次开始，30秒内再次访问秒显页面。
    return HttpResponse('hi')

密码加密、校验：make_password()、verify_password()

debug-toolbar

安装： pip install django-debug-toolbar

配置：

settings.py

INSTALLED_APPS = [
    ……
    'django.contrib.staticfiles',
    'debug_toolbar',
]

MIDDLEWARE = [
    'debug_toolbar.middleware.DebugToolbarMiddleware', # 置于首行
     ……
]

INTERNAL_IPS=[
    '127.0.0.1',
    # ……
]

mypro/mypro/urls.py

import debug_toolbar

urlpatterns = [
    ……
    path('__debug__/',include(debug_toolbar.urls)),
]

注：只对有模板渲染的页面有效。

发送邮件

配置settings.py

# 不加密，默认端口
EMAIL_HOST='smtp.qq.com'
EMAIL_HOST_USER='1*********0@qq.com'
EMAIL_HOST_PASSWORD='s**************e' # 授权码

views.py

from django.http import HttpResponse
from django.core.mail import send_mail

def send_email(request):
    send_mail('邮件主题','邮件内容','1******0@qq.com',['1*********0@qq.com'])
    return HttpResponse('发送成功')

配置settings.py 加密

# 加密
EMAIL_HOST='smtp.qq.com'
EMAIL_PORT=465
EMAIL_HOST_USER='1*********0@qq.com'
EMAIL_HOST_PASSWORD='s**************e'
EMAIL_USE_SSL=True

RESTfull Framework pip install djangorestframework

mypro/myapp/serializers.py

# https://www.django-rest-framework.org/tutorial/quickstart/
from django.contrib.auth.models import User, Group
from rest_framework import serializers


class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model=User
        fields=['url','username','email','groups']

class GroupSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model=Group
        fields=['url','name']

views.py

from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from myapp.serializers import UserSerializer, GroupSerializer


class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

class GroupViewSet(viewsets.ModelViewSet):
    queryset = Group.objects.all()
    serializer_class = GroupSerializer

settings.py

INSTALLED_APPS = [
    ……
    'rest_framework',
]

mypro/myapp/urls.py

from rest_framework import routers
from myapp.views import UserViewSet, GroupViewSet

router=routers.DefaultRouter()
router.register('users',UserViewSet)
router.register('groups',GroupViewSet)

mypro/mypro/urls.py

……
from myapp.urls import router

urlpatterns = [
    path('',include(router.urls)),
    ……
]

RESTfull Framework 简明示例二

models.py

class Person(models.Model):
    name=models.CharField(max_length=16)
    age=models.IntegerField(default=18)

serializers.py

class PersonSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model=Person
        fields=('url','name','age')

views.py

class PersonViewSet(viewsets.ModelViewSet):
    queryset = Person.objects.all()
    serializer_class = PersonSerializer

urls.py

router=routers.DefaultRouter()
router.register('persons',PersonViewSet)

mypro/mypro/urls.py

urlpatterns = [
    path('',include(router.urls)),
    ……
]

请求方法PUT必提供全量更新属性值，除非有该字段有默认值。请求url如http://127.0.0.1:8000/persons/2/

请求方法PATCH差量更新某个或某些属性值。请求url如http://127.0.0.1:8000/persons/2/

请求方法POST新增一条记录。请求url如http://127.0.0.1:8000/persons/

请求方法DELETE删除一条记录。请求url如http://127.0.0.1:8000/persons/2/

Serializer

models.py

LANGS=[(0,'Python'),(1,'易语言')]

class Person(models.Model):
    name=models.CharField(max_length=16)
    age=models.IntegerField(default=18)
    lang=models.CharField(choices=LANGS,default='Python',max_length=16)

serializers.py

class PersonSerializer(serializers.Serializer):
    id=serializers.IntegerField(read_only=True)
    name=serializers.CharField(max_length=16)
    age=serializers.IntegerField(default=18)
    lang = serializers.CharField(default='Python', max_length=16)

    def create(self, validated_data):
        return Person.objects.create(**validated_data)

    def update(self, instance, validated_data):
        instance.name=validated_data.get('name',instance.name)
        instance.age=validated_data.get('age',instance.age)
        instance.lang=validated_data.get('lang') or instance.lang
        instance.save()
        return instance

实际开发常用方式

# 用此方式若不带'url'也可以直接访问，
# 若带'url'则需在views函数中带context={'request':request}，
# serializer=PersonSerializer(persons,many=True,context={'request':request})
# 且需要要配好单个模型的获取方式，实际开发中用的少。
# class PersonSerializer(serializers.HyperlinkedModelSerializer):

# 实际开发中用此方式最多
class PersonSerializer(serializers.ModelSerializer):
    class Meta:
        model=Person
        fields=('id','name','age','lang')

views.py

def get_person(request):
    person=Person.objects.first()
    serializer=PersonSerializer(person)
    return JsonResponse(serializer.data)

或

def get_person(request):
    person=Person.objects.first()
    serializer=PersonSerializer(person)
    data={
        'msg':'ok',
        'status':0,
        'data':serializer.data
    }
    return JsonResponse(data)

urls.py

urlpatterns = [
    path('getperson/',views.get_person),
]

mypro/mypro/urls.py

urlpatterns = [
    path('myapp/',include('myapp.urls')),
]

增

views.py

def add_person(request):
    # 注释掉settings.py中的csrf中间件，在Postman中直接调接口添加Person
    name=request.POST.get('name')
    age=request.POST.get('age')
    lang=request.POST.get('lang')

    person=Person()
    person.name=name
    person.age=age
    person.lang=lang
    person.save()

    serializer=PersonSerializer(person)

    data={
        'msg':'ok',
        'status':0,
        'data':serializer.data
    }
    return JsonResponse(data)

或

def add_person(request):
    # 注释掉settings.py中的csrf中间件，在Postman中直接调接口添加Person
    name=request.POST.get('name')
    age=request.POST.get('age')
    lang=request.POST.get('lang')

    person_data={
        'name':name,
        'age':age, # 或 'status':status.HTTP_201_CREATED,
        'lang':lang,
    }
    serializer=PersonSerializer(data=person_data)
    if not serializer.is_valid():
        return JsonResponse(serializer.errors)
    serializer.save() # 调用save前必须先调用is_valid()

    data={
        'msg':'ok',
        'status':0,
        'data':serializer.data
    }
    return JsonResponse(data)

urls.py

urlpatterns = [
    path('addperson/',views.add_person),
    path('getperson/',views.get_person),
    ……

查询多个记录

views.py

def get_persons(request):
    persons=Person.objects.all()
    serializer=PersonSerializer(persons,many=True) # 对集合序列化必须指明many=True

    data = {
        'msg': 'ok',
        'status': 0,
        'data': serializer.data
    }
    return JsonResponse(data)

urls.py

urlpatterns = [
    path('getpersons/',views.get_persons),
    path('addperson/',views.add_person),
    path('getperson/',views.get_person),
    ……

api_view装饰器

views.py

@api_view(['GET','POST','PUT','PATCH']) # 加api_view装饰器后只能以指定的请求方式访问，若不加则可以以任何方式访问。
def index(request):
    print(request)
    print(type(request))
    print(request.data) # 通过装饰器@api_view能获取PATCH请求参数
    # return HttpResponse('index')
    return Response('index') # 自动根据请求客户端Accept决定响应Content-Type内容形式

urls.py

urlpatterns = [
    path('index/',views.index),
]

APIView

views.py

class HelloAPIView(APIView):
    def get(self,request):
        data={
            'msg':'ok'
        }
        # return Response(data)
        raise APIException(detail='待需求澄清')

urls.py

urlpatterns = [
    path('hello/',views.HelloAPIView.as_view()),
]

处理多个记录：

views.py

class PersonsAPIView(APIView):
    def get(self,request):
        persons=Person.objects.all()
        serializer=PersonSerializer(persons,many=True)
        return Response(serializer.data)

    def post(self,request):
        name=request.data.get('name')
        age=request.data.get('age') # 不写就可以用模型定义的默认值，写了就必须传。

        person_data={
            'name':name,
            'age':age,
        }

        serializer=PersonSerializer(data=person_data)
        if not serializer.is_valid():
            return Response(serializer.errors)
        serializer.save()
        return Response(serializer.data)

urls.py

urlpatterns = [
    path('persons/',views.PersonsAPIView.as_view()),
]

处理单个记录：

views.py

class PersonAPIView(APIView):
    def get_person(self,id):
        try:
            person=Person.objects.get(pk=id)
            return person
        except Exception as e:
            raise exceptions.NotFound

    def get(self,request,id):
        person=self.get_person(id)
        print('person的类型：',type(person))
        serializer=PersonSerializer(person)
        print('serializer.data的类型：',type(serializer.data)) # dict的子类
        return Response(serializer.data) # Response接收一个字典或字典的子类

    def put(self,request,id):
        pass

    def patch(self,request,id):
        pass

    def delete(self,request,id):
        person=self.get_person(id)
        person.delete()
        data={
            'msg':'删除成功',
            'status':status.HTTP_204_NO_CONTENT
        }
        return Response(data)

urls.py

urlpatterns = [
    path('persons/<int:id>/',views.PersonAPIView.as_view()), # 建议遵守规范用复数persons
]

GenericAPIView

models.py

class Blog(models.Model):
    title=models.CharField(max_length=16)
    content=models.CharField(max_length=256)

serializers.py

class BlogSerializer(serializers.ModelSerializer):
    class Meta:
        model=Blog
        fields=('id','title','content')

views.py

class BlogsAPIView(GenericAPIView):
    queryset=Blog.objects.all()
    serializer_class=BlogSerializer

    def get(self,request):
        queryset=self.get_queryset()
        serializer=self.get_serializer(queryset,many=True)
        return Response(serializer.data)

    def post(self,request):
        serializer=self.get_serializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors)

class BlogAPIView(GenericAPIView):
    # queryset=Blog.objects.all()
    # serializer_class=BlogSerializer

    def get_blog(self, id):
        try:
            blog = Blog.objects.get(pk=id)
            return blog
        except Exception as e:
            raise exceptions.NotFound

    def get(self, request, id):
        blog = self.get_blog(id)
        serializer = BlogSerializer(blog)
        return Response(serializer.data)  # Response接收一个字典或字典的子类

    def put(self, request, id):
        pass

    def patch(self, request, id):
        pass

    def delete(self, request, id):
        blog = self.get_blog(id)
        blog.delete()
        data = {
            'msg': '删除成功',
            'status': status.HTTP_204_NO_CONTENT
        }
        return Response(data)

urls.py

urlpatterns = [
    path('blogs/<int:id>/',views.BlogAPIView.as_view()),
    path('blogs/',views.BlogsAPIView.as_view()),
]