Catherine 成长记第四篇

小白成长记第四篇

创建项目:
第一步：创建一个Django项目命令如下:django-admin startproject 文件名
第二步：启动django命令如下：python manage.py runserver
第三步：找到http://127.0.0.1:8000/打开
第四步：创建一个Django项目的应用命令如下:django-admin startapp 文件名

FBV 函数视图
CBV 类视图

一、路由中携带数据
二、视图的写法
1、FBV Function Base View
函数视图处理请求
2、CBV Class Base View
视图类处理请求
三、获取 请求传递来的数据
1、浏览器 地址栏 传参
如果要在浏览器中 进行GET方式传参
http://127.0.0.1:8000/login1?username=Tom&password=123
​
解释:
GET传参 要用?开始 key=value是基本格式 多个 key=value用&符合隔开
​
2、视图函数/类中获取 GET方式传递来的参数

获取传递来的username参数的值 第二个"" 表示如果GET请求中没有username参数 则返回默认值，这里为空

username = request.GET.get(“username”, “”)
​

获取传递来的password参数的值

password = request.GET.get(“password”, “”)

1.HTTP 超文本传输协议

2.怎么将字典列表转换为字符串类型展示在页面，例如：
import json
json.dumps(变量名,ensure_ascii=False)

代码实现:
import json
book={“name”:“林木”,“age”:18,“sex”:“男”}
s=json.dumps(book,ensure_ascii=False)
return HttpResponse(s)
第二种
return JsonResponse(变量名,safe=False,json_dumps_params={“ensure_ascii”:False})
#返回字典列表使用JsonResponse，safe代表是否安全

3. CBV(类视图)增删改查
   post 增
   get 查询
   put 更新
   delete 删除

4、常见的响应状态码
200 成功ok
404 page Not Found 我们的地址路径和urls中的不一致，找不到
405 Method Not Allowed 方法不允许，这个访问方式，没有对应的处理方法
403 是CSRF的验证问题，解决办法 在settings中 中间件MIDDLEWARES中 注释 CSRF中间件
500 Internal Server Error 服务端出错，也就是django代码出现了异常

一、QueryDict
QueryDict查询字典，封装我们的请求数据
request或request.POST ，获取的对象就是 QueryDict

二、POST对象
request.POST 在POST方法请求下有效，在GET方法请求是无效的。
也就是说request.POST 要用到post方法中

三、GET对象
request.GET在任何请求中都有效，也就是说在任何的试图处理方法中都可以使用

四、VSCode 安装 插件
1、安装 中文汉化包
Chinese
2、安装 Vue的扩展包
Vetur
Vue 2 Snippets
Beautify

五、Vue 指令
v-if
v-else
v-for
v-on
v-bind
v-model
v-show
v-html

六、axios
axios 是用来 在浏览器端 发送 网络请求 的工具 JavaScript 进行网络访问的模块
npm install --save axios
​
#解释
–save意思 表示 保存到 生成环境依赖中
axios 可以使用 get post 等方法 发起网络请求
如果网络请求成功，使用then函数来接收这个响应
如果网络请求失败，使用catch函数来抓捕这个异常响应
axios.get(“http://127.0.0.1:8000/login”).then((resp)=>{
console.log(this.name)
}).catch((error)=>{
console.log(error)
})

箭头函数： 没有自己的作用域空间，使用父级的 域空间 也就是说 在箭头函数中 使用this 表示的是父级的this，也就是 vue组件。
以后 都是要箭头函数来 写 内部函数。

七、跨域
解决方案的办法， 一种是 前端跨域 一种是 后端跨域
后端跨域
先下载一个模块
pip install django-cors-headers

执行后端跨域三步骤：
第一步：
INSTALLED_APPS = [
…
‘corsheaders’,
…
]
第二步：
MIDDLEWARE = [
…
‘corsheaders.middleware.CorsMiddleware’,
‘django.middleware.common.CommonMiddleware’,
…
]
第三步：
CORS_ORIGIN_ALLOW_ALL=True

八，在vue网页中，登录注册，然后在django项目中，接收参网页中传入的参数。
格式：
vue （配置路由）
账号：
密码：

import axios from ‘axios’
data(){
return{
绑定的变量1：’ ‘,
绑定的变量2：’ ’
}
},
methods:{
绑定的方法(){
axios.get( ‘django项目的网址?路由传参的变量1=’+this.绑定变量1+‘&路由传参的变量2
=’+this.绑定的变量2 ).then((变量)=>{ console.log(this.绑定的变量1，this.绑定的变量2)
}).catch(( 变量 )=>{ console.log(‘如果连接失败后输出的内容’) })
}
}

django （配置路由）
def 变量（request）：
a = request.GET.get(‘路由传参的变量1’，’ ‘)
b = request.GET.get(’‘路由传参的变量2’，’ ‘)
print（a，b）
return HttpResponse(‘网页输出的内容’)

一、拦截器的简介和使用
为了防止用户在知道组件名称的情况下，没有登录而直接进入相应的页
面下，所以要为路由设置一个拦截器，来鉴定用户的权限。
路由导航守卫
概念：导航守卫主要用来通过跳转或取消的方式守卫导航
作用：我们可以通过路由拦截，来判断用户是否登录，该页面用户是否
有权限浏览
router.beforeEach((to,from,next)=>{
// 1 判断当前路由是不是/login 如果是直接放行
if(to.path==’/login’) return next();
// 2 判断当前路由不是/login,那么就获取他的token
const token = sessionStorage.getItem(‘token’);
// 3 如果token 不存在，强制跳回 /login
if(!token) return next(’/login’);
// 4 如果token 存在。则继续放行
next();
})

名词解释 :
to 是从哪里来
from 去哪里
next() 代表放行
next(’/login’) 强制跳回login页面

请求拦截器
概念：对请求的数据添加一些我们想给后端传递的数据并且一般的这种
数据我们会放在请求头中。
作用：我们在前后端交互时 经常会使用到token 首次请求后台把token
返回给前端 前端把这个token可以保存到localStorage里 然后每次请求
后端都需要带上这个token 进行鉴权验证等。
如下图代码：
axios.interceptors.request.use(
function (config) {
let token = window.localStorage.getItem(“token”);
if (token) {
config.headers.token = token; //将token放到请求头发
}
return config; // 最终需要返回config
},
function (error) {
return Promise.reject(error);
}
);

二、同源
我们把协议+IP+端口号都一样的url称为同源，这些url请求来自于同一个服务器

三、同源策略
浏览器为了安全起见，有一个约束，要求浏览器执行的脚本只能同源访问，默认如果访问的不是同源，则拦截这个访问

四、COSF

五、axios拦截器 - 了解
// 给axios配置 请求拦截器 参数1 正常拦截 参赛2 出错的时候拦截
axios.interceptors.request.use(function (config) {
​
console.log(config)
​
return config; // 最终需要返回config
},
function (error) {
return Promise.reject(error);
})

​
六、POST数据传递
我们使用axios进行POST数据传递的时候，需要注意封装格式， 数据 可以分为 字典类型数据，form表单类型数据
django中 request.POST 只能识别出 form表单封装的数据。
const data=new FormData()
data.append(“user”,this.user) //get方法跨域请求
data.append(“pwd”,this.pwd)
axios.post(“http://127.0.0.1:8000/login”,data).then((resp)=>{
console.log(resp)
}).catch((error)=>{
console.log(error)
})

七、连接数据库
默认使用sqlite3作为数据库
执行数据库初始化命令
1、 执行迁移操作
python manage.py makemigrations
python mange.py migrate

一、ORM提供的 字段类
为了描述数据表中字段， 字段类型 字段约束，ORM提供了专用的字段类。
1、IntegerField 整数字段
2、CharField 字符串字段
3、DateField 日期字段
4、SmallIntegerField 迷你型整数字段，最大字段16
案例：
class Student(models.Model): #用models这个包导Model
#设置id，正常id如果自增不变的话可以默认不写
id = models.AutoField(primary_key=True)
#设定姓名，长度20，且是唯一的
name = models.CharField(max_length=20, unique=True)
#小整数类型，不为空
age = models.SmallIntegerField(null=False)
#设置birhday类型，后面为日期类型
birthday = models.DateField()

注意：model.Model类 默认 会给我们创建一个名字 id的主键，我们可以不用写。以后我们就默认不写id。

二、给Django配置数据库
DATABASES = {
‘default’: {
‘ENGINE’: ‘django.db.backends.mysql’, # 使用数据库引擎
‘NAME’: ‘2002a’, # 要连接的数据库名
‘HOST’: ‘localhost’, # 数据库所在的主机
‘PORT’: 3306, # 数据库端口号
‘USER’: ‘root’, # 连接数据库的用户名
‘PASSWORD’: ‘123’ # 连接数据库的密码
}
}

三、把model类 映射到数据库
两步骤：
第一步：要生成一个 迁移文件，执行代码:python manage.py makemigrations
第二步：执行 迁移,执行代码:python manage.py migrate

四、Meta元素
1、给数据表起名字
默认名是 应用名_model名
例举：
class School(models.Model):
name=models.CharField(max_length=20,unique=True) #字符串类型，长度20，唯一
age=models.SmallIntegerField(default=16) #整数类型，small整形最大16字段
cls_id=models.IntegerField(default=32) #整形类型，最大字段32
class Meta: # 给数据表起名字，默认名是 应用名_model名,如
db_table=“schools”

                         #不起名以迁移文件夹的前面名字为主

五，添加操作
添加功能实现， 第一个易错点 就是 postman 或vue 传递的来数据 获取不到，
一定要打印print 这些传递来数据。
格式：
先导包：
from app01.models import Teacher
import json

def post(self,request):

获取网页中传过来的参数

name = request.POST.get('name','')
age = request.POST.get('age','')
print(name,age)

# 保存数据 到数据库
tea = 表名.objects.create(name=name, age=age)
print(tea)

return HttpResponse('添加')

六，查询操作
先导包：
from app01.models import Teacher
import json

1、查询所有
all() 查询出 这个数据表中的所有数据
返回的是一个QuerySet 类似于一个列表 一个集合
格式：
变量 = 表名.objects.all()

2、first（）
表示从一个查询集中 获取第一条记录， 就是 从列表中 获取第一个元素
返回的是一个Model实例
格式：
变量 = 表名.objects.各种查询方式.first()

3，条件查询
filter（条件1，条件2）
格式：
变量 = 表名.objects.filter(条件1,条件2)

4，模糊查询
filter(字段名_ _endswith/startswith)
以什么结尾：qq = 表名.objects.filter(name__endswith=“汉字”)
以什么开头：qq = 表名.objects.filter(name__startswith=‘汉字’)

5，排序
升序：order_by(条件)
降序：order_by(-条件)
格式：
变量 = 表名.objects.各种查询方式.order_by(条件)

6，比较表达式查询集
比较条件判断：
大于 ：greater than 简称：gt
小于 ：less than 简称：lt
等于 ：equal 简称：e
大于等于/小于等于： gte/lte
格式：
变量 = 表名.objects.filter(字段_ 范围1, 字段 _范围2)

7，所有的查询的结果集，必须进行封装，再用json模块转码输出。
格式：

这个空列表用来存放查询到的数据

列表名 = []

循环查询到的结果集，并进行封装

for i in 查询结果变量:
列表名.append({‘name’:i.字段名/列名,‘age’:i.字段名/列名})

把列表字典数据，转为json字符串

s = json.dumps(列表名,ensure_ascii=False)

return HttpResponse(s)

8，获取指定的字段的查询集
values（字段名）
格式：
变量 = 表名.objects.各种查询方式.values(“字段名”)
print(变量)
查询的结果为一个列表，元素是字典，可以直接用print输出，不需要进行json数据封装展示。

一、前端vue跨域
在config/index.js中 配置 代理 避免跨域访问
proxyTable: {
‘/api’: {
‘target’: ‘http://localhost:8000’, // 目标地址 我们的django地址
“changeOrigin”: true, //要不要改变源 要
“pathRewrite”: { // 重写路径 把/api 转成空字符串
‘^/api’: ‘’
}
}
},

二、列表查询

三、ORM进阶 --F Q
F方法: 能够解析对现有查询对象的引用的对象。
举个例子，我们想做一个关于商品点击量的功能，只使用数据库存
储。一般的情况下，我们需要这样做:
class LooksView(View):
def put(self,request):
uid=request.GET.get(“uid”)
print(“111”,uid)
# 先查询到集合 更新 update set age=age+1
Looks.objects.filter(id=uid).update(age=F(“age”)+1) #用表进行添加，然后id赋值给uid的变量，年龄加1，F方法进行操作
return HttpResponse(“更新成功”)

Q方法:对对象进行复杂查询，并支持&（and）,|（or），~（not）
操作符。
同样也举个例子，我们现在有一个需求，需要查询表里的名字是否存在
def get(self,request):
# queryset=Looks.objects.filter(Q(name__contains=‘飞’)&Q(name__contains=‘张’)) #查找姓名是否有张和飞的
# queryset = Looks.objects.filter(~Q(name__contains=“张”)) #除了姓名带有张的其他的都输出
# return HttpResponse(queryset)
# lesson_list = []
# for i in queryset:
# lesson_list.append({‘id’: i.id, ‘name’: i.name,‘pwd’:i.age})
# return HttpResponse(lesson_list)

name__contains ： 对商品名称进行模糊匹配
cate__name__contains : 对商品分类名称进行模糊匹配
| ： 在每个匹配条件都会有一个 | , | 是或者的意思，就是
说只要有一个满足就可以了。

四、ORM执行原生SQL语句
queryset = User.objects.raw(“select * from app02_user”)
#models里面的类名，加上。raw代表查询数据，app_user代表数据库的表名
for item in queryset:
print(item.id,item.username,item.age) #循环输出表里的元素

一，在vue页面刷新页面：
在方法里写：this.$router.go(0)

二，批量删除
delete
也就是从vue里传参数，在django里删除
格式：
def delete(self, request):
bid = request.GET.get(“bid”)
# 批量删除
Book.objects.filter(id=bid).delete()
return JsonResponse({“msg”: “删除成功”})

三，正则表达式，判断
变量=‘ 字符串内容 ’
if re.match("^条件$", 变量):
print（满足条件执行的内容）

四，Model模型关系
给数据表添加外键
在models.py文件里操作
格式：
外键名= models.ForeignKey(主表名（也就是添加的字段表名）,
on_delete = models.CASCADE/SET_NULL, null=True)

详解：
on_delete参数意思:
参数的意思：当主表记录删除时，从表应该怎么办
model.CASCADE 表示 主表删除，从表记录也删除
models.SET_NULL,mull=True 主表删除，从表记录的外键值设为Null

外键名在数据表中会自动添加_id

五，正向访问
我们可以根据外键去访问主表记录 并获取到主表记录
我们获取到了i实例，图书model有外键 num 指向的 分类
​
则 book实例 就可以通过外键num获取num实例
​
要获取图书分类的名就可以这样操作
i.num.name
举例：
def get(self,request):
list1=[]
gg=Essay.objects.all() #Essay代表model里类名
for i in gg:
list1.append({‘id’:i.id,‘title’:i.title,‘number1’:i.number1,‘cid’:i.num.name})
#cid代表request获取变量名，num代表外键的分类，name是要获取另外一个表的name，来实现两个表之间的关联
return JsonResponse(list1,safe=False)

六，vue路由跳转
当前路径 可以通过 $route来表示一个路由如果一个路由中携带了参数，我们可以通过$route.query来获取
query是固定的，必须这样来访问
来跳转
​
如果是不带参数跳转

​
如果携带参数
来跳转
例举：

• 
  {{i.title}}

• ​
  在data里获取 传递来的参数
  变量：this.$route.query.key1
  $router 是路由器 用来跳转的。
  格式:

  图书详情

  {{title}} {{number1}} {{cid}}

  一、文件上传
  1、vue部分
  一定要使用FormData()来封装数据
  如何获取input选择的数据
  methods: {
  addbook() {
  //获取 选择的文件
  let pic = document.getElementById(“pic”).files[0]; // 获取的 一个 input标签对象

  获取到用户上传的图片对象，我们需要通过axios提交到Django后端，
  由后端负责保存，在写地址到数据库
  2、前端vue 发送图片到后端
  我们这里使用FormData对象来封装要传递的数据，包括我们要上传的
  图片106
  // 偶去 图片标签对象
  const file=document.getElementById(“pic”)
  // input 可以一次性 上传多个文件， 这里获取第一个 下标为0
  const pic=file.files[0]
  // 因为我们这里有图片 所以 要使用FormData 进行 form表单数据模拟
  const data=new FormData()
  data.append(“name”,this.name)
  data.append(“age”,this.age)
  data.append(“pic”,pic)
  axios.post(“http://127.0.0.1:8000/student”,data).then(function(r
  alert(“添加成功”)
  }).catch(function(error){
  alert(“添加出错”)
  })

  3、Model部分
  一定要注意，我们的数据库存储从是 文件的存储地址，而不是文件本身，所以文件字段是CharField()类型
  补充：给已经存在的表 添加新字段，一定要注意 给字段添加默认值 或者 一次性默认值
  4、视图部分
  import math

  from django.http import JsonResponse
  from django.shortcuts import render
  from django.views import View

  from app01.models import Book, Commodity

  class Book_Page(View):
  def get(self,request):
  #完成我们的分页测试
  page_num=request.GET.get(‘num’,1) #设置一个值为num，默认为1
  page_num=int(page_num)
  page_size=2 #设定一个长度开始为2
  #进行分页查询
  # 进行分页查询 0:3 3:6 6:9 3*(1-1):13 3:(2-1):23 3*(3-1):33
  querset=Book.objects.all()[(page_num -1) * page_size:page_numpage_size] #
  book_list=[]
  for i in querset:
  book_list.append({‘id’:i.id,‘name’:i.name,‘price’:i.price})
  count=Book.objects.count() #获取所有的记录数
  total_size=math.ceil(count/page_size) #对计算结果进行向上取整数
  page_list=[x for x in range(1,total_size+1)]
  resp={‘data’:book_list,‘page_list’:page_list} #把book_list列表循环的值赋值给data，然后将循环出的分页赋值给page_list
  return JsonResponse(resp,safe=False)

  class Commodity_Fruits(View):
  def get(self,request):
  fruits_num=request.GET.get(‘num’,1) #设置一个值为num，默认为1
  fruits_num=int(fruits_num) #字符串转整形
  fruits_size=1 #设定一个默认长度1
  querset=Commodity.objects.all()[(fruits_num-1)fruits_size:fruits_numfruits_size]
  commodity_list=[]
  for i in querset:
  commodity_list.append({‘id’:i.id,‘name’:i.name,‘price’:i.price})

      count=Commodity.objects.count()    # 获取所有的记录数
      total_size=math.ceil(count/fruits_size)     #对计算结果进行向上取整数
      fruits_list=[x for x in range(1,total_size+1)]
      # print(fruits_list)
      resp={'data':commodity_list,'fruits_list':fruits_list}
      # if (fruits_list==0 or fruits_list==-1):
      #     return JsonResponse({'data':'页面无法加载'})
      return JsonResponse(resp,safe=False)
  

  ​第二种
  import math

  from django.db.models import F
  from django.http import JsonResponse
  from django.shortcuts import render
  from django.views import View
  from rest_framework.response import Response
  from rest_framework.views import APIView

  from app01.models import *
  from app01.sers import *

  class LoginView(APIView):
  def post(self,request):
  username=request.data.get(‘username’,)
  password=request.data.get(‘password’,)
  if User.objects.filter(username=username,password=password):
  return Response({‘msg’:‘登录成功’,‘msg_code’:0})
  return Response({“msg”:‘登录失败’,‘msg_code’:1})
  class JournalismAPIView(APIView):
  def get(self,request):
  journalism_num=request.GET.get(‘num’,1) # 获取页码
  journalism_num=int(journalism_num)
  journalism_size=1 # 定义每页数据条数
  queryset=Journalism.objects.all()[(journalism_num-1)journalism_size:journalism_numjournalism_size]
  count=Journalism.objects.count()
  total_size=math.ceil(count/journalism_size) #向上取整数， # 总页码数
  journalism_list=[x for x in range(1,total_size+1)] # # 页码列表
  ser=JournalismSer(queryset,many=True) # # 序列化
  data=ser.data
  resp={“data”:data,‘journalism_list’:journalism_list} # 返回每页新闻和页码列表
  return Response(resp)
  def post(self,request):
  id=request.data.get(‘id’)
  print(id)
  journalism=Journalism.objects.filter(id=id) #点击vue详情获取id
  ser=JournalismSer(journalism,many=True) #序列化，many代表多个值
  data=ser.data #赋值数据
  print(data)
  return Response(data)
  def put(self,request):
  id = request.data.get(‘id’) # 获取id
  print(id)
  Journalism.objects.filter(id=id).update(stars=F(‘stars’)+1) # 通过id查询对应新闻， 修改点赞数 增1
  return Response({‘msg’:‘点赞成功’})

  4、静态目录配置

  setting中配置

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

  一、djangorestframework
  1、django rest framework django的 rest框架 简称drf
  2、下载
  pip install djangorestframework

  3、认识 drf框
  认识基本的类：
  视图部分： APIView 父类是View
  APIView是继承自Django的View，重新做了封装
  Response 是继承了Django的 HTTPResponse，增强了功能
  可以直接返回字典列表类型，类似于JsonResponse。
  可以直接获取form表单数据或者字典数据。
  使用 data属性来获取 POST或PUT提交来的数据
  使用query_params/GET属性来获取url地址后携带的参数
  from django.shortcuts import render
  from rest_framework.fields import IntegerField, CharField
  from rest_framework.response import Response
  from rest_framework.serializers import Serializer, ModelSerializer

  from rest_framework.views import APIView

  from app01.models import Book

  class BookModeSerializer(ModelSerializer):
  class Meta:
  model = Book # 指定 是给哪个Model写的序列化类
  # fields = ‘all’ # 所有字段都参与
  # fields=[‘id’,‘name’,‘price’] # 只能model的哪些字段参与
  # exclude = (‘id’,) #在所有的字段中剔除某个字段,换句话说就是不想显示的字段放在这里就可以了， 则需使用 exclude

  class BookSerializer(Serializer):

  # # 声明 要进行 序列化的类

  id=IntegerField()

  name=CharField()

  class BookAPIView(APIView):
  # def post(self, request):
  # name = request.data.get(‘name’, ‘’)
  # print(‘name:’, name)
  # return Response({“msg”: ‘ok’})

  def get(self, request):
      querest = Book.objects.all()
      # book_list=[]
      # for i in querest:
      #     book_list.append({"id":i.id,'name':i.name,'price':i.price})
      # return Response(book_list)
      # 创建了一个 序列化实例  many 多个的意思   因为我们要序列化的是queryset是一个列表 有多个元素
      ser = BookModeSerializer(querest, many=True)
      # 获取序列化后的结果
      data = ser.data
      return Response(data)
  

  二、序列化
  我们需要把对象 转化成 可以传输/保存的数据格式，这个过程就是序列化

  1. ModelSerializer 介绍 ★★★★
     DRF中的serializer是针对json,而且非常强大。通俗的理解为从后台获取
     数据进行一系列的逻辑运算最终转成json串给前端使用。
     ModelSerializer 类提供了一个快捷方式，可让你基于 Models,自动创建
     一个 Serializer类，其中的字段与模型类字段对应。

  2. ModelSerializer 序列化数据 ★★★★★
     该类中的所有模型类字段将被映射为相应的序列化类字段。任何关系
     （如模型上的外键）都将映射到 PrimaryKeyRelatedField 。除非在序
     列化关系文档中指定，否则默认不包括反向关系。
     class BookModeSerializer(ModelSerializer):
     class Meta:
     model = Book # 指定 是给哪个Model写的序列化类
     # fields = ‘all’ # 所有字段都参与
     # fields=[‘id’,‘name’,‘price’] # 只能model的哪些字段参与
     # exclude = (‘id’,) #在所有的字段中剔除某个字段,换句话说就是不想显示
     #字段放在这里就可以了， 则需使用 exclude

  3.指定的要包含的指定的字段 是用 fields 关键字
  class BookModeSerializer(ModelSerializer):
  class Meta:
  model = Book # 指定 是给哪个Model写的序列化类,Book是model的列名
  fields = ‘all’ # 所有字段都参与
  # fields=[‘id’,‘name’,‘price’] # 只能model的哪些字段参与

  4.在所有的字段中剔除某个字段,换句话说就是不想显示的字段放在这里就可以了， 则需使用 exclude

  三、全局默认的配置信息
  在settings中的
  INSTALLED_APPS = [
  ‘django.contrib.admin’,
  ‘django.contrib.auth’,
  ‘django.contrib.contenttypes’,
  ‘django.contrib.sessions’,
  ‘django.contrib.messages’,
  ‘django.contrib.staticfiles’,
  ‘app01.apps.App01Config’,
  ‘rest_framework’
  ]

  添加 ‘rest_framework’

  一、如何把报错改编成中文，在settings中把LANGUAGE_CODE = 'zh-hans’改成这样就可以了
  配置Postman里的中文提示，在sttings里：LANGUAGE_CODE = ‘zh-hans’

  二、如何把外键对应的id改编成主表的名字，代码如下：
  class JournalismSer(serializers.ModelSerializer):
  # 传过来分类表的名字，read_only只能读取，cate为外键表的分类字段名,name是分类
  #主键的名字字段
  cate= serializers.SlugRelatedField(slug_field=‘name’, read_only=True)
  class Meta:
  model=Journalism
  fields=“all”

  三、反序列化
  二，反序列
  在post方法中，写反序列
  1，创建反序列化器
  格式：
  导包：
  from rest_framework import serializers
  from app04.models import *
  写序列化器：
  class 序列化器类名（serializers.ModelSerializer）：
  cate= serializers.SlugRelatedField(slug_field=‘name’, read_only=True)

  传过来分类表的名字，read_only只能读取，cate为外键表的分类字段名,name是分类

  #主键的名字字段
  

  class Meta：
  model = 库名
  fields = “all” #代表全部字段
  fields = [“字段名”，“字段名”…] #需要序列化的字段

  2，创建反序列化视图类
  在view文件中，创建序列化类
  格式：
  导包：
  from rest_framework.views import APIView #导APIView
  from app04.res import * #导创建的序列化
  from rest_framework.response import Response
  写序列化类：
  class 类名（APIView）：
  def post（self，request）：
  #用data获取post传入的参数，再把参数放到序列化器中
  变量1(ser) = 序列化器类名（data=request.data）

  #判断参数是否正确，先判断字段的约束，再判断是否默认为空，
  最后判断自定义约束，并捕获异常
  变量1(ser).is_valid(raise_exception=True)

  #把数据写入到数据库中
  变量1(ser).save()
  return Response（{‘mag’:‘插入成功’}） #把结果返回给页面

  四、创建序列化视图类
  在view文件中，创建序列化类
  格式：
  导包：
  from rest_framework.views import APIView #导APIView
  from app04.res import * #导创建的序列化
  from rest_framework.response import Response
  写序列化类：
  class 类名（APIView）：
  def get（self，request）：
  #查询数据库中的数据
  变量1（queryset) = 库名.objects.all（）

  把内容放到序列化器中，many=True代表多个的意思。

  变量2(ser) = 序列化器类名（变量1(queryset)，many=True）

  变量3(ser) = 变量2.data #获取序列化后的内容

  return Response（变量3(ser)） #把结果返回给页面

  一、WebStorage介绍

  是一个存储到浏览器客户端的 解决方案，使用webStorage可以实现在客户端 临时存储数据 和 长久存储数据

  二、临时存储使用SessionStorage
  在方法里写：
  sessionStorage.setItem(“存储进去后的变量名”,this.需要存储的变量)

  获取vue中临时存储的数据
  接收的变量:sessionStorage.getItem(“存储进去后的变量名”)

  三、长久存储使用LocalStorage
  存储数据
  localStorage.setItem(key,value)

  读取数据
  value=sessionStorage.getItem(key)
  value=localStorage.getItem(key)

  一、用分页器完成分页操作
  class CateAPIView(APIView):

  def get(self, request):
      # 获取页码
      num = request.query_params.get("num", 1)
      num = int(num)
  
      # 查询结果
      queryset = Cate.objects.all()  # all  filter
  
      # 创建分页器
      paginator = Paginator(queryset, 3)
  
      # 获取一页 数据
      queryset = paginator.get_page(num)
  
      # 创建序列号器 传入要序列化的对象 many 我们要序列化的对象是一个列表
      ser = CateModelSerializer(queryset, many=True)
  
      # 获取页码范围
      num_list = [x for x in paginator.page_range]
  
      # 返回序列化的结果
      resp = {
          "data": ser.data,
          "num_list": num_list
      }
      return Response(resp)