首页 > 其他分享 >drf-过滤、排序、分页

drf-过滤、排序、分页

时间：2023-05-27 20:23:21浏览次数：39  
标签：分页 get self queryset page 过滤 排序 price drf

目录

一 过滤Filtering

前提条件:

  • 带过滤的接口只有：查询所有
  • 必须是继承GenericAPIView及其子类，才能用。
  • 过滤有三种方式
# restful规范中
	-请求地址中带过滤条件

# 加快筛选速度的方法：使用多个过滤类时，最左侧直接把大部分数据过滤掉。

1.1 内置过滤类

from rest_framework.filters import SearchFilter

class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [SearchFilter, ]
    # 配合的字段
    # search_fields = ['name']
    # 只支持这种搜索方式，模糊匹配
    # http://127.0.0.1:8000/api/v1/books/?search=红

    # 多个字段
    # http://127.0.0.1:8000/api/v1/books/?search=33  只要name或price中带33都能搜出来
    search_fields = ['name', 'price']

1.2 第三方过滤类

# pip3 install django-filter
from django_filters.rest_framework import DjangoFilterBackend

class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [DjangoFilterBackend, ]
    # 配合的字段
    # filterset_fields = ['name']
    # 可以使用字段名，精准匹配
    # http://127.0.0.1:8000/api/v1/books/?name=红楼梦

    # 多个字段
    # http://127.0.0.1:8000/api/v1/books/?name=红楼梦&price=2
    # 按名字和价格精准匹配
    filterset_fields = ['name', 'price']

1.3 自定义过滤类

价格等于44或者书名是红楼梦

视图类：

from .filter import MyFilter

class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [MyFilter, ]
    # 自己写的过滤类，返回的数据，就是过滤后的数据，所以不需要配合字段了
    # 地址：http://127.0.0.1:8000/api/v1/books/?price=44&name=红楼梦

filter.py文件

from rest_framework.filters import BaseFilterBackend
from django.db.models import Q

# 自己写的过滤类
class MyFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        # queryset是要序列化的数据对象，queryset对象
        # 返回的数据，就是过滤后的数据
        # http://127.0.0.1:8000/api/v1/books/?price=44&name=红楼梦   按名字或价格
        # 地址中就只能写这种，我们要自己获取问号后的数据，然后自己写过滤条件
        price = request.query_params.get('price')
        name = request.query_params.get('name')
        queryset = queryset.filter(Q(name=name) | Q(price=price))
        return queryset

价格在100----200之间的图书

filter.py文件：

class ChangeFilter(BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        # 前端传入的数据是: http://127.0.0.1:8000/api/v1/books/?min_price=100&max_price=200
        min_price = request.query_params.get('min_price')
        max_price = request.query_params.get('max_price')
        # queryset = queryset.filter(price__range=[min_price, max_price])
        queryset = queryset.filter(price__gte=min_price, price__lte=max_price)
        return queryset

二 排序

前提条件:

  • 带过滤的接口只有：查询所有
  • 必须是继承GenericAPIView及其子类，才能用。
  • 过滤有三种方式

对于列表数据，REST framework提供了OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序。

使用方法：

在类视图中设置filter_backends，使用rest_framework.filters.OrderingFilter过滤器，REST framework会在请求的查询字符串参数中检查是否包含了ordering参数，如果包含了ordering参数，则按照ordering参数指明的排序字段对数据集进行排序。

前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。

视图类

# restful规范中
	-请求地址中带过滤条件
# 排序功能的接口：查询所有
# 必须是继承GenericAPIView及其子类，才能用，drf提供了要给排序类，用它的就可以了。
# 如果继承APIViwe，不能这么用

from rest_framework.filters import OrderingFilter


class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [OrderingFilter]  # 排序类
    # 配合一个类属性,按哪些字段可以排序
    # 1.单个字段
    # 地址写法：http://127.0.0.1:8000/api/v1/books/?ordering=price
    # 按照价格字段升序
    # ordering_fields = ['price']
    # /?ordering=-price，按照价格降序，地址中字段前面加符号

    # 2.多个字段
    ordering_fields = ['price', 'id']
    # http://127.0.0.1:8000/api/v1/books/?ordering=-price,id
    # 先按价格倒序排，价格一样，再按id升序排
    # http://127.0.0.1:8000/api/v1/books/?ordering=-price
    # 写了多个字段可以只使用1个

过滤和排序一起使用

# 过滤和排序可以一起使用
from rest_framework.filters import OrderingFilter
from rest_framework.filters import SearchFilter


class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [SearchFilter, OrderingFilter]
    search_fields = ['name', 'price']
    ordering_fields = ['price']
    # 地址：http://127.0.0.1:8000/api/v1/books/?search=33&ordering=price

三 分页Pagination

查询所有的接口都需要有分页功能。

    -分页的展现形式
    	web：下一页点解
        app，小程序：下滑下一页
    -接口都一样，要支持分页

视图类

# drf提供给咱们，三种分页方式
# 基本分页
# 偏移分页
# 游标分页


from .page import MyPageNumberPagination,MyLimitOffsetPagination,MyCursorPagination
# 这种方式用的多
class BookView(GenericViewSet, ListModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier
    # http://127.0.0.1:8000/api/v1/books/?page=2&page_size=3
    # pagination_class = MyPageNumberPagination  # 只能按一种方式分页，不要放到列表中了

    # http://127.0.0.1:8000/api/v1/books/?limit=4&offset=3  # 从第三条数据开始，取4条
    # pagination_class = MyLimitOffsetPagination  # 只能按一种方式分页，不要放到列表中了

    # 只能点击上一页或下一页
    # http://127.0.0.1:8000/api/v1/books/
    pagination_class = MyCursorPagination  # 只能按一种方式分页，不要放到列表中了

page.py

from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination


## 基本分页
class MyPageNumberPagination(PageNumberPagination):
    # 重写几个类属性 ：4个
    page_size = 2  # 每页显示的条数
    page_query_param = 'page'  # page=4 表示当前是第4页
    page_size_query_param = 'page_size'  # page=4&page_size=5 表示查询第4页，每页显示5条
    max_page_size = 5  # 每页最大显示多少条


## 偏移分页
class MyLimitOffsetPagination(LimitOffsetPagination):
    # 重写几个类属性 ：4个
    default_limit = 2  # 每页显示多少条
    limit_query_param = 'limit'  # limit=3  这一页取3条
    offset_query_param = 'offset'  # 偏移量是多少  offset=3&limit=2  从第3条开始，拿2条
    max_limit = 5  # 最多取5条


## 游标分页,只能上一页和下一页，不能直接跳到某一页，但是这个的速度快---> app上用它多
class MyCursorPagination(CursorPagination):
    # 重写几个类属性 ：3个
    cursor_query_param = 'cursor'  # 查询参数，其实用不到
    page_size = 2  # 每页显示多少条
    ordering = 'id'  # 必须是要分页的数据表中的字段，一般按id来

四 基于APIView写过滤、排序和分页

上面都是继承GenericAPIView写的，现在我们来继承APIView写这三种形式。

4.1 写过滤和排序

# 继承了APIView就不能用drf自己的内置类了，针对的不同情况就需要我们自己判断了
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Book
from .serializer import BookSerializer


class BookView(APIView):
    # 前端传入的网址：
    # /books/?ordering=-price&name=红楼梦
    def get(self, request):
        # 取出地址中过滤条件的参数
        ordering = request.query_params.get('ordering')
        name = request.query_params.get('name')
        book_list = Book.objects.all()
        if name:  # 过滤
            book_list = book_list.filter(name__contains='红')
        if ordering:  # 排序
            book_list = book_list.order_by(ordering)
        ser = BookSerializer(instance=book_list, many=True)
        return Response({'code': 100, 'msg': '查询成功', 'data': ser.data})

    
# 查询地址:http://127.0.0.1:8000/book/?ordering=-price&name=%E7%BA%A2
# 路由：
    path('book/', views.BookView.as_view()),

4.2 写分页

from rest_framework.mixins import ListModelMixin
from rest_framework.generics import GenericAPIView
from .serializer import BookSerializer
from rest_framework.views import APIView
from rest_framework.response import Response

from .page import MyPageNumberPagination


class BookView(APIView):
    def get(self, request):
        ordering = request.query_params.get('ordering')
        name = request.query_params.get('name')
        book_list = Book.objects.all()
        if ordering:
            book_list = book_list.order_by(ordering)
        if name:
            book_list = book_list.filter(name__contains=name)


        # 加入分页

        # page=MyPageNumberPagination().paginate_queryset(book_list, request,self)
        # 得到分页对象
        pagination = MyPageNumberPagination()
        # 分页对象调用它的paginate_queryset方法
        page = pagination.paginate_queryset(book_list, request, self)
        # 把page序列化
        ser = BookSerializer(instance=page, many=True)
        # 分页类对象调用分页父类中的get_paginated_response方法
        return pagination.get_paginated_response(ser.data)
        # 模仿get_paginated_response中的返回值Response
        return Response({'code': 100, 'msg': '成功',
                         'count': pagination.page.paginator.count,
                         'next': pagination.get_next_link(),
                         'previous': pagination.get_previous_link(),
                         'results': ser.data})


''' 根据源码写自己的分页
# 配置的分页类的对象调用了paginate_queryset(queryset, self.request, view=self)
page = self.paginate_queryset(queryset) #  是paginate_queryset的GenericAPIView
##### 重写了这句话

if page is not None:
    # 把page进行了序列化
   serializer = self.get_serializer(page, many=True)
   # 返回格式
   return self.get_paginated_response(serializer.data) # GenericAPIView--》self.paginator.get_paginated_response(data)


PageNumberPagination类的get_paginated_response方法
def get_paginated_response(self, data):
    return Response(OrderedDict([
                ('count', self.page.paginator.count),
                ('next', self.get_next_link()),
                ('previous', self.get_previous_link()),
                ('results', data)
            ]))
'''

4.3 分页的源码

-1.入口，查询所有才会有分页，入口就在ListModelMixin类的list方法中
class ListModelMixin:
    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())
        # 视图扩展类不会单独使用，会与GenericAPIView一起使用
	    # self是视图类的对象
        # self.paginate_queryset(queryset)是GenericAPIView中的方法
        # 最后结果是：自己写的分页类的对象调用了它的paginate_queryset(queryset, self.request, view=self)方法，并传了一些参数---> 第4步
        page = self.paginate_queryset(queryset)  # 分页对象
        if page is not None:
            # 把page进行了序列化
            serializer = self.get_serializer(page, many=True)
            # 返回格式  ---> 第5步
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)
    
    
-2. GenericAPIView中的paginate_queryset方法
    def paginate_queryset(self, queryset):
        if self.paginator is None:
            return None
        # self.paginator--> 配置的分页类的对象
        # 分页类对象调用了paginate_queryset方法
        return self.paginator.paginate_queryset(queryset, self.request, view=self)
    
-3.paginator: 是GenericAPIView中方法
    @property
    def paginator(self):
        if not hasattr(self, '_paginator'):
            if self.pagination_class is None:
                self._paginator = None
            else:
                # ***
                # self是视图类的对象
                # 如果分页类存在，就加括号，把对象赋值给self._paginator
                self._paginator = self.pagination_class()
        return self._paginator  # 配置的分页类的对象

-4 PageNumberPagination一个分页类的paginate_queryset方法
class PageNumberPagination(BasePagination):
    def paginate_queryset(self, queryset, request, view=None):
        # 这个只关注传入进来的参数即可
        self.request = request
        return list(self.page)

    
# self.get_paginated_response(serializer.data)    
-5 get_paginated_response这个方法ListModelMixin中没有，所以又找到了GenericAPIView中
    def get_paginated_response(self, data):
        # self是视图类的对象
        # data就是serializer.data，序列化后的数据
        assert self.paginator is not None  # 分页类的对象不是None
        # 返回分页类的对象调用get_paginated_response(serializer.data)方法，并把序列化后的数据传入
        return self.paginator.get_paginated_response(data)
    
    
-6 PageNumberPagination类的get_paginated_response方法
    def get_paginated_response(self, data):
        # self是分页类的对象
        return Response(OrderedDict([
            ('count', self.page.paginator.count),  # 总数量
            ('next', self.get_next_link()),  # 下一页的地址
            ('previous', self.get_previous_link()),  # 上一页的地址
            ('results', data)  # 数据
        ]))

标签：分页,get,self,queryset,page,过滤,排序,price,drf
From： https://www.cnblogs.com/zjyao/p/17437263.html

相关文章

  • drf——全局处理异常、接口文档、jwt介绍、based64编码与解码
    全局异常处理原理#对于前端来讲，后端即便报错，也要返回统一的格式，前端便于处理{code:999,msg:'系统异常，请联系系统管理员'}#只要三大认证，视图类的方法出了异常，都会执行一个函数： rest_framework.viewsimportexception_handler#drf只要出了异常就会执行这是drf的配置文件......
  • 拦截器和过滤器区别
    转载：https://www.bilibili.com/video/BV1ro4y1F7Yg/?spm_id_from=333.1007.tianma.2-2-5.click&vd_source=46d50b5d646b50dcb2a208d3946b1598......
  • drf全局异常处理，接口文档，jwt介绍和原理，base64编码和解码
    drf全局异常处理：只要三大认证，视图类的方法出了异常，都会执行一个函数：rest_framework.viewsimportexception_handlersetting：REST_FRAMEWORK={'EXCEPTION_HANDLER':'app01.exception.commn_exception_handler',#导入自己写的异常类的路径}......
  • drf之全局异常处理和 接口文档
    目录一、全局异常处理注意：exception_handler补充：新建一个exception文件放我们自己写的异常方法配置文件二、接口文档后端把接口写好后接口文档的编写形式使用coreapi自动生成接口文档（文件drf_09）一、全局异常处理对于前端来讲，后端即便报错，也要返回统一的格式，前端便于处理只......
  • 数据结构与算法—排序算法篇
    1、选择排序1.1、算法思想每趟从待排序的数据元素中，选出最小（或最大）的一个元素，顺序放在待排序的数列最前面，直到全部待排序的数据元素排完。1.2、步骤1、查找此数列中的最小元素，将其与第一个交换2、从第二个值开始找，查找到最小元素，将其与第二个交换3、以此类推，直到遍历结束1.3、算法......
  • drf之restful规范中的过滤、排序和分页
    目录一、过滤内置过滤类第三方过滤类自定义过滤类价格再100----200之间的图书二、排序三、分页作业过滤和排序带分页一、过滤restful规范中-请求地址中带过滤条件带过滤的接口只有：查询所有内置过滤类fromrest_framework.filtersimportSearchFilterclassBookView(G......
  • drf——基于apiview写过滤、排序和分页
    基于APIView带过滤和排序fromrest_framework.viewsimportAPIViewfrom.modelsimportBookfrom.serializerimportBookSerializerfromrest_framework.responseimportResponseclassBookView(APIView):#/books/?ordering=-price&name=红楼梦defget(self,......
  • day107-过滤器与监听器
    过滤器filter：过滤器用来过滤网站的数据处理中文乱码登陆验证......导入maven包<dependencies><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.1.0&......
  • Windows驱动开发学习记录-使用Inf安装过滤驱动时自动添加注册表相关内容
     做过滤驱动时一般需要在相关class驱动里添加过滤信息，即LowerFilters或者UpperFilters,比如disk类的注册表当前信息，如下图：一个常规的inf文件如下所示：;;USBFilter.inf;[Version]Signature="$WINDOWSNT$"Class=TOASTERClassGuid={B85B7C50-6A01-11d2-B841-00C04FAD517......
  • 算法之常见排序算法-冒泡排序、归并排序、快速排序
    对于编程中琳琅满目的算法，本人向来是不善此道也不精于此的，而说起排序算法，也只是会冒泡排序。还记得当初刚做开发工作面试第一家公司时，面试官便让手写冒泡排序（入职之后才知道，这面试官就是一个冒泡排序"病态"爱好者，逢面试必考冒泡排序-__-）。后来看吴军的一些文章，提到提高效率的关键就......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99