一。拆分的序列化。
model序列化的基本用法就是使用元类中的fields，其中model绑定的就是model中的表
如果需要多表查询，要在model中定义property：
class BookModelSerializer(ModelSerializer): publish = PublishModelSerializer() class Meta: model = models.Book fields = ('name', 'price', 'img', 'author_list', 'publish')
model该表中的property方法：
@property def publish_name(self): return self.publish.name @property def author_list(self): return self.authors.values('name', 'age','detail__mobile').all()
这些都是model中的字段。
第二种就是使用外接的序列化类生成序列化对象，然后作为字段添加到field中。这种设定不是可插拔式的。
class PublishModelSerializer(ModelSerializer): class Meta: model = models.Publish fields = ('name', 'address') class BookModelSerializer(ModelSerializer): publish = PublishModelSerializer() class Meta: model = models.Book fields = ('name', 'price', 'img', 'author_list', 'publish')
第三种不常用，就是使用field。exclude除了这立马的字段之外其他都显示，另加depth作为深度。
class BookModelSerializer(ModelSerializer): publish = PublishModelSerializer() class Meta: model = models.Book fields = ('name', 'price', 'img', 'author_list', 'publish') # 了解知识点 # 所有字段 # fields = '__all__' # 与fields不共存，exclude排除哪些字段 # exclude = ('id', 'is_delete', 'create_time') # 自动连表深度 # depth = 1
这些序列化类在被定义之后，在view视图层种调用，调用的参数有instance，date和many
instance是需要序列化的对象，date是从前端接受的数据，many就是是否为多单位。
class Book(APIView): def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: book_obj = models.Book.objects.get(pk=pk, is_delete=False) book_data = serializers.BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: book_query = models.Book.objects.filter(is_delete=False).all() book_data = serializers.BookModelSerializer(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data })
反序列化使用：
重新继承一个modelserializer类，反序列化需要使用元类字段extra_kwargs。
这个是其他关键字段，其中的元素就是fields种的字段，字段种使用字段进行判断:
required：是否必填。
min_length等长度提示，
error_messages则是以上限时生效的时候返回给前端的错误信息。
进行反序列化后可以通过钩子函数（局部和全局）进判断。
class BookModelDeserializer(ModelSerializer): class Meta: model = models.Book fields = ('name', 'price', 'publish', 'authors') # extra_kwargs 用来完成反序列化字段的 系统校验规则 extra_kwargs = { 'name': { 'required': True, 'min_length': 1, 'error_messages': { 'required': '必填项', 'min_length': '太短', } } } # 局部钩子 def validate_name(self, value): # 书名不能包含 g 字符 if 'g' in value.lower(): raise ValidationError('该g书不能出版') return value # 全局钩子 def validate(self, attrs): publish = attrs.get('publish') name = attrs.get('name') if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs # ModelSerializer类已经帮我们实现了 create 与 update 方法
这个模块已经帮我们实现了create和update，只需要在前端调用save方法即可。
二。整合的序列化。
在序列化类中，有以下信息：
model = models.book 模块的定义
fields = 操作的字段定义。
extra_kwargs 对字段的操作
在对字段的操作中，有三选一的操作：
required:True 是否必填。
read_only 只能序列化。
write_only 只能反序列化。
""" 1) fields中设置所有序列化与反序列化字段 2) extra_kwargs划分只序列化或只反序列化字段 write_only：只反序列化 read_only：只序列化 自定义字段默认只序列化(read_only) 3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则 """ class V2BookModelSerializer(ModelSerializer): class Meta: model = models.Book fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors') extra_kwargs = { 'name': { 'required': True, 'min_length': 1, 'error_messages': { 'required': '必填项', 'min_length': '太短', } }, 'publish': { 'write_only': True }, 'authors': { 'write_only': True }, 'img': { 'read_only': True, }, 'author_list': { 'read_only': True, }, 'publish_name': { 'read_only': True, } } def validate_name(self, value): # 书名不能包含 g 字符 if 'g' in value.lower(): raise ValidationError('该g书不能出版') return value def validate(self, attrs): publish = attrs.get('publish') name = attrs.get('name') if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs
三。单查询和群查询。
主要通过路由传输参数pk，判断是否有pk如果有pk则为单查，如果没有pk则为群查。
''' 单查路由：http://127.0.0.1:8000/api/v2/books/1/ 单查数据返回：{ "status": 0, "msg": "ok", "results": { "name": "南开大学", "price": "12.00", "img": "/media/img/default.jpg", "publish_name": "东京出版社", } } 群查路由：http://127.0.0.1:8000/api/v2/books 群查数据返回：{ "status": 0, "msg": "ok", "results": [ { "name": "南开大学", "price": "12.00", "img": "/media/img/default.jpg", "publish_name": "东京出版社", "author_list": [ { "id": 1, "is_delete": false, "create_time": "2019-10-17T11:09:29.316398", "name": "zzj", "age": 12 }, { "id": 2, "is_delete": false, "create_time": "2019-10-17T11:10:21.914888", "name": "zzp", "age": 43 } ] }, { "name": "南开大学", "price": "12.00", "img": "/media/img/default.jpg", "publish_name": "东京出版社", "author_list": [ { "id": 1, "is_delete": false, "create_time": "2019-10-17T11:09:29.316398", "name": "zzj", "age": 12 }, { "id": 2, "is_delete": false, "create_time": "2019-10-17T11:10:21.914888", "name": "zzp", "age": 43 } ] } ] } ''' def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: book_obj = models.Book.objects.get(pk=pk, is_delete=False) book_data = serializers.V2BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: book_query = models.Book.objects.filter(is_delete=False).all() book_data = serializers.V2BookModelSerializer
(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data })
四，单增和多增。
增加的逻辑就是判断传入的数据是否是字典或列表，是字典则是单个，列表则是多个
''' 增添路由：http://127.0.0.1:8000/api/v2/books/ 单增输入： { "name":"南开大学12", "price":12, "publish":1, "authors":[1,2] } 多增输入： [ { "name":"南开大学1", "price":12, "publish":1, "authors":[1,2] }, { "name":"南开大学2", "price":12, "publish":1, "authors":[1,2] } ] 数据返回： { "status": 0, "msg": "ok", "results": { "name": "南开大学12", "price": "12.00", "img": "/media/img/default.jpg", "publish_name": "东京出版社", } } ''' def post(self, request, *args, **kwargs): request_data = request.data if isinstance(request_data, dict): many = False elif isinstance(request_data, list): many = True else: return Response({ 'status': 1, 'msg': '数据有误', }) book_ser = serializers.V2BookModelSerializer
(data=request_data, many=many) # 当校验失败，马上终止当前视图方法，抛异常返回给前台 book_ser.is_valid(raise_exception=True) book_result = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer
(book_result, many=many).data })
五。单删和多删。
单次删除时添加参数pk，而如果没有pk，则会获取传入参数 的数据中的pks。
最后都生成列表以并操作。
''' 单删路由：http://127.0.0.1:8000/api/v2/books/7/ 多删路由:http://127.0.0.1:8000/api/v2/books/ 多删输入：{"pks": [1, 2, 3]} 返回数据{ "status": 0, "msg": "删除成功" } ''' def delete(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: pks = [pk] else: pks = request.data.get('pks') if models.Book.objects.filter(pk__in=pks, is_delete=False).update
(is_delete=True): return Response({ 'status': 0, 'msg': '删除成功', }) return Response({ 'status': 1, 'msg': '删除失败', })
六。整体单改
修改主要取决于序列化对象中的参数partial和所有字段中的required对象
""" 1) 单整体改，说明前台要提供修改的数据，那么数据就需要校验，
校验的数据应该在实例化“序列化类对象”时，赋值给data 2）修改，就必须明确被修改的模型类对象，并在实例化“序列化类对象”时，赋值给instance 3）整体修改，所有校验规则有required=True的字段，都必须提供，因为在实例化“序列化类对象”时，
参数partial默认为False 注：如果partial值设置为True，就是可以局部改 1）单整体修改，一般用put请求： V2BookModelSerializer( instance=要被更新的对象, data=用来更新的数据, partial=默认False，必须的字段全部参与校验 ) 2）单局部修改，一般用patch请求： V2BookModelSerializer( instance=要被更新的对象, data=用来更新的数据, partial=设置True，必须的字段都变为选填字段 ) 注：partial设置True的本质就是使字段 required=True 校验规则失效 """
对于单体全修改，使用put来提交数据。
如果系列化对象中同时存在对象和数据时，就会修改该数据：
''' 修改路由：http://127.0.0.1:8000/api/v2/books/7/ 修改输入： { "name":"南开大学123", "price":12, "publish":1, "authors":[1,2] }(所有必填字段都要) ''' class V2Book(APIView): # 单整体改: 对 v2/books/(pk)/ 传的数据是与model对应的字典
{name|price|publish|authors} def put(self, request, *args, **kwargs): request_data = request.data pk = kwargs.get('pk') old_book_obj = models.Book.objects.filter(pk=pk).first() # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，
校验成功后，序列化类来帮你入库 book_ser = serializers.V2BookModelSerializer(instance=old_book_obj,
data=request_data, partial=False) book_ser.is_valid(raise_exception=True) # 校验通过，完成数据的更新：要更新的目标，用来更新的新数据 book_obj = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(book_obj).data })
七。单改和群局部修改。
只需要修改被改的对象。
首先通过是否有pk和传入的修改数据对象类型进行判断，同一替换成列表。
群体修改的数据需要一一对应。然后弹出pk。
其中需要定义listserializer中的update方法，重写，可以调用子的update方法进行重写。
# 重点：ListSerializer与ModelSerializer建立关联的是： # ModelSerializer的Meta类的 - list_serializer_class class V2BookListSerializer(ListSerializer): def update(self, instance, validated_data): # print(instance) # 要更新的对象们 # print(validated_data) # 更新的对象对应的数据们 # print(self.child) # 服务的模型序列化类 - V2BookModelSerializer for index, obj in enumerate(instance): self.child.update(obj, validated_data[index]) return instance # 原模型序列化类变化 class V2BookModelSerializer(ModelSerializer): class Meta: # ... # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法 list_serializer_class = V2BookListSerializer # ...
视图：
''' 单局部修改路由：http://127.0.0.1:8000/api/v2/books/7/ 单局部修改输入：{"name":"南开大学1234"} 群局部修改路由：http://127.0.0.1:8000/api/v2/books/ 群局部修改输入：[ {"pk":1, "name":"123"}, {"pk":3, "price":7}, {"pk":7, "publish":2} ] ''' class V2Book(APIView): # 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填 # 群局部改：对 v2/books/ # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}] def patch(self, request, *args, **kwargs): request_data = request.data pk = kwargs.get('pk') # 将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] |
request_data=[每个要修改的对象对应的修改数据] if pk and isinstance(request_data, dict): # 单改 pks = [pk, ] request_data = [request_data, ] elif not pk and isinstance(request_data, list): # 群改 pks = [] for dic in request_data:
# 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，
拿一个个字典 pk = dic.pop('pk', None) if pk: pks.append(pk) else: return Response({ 'status': 1, 'msg': '数据有误', }) else: return Response({ 'status': 1, 'msg': '数据有误', }) # pks与request_data数据筛选， # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，
request_data对应索引位上的数据也移除 # 2）将合理的pks转换为 objs objs = [] new_request_data = [] # [{},{},{}] for index, pk in enumerate(pks): try: # pk对应的数据合理，将合理的对象存储 obj = models.Book.objects.get(pk=pk) objs.append(obj) # 对应索引的数据就需要保存下来 new_request_data.append(request_data[index]) except: # 重点：反面教程 - pk对应的数据有误，
将对应索引的data中request_data中移除 # index = pks.index(pk) # request_data.pop(index) continue book_ser = serializers.V2BookModelSerializer
(instance=objs, data=new_request_data, partial=True, many=True) book_ser.is_valid(raise_exception=True) book_objs = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer
(book_objs, many=True).data })
总结：
model层：
from django.db import models # 图书管理系统：Book、Author、AuthorDetail、Publish """ Book表: name、price、img、authors、publish、is_delete、create_time Publish表: name、address、is_delete、create_time Author表: name、age、is_delete、create_time AuthorDetail表: mobile, author、is_delete、create_time """ # 1) 基表 class BaseModel(models.Model): is_delete = models.BooleanField(default=False) create_time = models.DateTimeField(auto_now_add=True) # 作为基表的Model不能在数据库中形成对应的表，设置 abstract = True class Meta: abstract = True class Book(BaseModel): """name、price、img、authors、publish、is_delete、create_time""" name = models.CharField(max_length=64) price = models.DecimalField(max_digits=5, decimal_places=2) img = models.ImageField(upload_to='img', default='img/default.jpg') publish = models.ForeignKey( to='Publish', db_constraint=False, related_name='books', on_delete=models.DO_NOTHING, ) authors = models.ManyToManyField( to='Author', db_constraint=False, related_name='books' ) @property def publish_name(self): return self.publish.name @property def author_list(self): return self.authors.values('name', 'age', 'detail__mobile').all() class Meta: db_table = 'book' verbose_name = '书籍' verbose_name_plural = verbose_name def __str__(self): return self.name class Publish(BaseModel): """name、address、is_delete、create_time""" name = models.CharField(max_length=64) address = models.CharField(max_length=64) class Meta: db_table = 'publish' verbose_name = '出版社' verbose_name_plural = verbose_name def __str__(self): return self.name class Author(BaseModel): """name、age、is_delete、create_time""" name = models.CharField(max_length=64) age = models.IntegerField() class Meta: db_table = 'author' verbose_name = '作者' verbose_name_plural = verbose_name def __str__(self): return self.name class AuthorDetail(BaseModel): """mobile, author、is_delete、create_time""" mobile = models.CharField(max_length=11) author = models.OneToOneField( to='Author', db_constraint=False, related_name='detail', on_delete=models.CASCADE, ) class Meta: db_table = 'author_detail' verbose_name = '作者详情' verbose_name_plural = verbose_name def __str__(self): return '%s的详情' % self.author.name
exception层：
from rest_framework.views import exception_handler as drf_exception_handler from rest_framework.views import Response from rest_framework import status def exception_handler(exc, context): # drf的exception_handler做基础处理 response = drf_exception_handler(exc, context) # 为空，自定义二次处理 if response is None: print('%s - %s - %s' % (context['view'], context['request'].method, exc)) return Response({ 'detail': '服务器错误' }, status=status.HTTP_500_INTERNAL_SERVER_ERROR, exception=True) return response
serializers层：
from rest_framework.serializers import ModelSerializer, SerializerMethodField from rest_framework.exceptions import ValidationError from . import models class PublishModelSerializer(ModelSerializer): class Meta: model = models.Publish fields = ('name', 'address') class BookModelSerializer(ModelSerializer): # 了解: 该方式设置的序列化字段，必须在fields中声明 # publish_address = SerializerMethodField() # def get_publish_address(self, obj): # return obj.publish.address # 自定义连表深度 - 子序列化方式 publish = PublishModelSerializer() class Meta: # 序列化类关联的model类 model = models.Book # 参与序列化的字段 fields = ('name', 'price', 'img', 'author_list', 'publish') # 了解知识点 # 所有字段 # fields = '__all__' # 与fields不共存，exclude排除哪些字段 # exclude = ('id', 'is_delete', 'create_time') # 自动连表深度 # depth = 1 class BookModelDeserializer(ModelSerializer): class Meta: model = models.Book fields = ('name', 'price', 'publish', 'authors') # extra_kwargs 用来完成反序列化字段的 系统校验规则 extra_kwargs = { 'name': { 'required': True, 'min_length': 1, 'error_messages': { 'required': '必填项', 'min_length': '太短', } } } def validate_name(self, value): # 书名不能包含 g 字符 if 'g' in value.lower(): raise ValidationError('该g书不能出版') return value def validate(self, attrs): publish = attrs.get('publish') name = attrs.get('name') if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs # ModelSerializer类已经帮我们实现了 create 与 update 方法 """ 1) fields中设置所有序列化与反序列化字段 2) extra_kwargs划分只序列化或只反序列化字段 write_only：只反序列化 read_only：只序列化 自定义字段默认只序列化(read_only) 3) 设置反序列化所需的 系统、局部钩子、全局钩子 等校验规则 """ from rest_framework.serializers import ListSerializer # 重点：ListSerializer与ModelSerializer建立关联的是： # ModelSerializer的Meta类的 - list_serializer_class class V2BookListSerializer(ListSerializer): def update(self, instance, validated_data): # print(instance) # 要更新的对象们 # print(validated_data) # 更新的对象对应的数据们 # print(self.child) # 服务的模型序列化类 - V2BookModelSerializer for index, obj in enumerate(instance): self.child.update(obj, validated_data[index]) return instance class V2BookModelSerializer(ModelSerializer): class Meta: model = models.Book fields = ('name', 'price', 'img', 'author_list', 'publish_name', 'publish', 'authors') extra_kwargs = { 'name': { 'required': True, 'min_length': 1, 'error_messages': { 'required': '必填项', 'min_length': '太短', } }, 'publish': { 'write_only': True }, 'authors': { 'write_only': True }, 'img': { 'read_only': True, }, 'author_list': { 'read_only': True, }, 'publish_name': { 'read_only': True, } } # 群改，需要设置 自定义ListSerializer，重写群改的 update 方法 list_serializer_class = V2BookListSerializer def validate_name(self, value): # 书名不能包含 g 字符 if 'g' in value.lower(): raise ValidationError('该g书不能出版') return value def validate(self, attrs): publish = attrs.get('publish') name = attrs.get('name') if models.Book.objects.filter(name=name, publish=publish): raise ValidationError({'book': '该书已存在'}) return attrs
url：
from django.conf.urls import url from . import views urlpatterns = [ url(r'^books/$', views.Book.as_view()), url(r'^books/(?P<pk>.*)/$', views.Book.as_view()), url(r'^publishes/$', views.Publish.as_view()), url(r'^publishes/(?P<pk>.*)/$', views.Publish.as_view()), url(r'^v2/books/$', views.V2Book.as_view()), url(r'^v2/books/(?P<pk>.*)/$', views.V2Book.as_view()), ]
view层：
from rest_framework.views import APIView from rest_framework.response import Response from . import models, serializers class Publish(APIView): def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: publish_obj = models.Publish.objects.get(pk=pk, is_delete=False) publish_data = serializers.PublishModelSerializer(publish_obj).data except: return Response({ 'status': 1, 'msg': '出版社不存在' }) else: publish_query = models.Publish.objects.filter(is_delete=False).all() publish_data = serializers.PublishModelSerializer(publish_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': publish_data }) class Book(APIView): def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: book_obj = models.Book.objects.get(pk=pk, is_delete=False) book_data = serializers.BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: book_query = models.Book.objects.filter(is_delete=False).all() book_data = serializers.BookModelSerializer(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data }) def post(self, request, *args, **kwargs): request_data = request.data book_ser = serializers.BookModelDeserializer(data=request_data) # 当校验失败，马上终止当前视图方法，抛异常返回给前台 book_ser.is_valid(raise_exception=True) book_obj = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.BookModelSerializer(book_obj).data }) class V2Book(APIView): # 单查：有pk # 群查：无pk def get(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: try: book_obj = models.Book.objects.get(pk=pk, is_delete=False) book_data = serializers.V2BookModelSerializer(book_obj).data except: return Response({ 'status': 1, 'msg': '书籍不存在' }) else: book_query = models.Book.objects.filter(is_delete=False).all() book_data = serializers.V2BookModelSerializer(book_query, many=True).data return Response({ 'status': 0, 'msg': 'ok', 'results': book_data }) # 单增：传的数据是与model对应的字典 # 群增：传的数据是 装多个 model对应字典 的列表 def post(self, request, *args, **kwargs): request_data = request.data if isinstance(request_data, dict): many = False elif isinstance(request_data, list): many = True else: return Response({ 'status': 1, 'msg': '数据有误', }) book_ser = serializers.V2BookModelSerializer(data=request_data, many=many) # 当校验失败，马上终止当前视图方法，抛异常返回给前台 book_ser.is_valid(raise_exception=True) book_result = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(book_result, many=many).data }) # 单删：有pk # 群删：有pks | {"pks": [1, 2, 3]} def delete(self, request, *args, **kwargs): pk = kwargs.get('pk') if pk: pks = [pk] else: pks = request.data.get('pks') if models.Book.objects.filter(pk__in=pks, is_delete=False).update(is_delete=True): return Response({ 'status': 0, 'msg': '删除成功', }) return Response({ 'status': 1, 'msg': '删除失败', }) # 单整体改: 对 v2/books/(pk)/ 传的数据是与model对应的字典{name|price|publish|authors} def put(self, request, *args, **kwargs): request_data = request.data pk = kwargs.get('pk') old_book_obj = models.Book.objects.filter(pk=pk).first() # 目的：将众多数据的校验交给序列化类来处理 - 让序列化类扮演反序列化角色，校验成功后，序列化类来帮你入库 book_ser = serializers.V2BookModelSerializer(instance=old_book_obj, data=request_data, partial=False) book_ser.is_valid(raise_exception=True) # 校验通过，完成数据的更新：要更新的目标，用来更新的新数据 book_obj = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(book_obj).data }) # 单局部改：对 v2/books/(pk)/ 传的数据，数据字段key都是选填 # 群局部改： # 请求数据 - [{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}] def patch(self, request, *args, **kwargs): request_data = request.data pk = kwargs.get('pk') # 将单改，群改的数据都格式化成 pks=[要需要的对象主键标识] | request_data=[每个要修改的对象对应的修改数据] if pk and isinstance(request_data, dict): # 单改 pks = [pk, ] request_data = [request_data, ] elif not pk and isinstance(request_data, list): # 群改 pks = [] for dic in request_data: # 遍历前台数据[{pk:1, name:123}, {pk:3, price:7}, {pk:7, publish:2}]，拿一个个字典 pk = dic.pop('pk', None) if pk: pks.append(pk) else: return Response({ 'status': 1, 'msg': '数据有误', }) else: return Response({ 'status': 1, 'msg': '数据有误', }) # pks与request_data数据筛选， # 1）将pks中的没有对应数据的pk与数据已删除的pk移除，request_data对应索引位上的数据也移除 # 2）将合理的pks转换为 objs objs = [] new_request_data = [] for index, pk in enumerate(pks): try: # pk对应的数据合理，将合理的对象存储 obj = models.Book.objects.get(pk=pk) objs.append(obj) # 对应索引的数据就需要保存下来 new_request_data.append(request_data[index]) except: # 重点：反面教程 - pk对应的数据有误，将对应索引的data中request_data中移除 # index = pks.index(pk) # request_data.pop(index) continue book_ser = serializers.V2BookModelSerializer(instance=objs, data=new_request_data, partial=True, many=True) book_ser.is_valid(raise_exception=True) book_objs = book_ser.save() return Response({ 'status': 0, 'msg': 'ok', 'results': serializers.V2BookModelSerializer(book_objs, many=True).data }) # 总结： """ 1）单整体修改： V2BookModelSerializer( instance=要被更新的对象, data=用来更新的数据, partial=默认False，必须的字段全部参与校验 ) 2）单局部修改： V2BookModelSerializer( instance=要被更新的对象, data=用来更新的数据, partial=设置True，必须的字段都变为选填字段 ) 注：partial设置True的本质就是使字段 required=True 校验规则失效 """