from django.db import models

# Create your models here.

class Classroom(models.Model):

    location = models.CharField(max_length=128)
    def __str__(self):
        return self.location


class Student(models.Model):
    name = models.CharField(max_length=32)
    classroom = models.ForeignKey(Classroom, on_delete=models.CASCADE)

    def __str__(self):
        return self.name

from .models import Classroom, Student
from rest_framework.serializers import ModelSerializer

class StudentSerializer(ModelSerializer):

    class Meta:
        model = Student
        fields = "__all__"


class ClassroomSerializer(ModelSerializer):
    class Meta:
        model = Classroom
        fields = "__all__"

from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom


class StudentViewSet(ModelViewSet):
    serializer_class = StudentSerializer
    queryset = Student.objects.all()


class ClassroomViewSet(ModelViewSet):
    serializer_class = ClassroomSerializer
    queryset = Classroom.objects.all()

from rest_framework.routers import DefaultRouter
from .views import StudentViewSet, ClassroomViewSet

router = DefaultRouter()
router.register(r'students', StudentViewSet)
router.register(r'classrooms', ClassroomViewSet)

urlpatterns = router.urls

from django.contrib import admin
from django.urls import path,include
urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

[
    {
        "name": "alex",
        "classroom": 1
    },
    {
        "name": "mary",
        "classroom": 2
    },
    {
        "name": "kk",
        "classroom": 3
    }
]

class StudentViewSet(ModelViewSet):
    serializer_class = StudentSerializer
    queryset = Student.objects.all()

    # 通過(guò)many=True直接改造原有的API，使其可以批量創(chuàng)建
    def get_serializer(self, *args, **kwargs):
        serializer_class = self.get_serializer_class()
        kwargs.setdefault('context', self.get_serializer_context())
        if isinstance(self.request.data, list):
            return serializer_class(many=True, *args, **kwargs)
        else:
            return serializer_class(*args, **kwargs)

from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom
from rest_framework import status
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from rest_framework.decorators import action



class StudentViewSet(ModelViewSet):
    serializer_class = StudentSerializer
    queryset = Student.objects.all()

    # 通過(guò)many=True直接改造原有的API，使其可以批量創(chuàng)建
    def get_serializer(self, *args, **kwargs):
        serializer_class = self.get_serializer_class()
        kwargs.setdefault('context', self.get_serializer_context())
        if isinstance(self.request.data, list):
            return serializer_class(many=True, *args, **kwargs)
        else:
            return serializer_class(*args, **kwargs)

    # 新增一個(gè)批量刪除的API。刪除單個(gè)對(duì)象，依然建議使用原API
    # 通過(guò)DELETE訪問(wèn)訪問(wèn)url domain.com/students/multiple_delete/?pks=4,5
    @action(methods=['delete'], detail=False)
    def multiple_delete(self, request, *args, **kwargs):
        # 獲取要?jiǎng)h除的對(duì)象們的主鍵值
        pks = request.query_params.get('pks', None)
        if not pks:
            return Response(status=status.HTTP_404_NOT_FOUND)
        for pk in pks.split(','):
            get_object_or_404(Student, id=int(pk)).delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

from rest_framework.viewsets import ModelViewSet
from .serializers import StudentSerializer, ClassroomSerializer
from .models import Student, Classroom
from rest_framework import status
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from rest_framework.decorators import action



class StudentViewSet(ModelViewSet):
    serializer_class = StudentSerializer
    queryset = Student.objects.all()

    # 通過(guò)many=True直接改造原有的API，使其可以批量創(chuàng)建
    def get_serializer(self, *args, **kwargs):
        serializer_class = self.get_serializer_class()
        kwargs.setdefault('context', self.get_serializer_context())
        if isinstance(self.request.data, list):
            return serializer_class(many=True, *args, **kwargs)
        else:
            return serializer_class(*args, **kwargs)

    # 新增一個(gè)批量刪除的API。刪除單個(gè)對(duì)象，依然建議使用原API
    # 通過(guò)DELETE訪問(wèn)訪問(wèn)url domain.com/students/multiple_delete/?pks=4,5
    @action(methods=['delete'], detail=False)
    def multiple_delete(self, request, *args, **kwargs):
        pks = request.query_params.get('pks', None)
        if not pks:
            return Response(status=status.HTTP_404_NOT_FOUND)
        for pk in pks.split(','):
            get_object_or_404(Student, id=int(pk)).delete()
        return Response(status=status.HTTP_204_NO_CONTENT)

    # 新增一個(gè)批量修改的API。更新單個(gè)對(duì)象，依然建議使用原API
    # 通過(guò)PUT方法訪問(wèn)url domain.com/students/multiple_update/
    # 發(fā)送json格式的數(shù)據(jù)，數(shù)據(jù)是個(gè)列表，列表中的每一項(xiàng)是個(gè)字典，每個(gè)字典是一個(gè)實(shí)例
    @action(methods=['put'], detail=False)
    def multiple_update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instances = []  # 這個(gè)變量是用于保存修改過(guò)后的對(duì)象，返回給前端
        for item in request.data:  # 遍歷列表中的每個(gè)對(duì)象字典
            instance = get_object_or_404(Student, id=int(item['id']))  # 通過(guò)ORM查找實(shí)例
            # 構(gòu)造序列化對(duì)象，注意partial=True表示允許局部更新
            # 由于我們前面重寫了get_serializer方法，進(jìn)行了many=True的判斷。
            # 但此處不需要many=True的判斷，所以必須調(diào)用父類的get_serializer方法
            serializer = super().get_serializer(instance, data=item, partial=partial)
            serializer.is_valid(raise_exception=True)
            serializer.save()
            instances.append(serializer.data)  # 將數(shù)據(jù)添加到列表中
        return Response(instances)

[
    {
        "id":2,
    	"name":"tom",
    	"classroom":3
    },
    {
        "id":3,
        "name":"jack",
        "classroom":2
    }
]

$ pip install djangorestframework-bulk

from rest_framework.serializers import ModelSerializer
from .models import Student
from rest_framework_bulk import (
    BulkListSerializer,
    BulkSerializerMixin,
    BulkModelViewSet
)
from rest_framework.filters import SearchFilter

# 序列化器。暫時(shí)寫在視圖模塊里
# 必須先繼承BulkSerializerMixin，由它將只讀字段id的值寫回到validated_data中，才能實(shí)現(xiàn)更新操作。
class StudentSerializer(BulkSerializerMixin, ModelSerializer):
    class Meta(object):
        model = Student
        fields = '__all__'
        
        # 在Meta類下面的list_serializer_class選項(xiàng)用來(lái)修改當(dāng)`many=True`時(shí)使用的類。
        # 默認(rèn)情況下，DRF使用的是ListSerializer。
        # 但是ListSerializer沒(méi)有實(shí)現(xiàn)自己的批量update方法。
        # 在DRF3中如果需要批量更新對(duì)象，則需定義此屬性，并編寫ListSerializer的子類
        # 所以bulk庫(kù)提供了一個(gè)BulkListSerializer類
        # 它直接繼承了ListSerializer，并重寫了update方法。
        list_serializer_class = BulkListSerializer
        
        # 這條可以不寫。但實(shí)際上，批量刪除需要搭配過(guò)濾操作
        filter_backends = (SearchFilter,) 

# 視圖集
class StudentView(BulkModelViewSet):
    queryset = Student.objects.all()
    serializer_class = StudentSerializer

    def allow_bulk_destroy(self, qs, filtered):
        # 這里作為例子，簡(jiǎn)單粗暴地直接允許批量刪除
        return True

# 批量查詢
GET    http://127.0.0.1/students/


# 創(chuàng)建單個(gè)對(duì)象
POST  	http://127.0.0.1/students/
body   {"field":"value","field2":"value2"}    發(fā)送字典格式的json數(shù)據(jù)


# 創(chuàng)建多個(gè)對(duì)象
POST 	http://127.0.0.1/students/
body	[{"field":"value","field2":"value2"}]   發(fā)送列表格式的json數(shù)據(jù)


# 更新多個(gè)對(duì)象（需要提供所有字段的值）
PUT 	http://127.0.0.1/students/
body	[{"field":"value","field2":"value2"}]   發(fā)送列表格式的json數(shù)據(jù)


# 局部更新多個(gè)對(duì)象（不需要提供所有字段的值）
PATCH 	http://127.0.0.1/students/
body 	[{"field":"value"}]                     發(fā)送列表格式的json數(shù)據(jù)


# 刪除多個(gè)對(duì)象
DELETE   http://127.0.0.1/students/

from rest_framework_bulk.routes import BulkRouter
from .views import StudentView

router = BulkRouter()
router.register(r'students', StudentView)

urlpatterns = router.urls

[
    {
        "name": "s1",
        "classroom": 1
    },
    {
        "name": "s2",
        "classroom": 3
    },
    {
        "name": "s3",
        "classroom": 2
    }
]

class FooSerializer(BulkSerializerMixin, ModelSerializer):
    class Meta(object):
        model = FooModel
        list_serializer_class = BulkListSerializer
        update_lookup_field = 'slug'

class FooView(BulkDestroyAPIView):
    def allow_bulk_destroy(self, qs, filtered):
        # 你的自定義業(yè)務(wù)邏輯寫在這里

        # qs參數(shù)是一個(gè)查詢集，它來(lái)自self.get_queryset()
        # 默認(rèn)要檢查qs是否被過(guò)濾了。
        # filtered參數(shù)來(lái)自self.filter_queryset(qs)
        return qs is not filtered   # 最終返回True，則執(zhí)行刪除操作。返回False，則不執(zhí)行。

__version__ = '0.2.1'
__author__ = 'Miroslav Shubernetskiy'

try:
    from .generics import *  # noqa
    from .mixins import *  # noqa
    from .serializers import *  # noqa
except Exception:
    pass

# 這是用于Python版本兼容，print方法和Unicode字符
from __future__ import print_function, unicode_literals
import rest_framework

if str(rest_framework.__version__).startswith('2'):
    from .drf2.serializers import *  # noqa
else:
    from .drf3.serializers import *  # noqa

from __future__ import print_function, unicode_literals
import rest_framework

if str(rest_framework.__version__).startswith('2'):
    from .drf2.mixins import *  # noqa
else:
    from .drf3.mixins import *  # noqa

from __future__ import unicode_literals, print_function
import copy
from rest_framework.routers import DefaultRouter, SimpleRouter


__all__ = [
    'BulkRouter',
]


class BulkRouter(DefaultRouter):
    """
    將http的method映射到bulk的minxins中的處理函數(shù)
    """
    routes = copy.deepcopy(SimpleRouter.routes)
    routes[0].mapping.update({
        'put': 'bulk_update',
        'patch': 'partial_bulk_update',
        'delete': 'bulk_destroy',
    })

from __future__ import unicode_literals, print_function
from rest_framework import mixins
from rest_framework.generics import GenericAPIView
from rest_framework.viewsets import ModelViewSet

from . import mixins as bulk_mixins


__all__ = [
    'BulkCreateAPIView',
    'BulkDestroyAPIView',
    'BulkModelViewSet',
    'BulkUpdateAPIView',
    'ListBulkCreateAPIView',
    'ListBulkCreateDestroyAPIView',
    'ListBulkCreateUpdateAPIView',
    'ListBulkCreateUpdateDestroyAPIView',
    'ListCreateBulkUpdateAPIView',
    'ListCreateBulkUpdateDestroyAPIView',
]


# ################################################## #
# 下面是一些具體的視圖類。通過(guò)將mixin類與基視圖組合來(lái)提供方法處理程序。
# 基本前面繼承一堆mixins，后面繼承GenericAPIView
# ################################################## #

# 批量創(chuàng)建
class BulkCreateAPIView(bulk_mixins.BulkCreateModelMixin,
                        GenericAPIView):
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

# 批量更新（局部和整體）
class BulkUpdateAPIView(bulk_mixins.BulkUpdateModelMixin,
                        GenericAPIView):
    def put(self, request, *args, **kwargs):
        return self.bulk_update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_bulk_update(request, *args, **kwargs)

# 批量刪除
class BulkDestroyAPIView(bulk_mixins.BulkDestroyModelMixin,
                         GenericAPIView):
    def delete(self, request, *args, **kwargs):
        return self.bulk_destroy(request, *args, **kwargs)

# 批量查看和創(chuàng)建
# 注意批量查看依然使用的是DRF原生的ListModelMixin提供的功能
class ListBulkCreateAPIView(mixins.ListModelMixin,
                            bulk_mixins.BulkCreateModelMixin,
                            GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

# 批量查看、單個(gè)創(chuàng)建、批量更新
class ListCreateBulkUpdateAPIView(mixins.ListModelMixin,
                                  mixins.CreateModelMixin,
                                  bulk_mixins.BulkUpdateModelMixin,
                                  GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.bulk_update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_bulk_update(request, *args, **kwargs)


class ListCreateBulkUpdateDestroyAPIView(mixins.ListModelMixin,
                                         mixins.CreateModelMixin,
                                         bulk_mixins.BulkUpdateModelMixin,
                                         bulk_mixins.BulkDestroyModelMixin,
                                         GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.bulk_update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_bulk_update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.bulk_destroy(request, *args, **kwargs)


class ListBulkCreateUpdateAPIView(mixins.ListModelMixin,
                                  bulk_mixins.BulkCreateModelMixin,
                                  bulk_mixins.BulkUpdateModelMixin,
                                  GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.bulk_update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_bulk_update(request, *args, **kwargs)


class ListBulkCreateDestroyAPIView(mixins.ListModelMixin,
                                   bulk_mixins.BulkCreateModelMixin,
                                   bulk_mixins.BulkDestroyModelMixin,
                                   GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.bulk_destroy(request, *args, **kwargs)

# 這個(gè)功能最全面
class ListBulkCreateUpdateDestroyAPIView(mixins.ListModelMixin,
                                         bulk_mixins.BulkCreateModelMixin,
                                         bulk_mixins.BulkUpdateModelMixin,
                                         bulk_mixins.BulkDestroyModelMixin,
                                         GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.bulk_update(request, *args, **kwargs)

    def patch(self, request, *args, **kwargs):
        return self.partial_bulk_update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.bulk_destroy(request, *args, **kwargs)


# ########################################################## #
# 專門提供的一個(gè)viewset，搭配了批量創(chuàng)建、更新和刪除功能
# 它需要搭配bulk的router模塊使用。
# 如果不用這個(gè)，就用ListBulkCreateUpdateDestroyAPIView
# ########################################################## #

class BulkModelViewSet(bulk_mixins.BulkCreateModelMixin,
                       bulk_mixins.BulkUpdateModelMixin,
                       bulk_mixins.BulkDestroyModelMixin,
                       ModelViewSet):
    pass

from __future__ import print_function, unicode_literals
from rest_framework import status
from rest_framework.mixins import CreateModelMixin
from rest_framework.response import Response


__all__ = [
    'BulkCreateModelMixin',
    'BulkDestroyModelMixin',
    'BulkUpdateModelMixin',
]


class BulkCreateModelMixin(CreateModelMixin):
    """
    Django REST >= 2.2.5.以后的版本多了一個(gè)many=True的參數(shù)。
    通過(guò)這個(gè)參數(shù)，可以實(shí)現(xiàn)單個(gè)和批量創(chuàng)建實(shí)例的統(tǒng)一操作。
    其本質(zhì)是使用DRF提供的ListSerializer類
    """
	# 重寫create方法
    def create(self, request, *args, **kwargs):
        # 通過(guò)判斷request.data變量是列表還是字典，來(lái)區(qū)分是單體操作還是批量操作。
        # 這要求我們前端發(fā)送json格式的數(shù)據(jù)時(shí)，必須定義好數(shù)據(jù)格式
        bulk = isinstance(request.data, list)

        if not bulk: # 如果不是批量操作，則調(diào)用父類的單體創(chuàng)建方法
            return super(BulkCreateModelMixin, self).create(request, *args, **kwargs)

        else:  # 如果是批量操作，則添加many=True參數(shù)
            serializer = self.get_serializer(data=request.data, many=True)
            serializer.is_valid(raise_exception=True)
            # 這里少了DRF源碼中的headers = self.get_success_headers(serializer.data)         
            self.perform_bulk_create(serializer)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
	# 這是個(gè)鉤子方法
    def perform_bulk_create(self, serializer):
        return self.perform_create(serializer)


class BulkUpdateModelMixin(object):
    """
	同樣是通過(guò)many=True參數(shù)來(lái)實(shí)現(xiàn)批量更新
    """
	# 重寫單個(gè)對(duì)象的獲取
    def get_object(self):
        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
		# 這個(gè)if執(zhí)行的是父類的操作
        if lookup_url_kwarg in self.kwargs:
            return super(BulkUpdateModelMixin, self).get_object()
		# 如果沒(méi)有攜帶id，則直接返回，什么都不做。
        # 也就是  PUT 	http://127.0.0.1/students/
        # 和	    PUT	 http://127.0.0.1/students/1/的區(qū)別
        return
	
    # 核心的更新方法
    def bulk_update(self, request, *args, **kwargs):
        # 先看看是PUT還是PATCH
        partial = kwargs.pop('partial', False)

        # 限制只對(duì)過(guò)濾后的查詢集進(jìn)行更新
        # 下面的代碼就是基本的DRF反序列化套路
        # 核心是instances是個(gè)過(guò)濾集，many指定為True，partial根據(jù)方法來(lái)變
        # 這里的邏輯是將單體更新當(dāng)作只有一個(gè)元素的列表來(lái)更新（也就是批量為1）。
        serializer = self.get_serializer(
            self.filter_queryset(self.get_queryset()),
            data=request.data,
            many=True,
            partial=partial,
        )
        serializer.is_valid(raise_exception=True)
        self.perform_bulk_update(serializer)
        return Response(serializer.data, status=status.HTTP_200_OK)
	
    # 如果是PATCH方法，則手動(dòng)添加partial=True參數(shù)，表示局部更新
    # 實(shí)際執(zhí)行的方法和整體更新一樣，都是調(diào)用bulk_update方法
    def partial_bulk_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.bulk_update(request, *args, **kwargs)
	
    # 鉤子方法
    def perform_update(self, serializer):
        serializer.save()
	# 鉤子方法
    def perform_bulk_update(self, serializer):
        return self.perform_update(serializer)


# 刪除操作
class BulkDestroyModelMixin(object):
    """
    用于刪除模型實(shí)例
    """

    def allow_bulk_destroy(self, qs, filtered):
        """
        這是一個(gè)鉤子，用于確保批量刪除操作是安全的。
        默認(rèn)情況下，它會(huì)檢查刪除操作是否在一個(gè)過(guò)濾集上進(jìn)行，不能對(duì)原始查詢集也就是qs進(jìn)行刪除。
		最終的返回值是布爾值，如果返回True，表示允許刪除，否則拒絕。
		源碼這里是簡(jiǎn)單地比較了qs和filtered是否相同，你可以自定義判斷邏輯。
		刪除操作可以配合過(guò)濾后端。
        """
        return qs is not filtered
	# DELETE方法將被轉(zhuǎn)發(fā)到這里
    def bulk_destroy(self, request, *args, **kwargs):
        # 首先，獲取查詢集
        qs = self.get_queryset()
		# 獲取過(guò)濾集
        filtered = self.filter_queryset(qs)
        # 調(diào)用allow_bulk_destroy方法，判斷是否允許該刪除操作
        if not self.allow_bulk_destroy(qs, filtered):
            # 如果不允許，返回400響應(yīng)，錯(cuò)誤的請(qǐng)求
            return Response(status=status.HTTP_400_BAD_REQUEST)
		# 否則對(duì)過(guò)濾集執(zhí)行批量刪除操作
        self.perform_bulk_destroy(filtered)

        return Response(status=status.HTTP_204_NO_CONTENT)
	
    # 這個(gè)刪除方法，其實(shí)就是ORM的delete方法
    # 之所以設(shè)置這個(gè)方法，其實(shí)就是個(gè)鉤子，方便我們自定義
    def perform_destroy(self, instance):
        instance.delete()
	
    # 批量刪除很簡(jiǎn)單，就是遍歷過(guò)濾集，逐個(gè)刪除
    def perform_bulk_destroy(self, objects):
        for obj in objects:
            self.perform_destroy(obj)

from __future__ import print_function, unicode_literals
import inspect  # Python內(nèi)置模塊。從活動(dòng)的Python對(duì)象獲取有用的信息。

from rest_framework.exceptions import ValidationError
from rest_framework.serializers import ListSerializer


__all__ = [
    'BulkListSerializer',
    'BulkSerializerMixin',
]

# 由于DRF源碼在默認(rèn)情況下，會(huì)將只讀字段的值去掉，所以id主鍵值不會(huì)出現(xiàn)在validated_data中
# 因?yàn)槲覀儸F(xiàn)在需要批量更新對(duì)象，url中也沒(méi)有攜帶對(duì)象的id，所以我們需要手動(dòng)將id的值添加回去。
class BulkSerializerMixin(object):
    # 由外部數(shù)據(jù)轉(zhuǎn)換為Python內(nèi)部字典
    def to_internal_value(self, data):
        # 先調(diào)用父類的方法，獲得返回值
        ret = super(BulkSerializerMixin, self).to_internal_value(data)
		# 去Meta元類中看看，有沒(méi)有指定'update_lookup_field'屬性，如果沒(méi)有，默認(rèn)使用id
        # 這本質(zhì)就是個(gè)鉤子，允許我們自定義主鍵字段
        id_attr = getattr(self.Meta, 'update_lookup_field', 'id')
        # 獲取當(dāng)前請(qǐng)求的類型
        request_method = getattr(getattr(self.context.get('view'), 'request'), 'method', '')
		
        # 如果下面的三個(gè)條件都滿足：
        # self.root是BulkListSerializer的實(shí)例
        # id_attr變量不為空
        # 請(qǐng)求的方法是'PUT'或'PATCH'
        # 那么執(zhí)行if語(yǔ)句中的代碼
        if all((isinstance(self.root, BulkListSerializer),
                id_attr,
                request_method in ('PUT', 'PATCH'))):
            # 拿到id字段的句柄
            id_field = self.fields[id_attr]
            # 拿到字段的值	
            id_value = id_field.get_value(data)
			# 為ret追加鍵值對(duì)
            ret[id_attr] = id_value

        return ret

# 這個(gè)類主要是在ListSerializer基礎(chǔ)上重寫的update邏輯，實(shí)現(xiàn)批量操作
class BulkListSerializer(ListSerializer):
    # 指定用于更新的查詢字段為id
    update_lookup_field = 'id'

    def update(self, queryset, all_validated_data):
        # 先看看有沒(méi)有指定用于查詢的字段
        id_attr = getattr(self.child.Meta, 'update_lookup_field', 'id')
		# 通過(guò)id去獲取所有的鍵值對(duì)
        # 下面是一個(gè)字典推導(dǎo)式
        all_validated_data_by_id = {
            i.pop(id_attr): i
            for i in all_validated_data
        }
		# 對(duì)數(shù)據(jù)類型做判斷
        if not all((bool(i) and not inspect.isclass(i)
                    for i in all_validated_data_by_id.keys())):
            raise ValidationError('')


        # 使用ORM從查詢集中過(guò)濾出那些需要更新的模型實(shí)例
        # 比如id__in=[1,3,4]
        objects_to_update = queryset.filter(**{
            '{}__in'.format(id_attr): all_validated_data_by_id.keys(),
        })
		# 如果過(guò)濾出來(lái)的模型實(shí)例數(shù)量和用于更新的數(shù)據(jù)數(shù)量不一致，彈出異常
        if len(all_validated_data_by_id) != objects_to_update.count():
            raise ValidationError('Could not find all objects to update.')
		# 準(zhǔn)備一個(gè)空列表，用于保存將要被更新的實(shí)例
        updated_objects = []
		# 循環(huán)每個(gè)實(shí)例
        for obj in objects_to_update:
            obj_id = getattr(obj, id_attr)
            obj_validated_data = all_validated_data_by_id.get(obj_id)
            # 使用模型序列化器的update方法進(jìn)行實(shí)際的更新動(dòng)作，以防update方法在別的地方被覆蓋
            updated_objects.append(self.child.update(obj, obj_validated_data))

        return updated_objects