批量查詢：

    def get(self,request,*args,**kwargs):
        # 查一個
        pk = kwargs.get('pk')
        if pk:
            book_list = models.Book.objects.filter(pk=pk).first()
            book_list_ser = BookModelSerializer(book_list)
            return Response(data=book_list_ser.data)
        # 查所有
        book_list=models.Book.objects.all().filter(is_delete=False)
        book_list_ser=BookModelSerializer(book_list,many=True)
        return Response(data=book_list_ser.data)

批量查詢其他表的處理方式：

#序列化py中的程式碼
class BookModelSerializer(serializers.ModelSerializer):
    # 一種方案（只序列化可以，反序列化有問題）
    # publish=serializers.CharField(source='publish.name')
    # 第二種方案，models中寫方法
    書名 = serializers.CharField(source='name')
    class Meta:
        list_serializer_class = BookListSerializer
        model = models.Book
        # fields = '__all__'
        # 用的少
        # depth=0#直接可以把全部表中的欄位拿出來
        fields = ('id','書名','price','authors','publish','publish_name','author_list')
        extra_kwargs = {
            'publish':{'write_only':True},
            'publish_name':{'read_only':True},
            'authors':{'write_only':True},
            'author_list':{'read_only':True}
        }

class Book(BaseModel):
    id = models.AutoField(primary_key=True)
    # verbose_name admin中顯示中文
    name = models.CharField(max_length=32, verbose_name='書名', help_text='這裡填書名')
    price = models.DecimalField(max_digits=5, decimal_places=2)
    # 一對多的關係一旦確立，關聯欄位寫在多的一方
    # to_field 預設不寫，關聯到Publish主鍵
    # db_constraint=False  邏輯上的關聯，實質上沒有外來鍵練習，增刪不會受外來鍵影響，但是orm查詢不影響
    publish = models.ForeignKey(to='Publish', on_delete=models.DO_NOTHING, db_constraint=False)

    # 多對多，跟作者，關聯欄位寫在 查詢次數多的一方

    # 什麼時候用自動，什麼時候用手動？第三張表只有關聯欄位，用自動    第三張表有擴充套件欄位，需要手動寫
    # 不能寫on_delete
    authors = models.ManyToManyField(to='Author', db_constraint=False)

    class Meta:
        verbose_name_plural = '書表'  # admin中表名的顯示
    def __str__(self):
        return self.name
    @property
    def publish_name(self):
        return self.publish.name

    # def author_list(self):
    def author_list(self):
        author_list = self.authors.all()
        # ll=[]
        # for author in author_list:
        #     ll.append({'name':author.name,'sex':author.get_sex_display()})
        # return ll
        return [{'name': author.name, 'sex': author.get_sex_display()} for author in author_list]

批量增加：

    def post(self,request,*args,**kwargs):
        # 具備增單條，和增多條的功能
        if isinstance(request.data,dict):
            book_ser=BookModelSerializer(data=request.data)
            book_ser.is_valid(raise_exception=True)
            book_ser.save()
            return Response(data=book_ser.data)
        elif isinstance(request.data,list):
            #現在book_ser是ListSerializer物件
            from rest_framework.serializers import ListSerializer
            book_ser = BookModelSerializer(data=request.data,many=True)  #增多條
            print('--------',type(book_ser))
            book_ser.is_valid(raise_exception=True)
            book_ser.save()
            # 新增---》ListSerializer--》create方法
            # def create(self, validated_data):
            #   self.child是BookModelSerializer物件
            #   print(type(self.child))
            #     return [
            #         self.child.create(attrs) for attrs in validated_data
            #     ]
            return Response(data=book_ser.data)

批量增加內部處理方式

 #內部判斷many
 def __new__(cls, *args, **kwargs):
        # We override this method in order to automatically create
        # `ListSerializer` classes instead when `many=True` is set.
        if kwargs.pop('many', False):
            #many為真
            return cls.many_init(*args, **kwargs)
        return super().__new__(cls, *args, **kwargs)

#many為真
        meta = getattr(cls, 'Meta', None)
        list_serializer_class = getattr(meta, 'list_serializer_class', ListSerializer)
        return list_serializer_class(*args, **list_kwargs)