一、版本

程序也来越大时，可能通过版本不同做不同的处理

没用rest_framework之前，我们可以通过以下这样的方式去获取。

  1.  class UserView(APIView):
  2.      def get(self,request,*args,**kwargs):
  3.          version = request.query_params.get('version')
  4.          print(version)
  5.          if version=='v1':
  6.              #如果版本是v1
  7.              ret = {
  8.                  'code':111,
  9.                  'msg':'版本一的内容'
  10.              }
  11.  
  12.          elif version=='v2':
  13.              # 如果是v2
  14.              ret = {
  15.                  'code': 112,
  16.                  'msg': '版本二的内容'
  17.              }
  18.          else:
  19.              ret = {
  20.                  'code': 0,
  21.                  'msg': '不支持其他版本'
  22.              }
  23.          return Response(ret)

现在我们来用rest_framework实现一下

a. 基于url的get传参方式

如：/users?version=v1

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_VERSION': 'v1',            # 默认版本
  3.     'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
  4.     'VERSION_PARAM': 'version'          # URL中获取值的key
  5. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'^test/', TestView.as_view(),name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.versioning import QueryParameterVersioning
  6.  
  7. class TestView(APIView):
  8.     versioning_class = QueryParameterVersioning
  9.  
  10.     def get(self, request, *args, **kwargs):
  11.  
  12.         # 获取版本
  13.         print(request.version)
  14.         # 获取版本管理的类
  15.         print(request.versioning_scheme)
  16.  
  17.         # 反向生成URL
  18.         reverse_url = request.versioning_scheme.reverse('test', request=request)
  19.         print(reverse_url)
  20.  
  21.         return Response('GET请求，响应内容')
  22.  
  23.     def post(self, request, *args, **kwargs):
  24.         return Response('POST请求，响应内容')
  25.  
  26.     def put(self, request, *args, **kwargs):
  27.         return Response('PUT请求，响应内容')

views.py

b. 基于url的正则方式

如：/v1/users/

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_VERSION': 'v1',            # 默认版本
  3.     'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
  4.     'VERSION_PARAM': 'version'          # URL中获取值的key
  5. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'^(?P<version>[v1|v2]+)/test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.versioning import URLPathVersioning
  6.  
  7. class TestView(APIView):
  8.     versioning_class = URLPathVersioning
  9.  
  10.     def get(self, request, *args, **kwargs):
  11.         # 获取版本
  12.         print(request.version)
  13.         # 获取版本管理的类
  14.         print(request.versioning_scheme)
  15.  
  16.         # 反向生成URL
  17.         reverse_url = request.versioning_scheme.reverse('test', request=request)
  18.         print(reverse_url)
  19.  
  20.         return Response('GET请求，响应内容')
  21.  
  22.     def post(self, request, *args, **kwargs):
  23.         return Response('POST请求，响应内容')
  24.  
  25.     def put(self, request, *args, **kwargs):
  26.         return Response('PUT请求，响应内容')

views.py

c. 基于 accept 请求头方式

如：Accept: application/json; version=1.0

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_VERSION': 'v1',            # 默认版本
  3.     'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本
  4.     'VERSION_PARAM': 'version'          # URL中获取值的key
  5. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'^test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.versioning import AcceptHeaderVersioning
  6.  
  7. class TestView(APIView):
  8.     versioning_class = AcceptHeaderVersioning
  9.  
  10.     def get(self, request, *args, **kwargs):
  11.         # 获取版本 HTTP_ACCEPT头
  12.         print(request.version)
  13.         # 获取版本管理的类
  14.         print(request.versioning_scheme)
  15.         # 反向生成URL
  16.         reverse_url = request.versioning_scheme.reverse('test', request=request)
  17.         print(reverse_url)
  18.  
  19.         return Response('GET请求，响应内容')
  20.  
  21.     def post(self, request, *args, **kwargs):
  22.         return Response('POST请求，响应内容')
  23.  
  24.     def put(self, request, *args, **kwargs):
  25.         return Response('PUT请求，响应内容')

views.py

d. 基于主机名方法

如：v1.example.com

  1. ALLOWED_HOSTS = ['*']
  2. REST_FRAMEWORK = {
  3.     'DEFAULT_VERSION': 'v1',  # 默认版本
  4.     'ALLOWED_VERSIONS': ['v1', 'v2'],  # 允许的版本
  5.     'VERSION_PARAM': 'version'  # URL中获取值的key
  6. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'^test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.versioning import HostNameVersioning
  6.  
  7. class TestView(APIView):
  8.     versioning_class = HostNameVersioning
  9.  
  10.     def get(self, request, *args, **kwargs):
  11.         # 获取版本
  12.         print(request.version)
  13.         # 获取版本管理的类
  14.         print(request.versioning_scheme)
  15.         # 反向生成URL
  16.         reverse_url = request.versioning_scheme.reverse('test', request=request)
  17.         print(reverse_url)
  18.  
  19.         return Response('GET请求，响应内容')
  20.  
  21.     def post(self, request, *args, **kwargs):
  22.         return Response('POST请求，响应内容')
  23.  
  24.     def put(self, request, *args, **kwargs):
  25.         return Response('PUT请求，响应内容')

views.py

  1. #分发url
  2.             urlpatterns = [
  3.                 #url(r'^admin/', admin.site.urls),
  4.                 url(r'^api/', include('api.urls')),
  5.             ]
  6.  
  7.             urlpatterns = [
  8.                 url(r'^users/', views.UsersView.as_view(),name='u'),
  9.             ]
  10.  
  11.             class UsersView(APIView):
  12.  
  13.                 def get(self,request,*args,**kwargs):
  14.                     self.dispatch
  15.                     print(request.version) # QueryParameterVersioning().detemiin_version()
  16.                     print(request.versioning_scheme) # QueryParameterVersioning()
  17.  
  18.             REST_FRAMEWORK = {
  19.                 'VERSION_PARAM':'version',
  20.                 'DEFAULT_VERSION':'v1',
  21.                 'ALLOWED_VERSIONS':['v1','v2'],
  22.                 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning"
  23.             }
  24.  
  25.             # C:\Windows\System32\drivers\etc
  26.             # vim /etc/hosts
  27.             127.0.0.1    v1.luffy.com
  28.             127.0.0.1    v2.luffy.com
  29.  
  30.             #配置ALLOWED_HOSTS = ['*']

基于子域名传参

如果遇到这样的错误

这是由于没有允许，解决办法，在settings里面配置一下

  1. ALLOWED_HOSTS = ['*']

e. 基于django路由系统的namespace

如：example.com/v1/users/

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_VERSION': 'v1',  # 默认版本
  3.     'ALLOWED_VERSIONS': ['v1', 'v2'],  # 允许的版本
  4.     'VERSION_PARAM': 'version'  # URL中获取值的key
  5. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'^v1/', ([
  6.                       url(r'test/', TestView.as_view(), name='test'),
  7.                   ], None, 'v1')),
  8.     url(r'^v2/', ([
  9.                       url(r'test/', TestView.as_view(), name='test'),
  10.                   ], None, 'v2')),
  11.  
  12. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.versioning import NamespaceVersioning
  6.  
  7. class TestView(APIView):
  8.     versioning_class = NamespaceVersioning
  9.  
  10.     def get(self, request, *args, **kwargs):
  11.         # 获取版本
  12.         print(request.version)
  13.         # 获取版本管理的类
  14.         print(request.versioning_scheme)
  15.         # 反向生成URL
  16.         reverse_url = request.versioning_scheme.reverse('test', request=request)
  17.         print(reverse_url)
  18.  
  19.         return Response('GET请求，响应内容')
  20.  
  21.     def post(self, request, *args, **kwargs):
  22.         return Response('POST请求，响应内容')
  23.  
  24.     def put(self, request, *args, **kwargs):
  25.         return Response('PUT请求，响应内容')

views.py

#http://127.0.0.1:8080/api/v1/users/

  1. #urls.py
  2. #分发路由
  3. urlpatterns = [
  4.     url(r'^admin/', admin.site.urls),
  5.     url(r'^api/(?P<version>[v1|v2]+)/', include('api.urls')),
  6. ]
  7.  
  8. #api.urls.py
  9. urlpatterns = [
  10.     url(r'^users/', views.UserView1.as_view(), name='users-list'),
  11. ]
  12.  
  13. #views.py
  14. 导入类
  15. from rest_framework.reverse import reverse
  16. url = request.versioning_scheme.reverse(viewname='users-list',request=request)
  17.         print(url)

restfoamework反向解析

我们自己用django实现的，当前版本不一样的时候可以用这种方式

  1.  from django.urls import reverse
  2.         url = reverse(viewname='users-list',kwargs={'version':'v2'}) #指定的是v2就是v2，当你路径中输入v1的时候还是v2的路径
  3.         print(url) #/api/v2/users/

f. 全局使用

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",
  3.     'DEFAULT_VERSION': 'v1',
  4.     'ALLOWED_VERSIONS': ['v1', 'v2'],
  5.     'VERSION_PARAM': 'version'
  6. }

settings.py

注：在配置的时候

  1. REST_FRAMEWORK = {
  2.                 'VERSION_PARAM':'version',
  3.                 'DEFAULT_VERSION':'v1',
  4.                 'ALLOWED_VERSIONS':['v1','v2'],
  5.                 # 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning" 
     　　　　　　　　　　#如果加上这个配置就不用versioning_class = QueryParameterVersioning这样再指定了，
  1. 　　　　　　　　　　 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning" }

二、解析器（parser） ：reqest.data取值的时候才执行

对请求的数据进行解析：是针对请求体进行解析的。表示服务器可以解析的数据格式的种类

django中的发送请求

  1. #如果是这样的格式发送的数据，在POST里面有值
  2. Content-Type: application/url-encoding.....
  3.     request.body
  4.     request.POST
  5.  
  6. #如果是发送的json的格式，在POST里面是没有值的，在body里面有值，可通过decode,然后loads取值
  7. Content-Type: application/json.....
  8.     request.body
  9.     request.POST

为了这种情况下每次都要decode，loads，显得麻烦，所以才有的解析器。弥补了django的缺点

  1.  客户端：
  2.              Content-Type: application/json
  3.              '{"name":"alex","age":123}'
  4.  
  5.          服务端接收：
  6.              读取客户端发送的Content-Type的值 application/json
  7.  
  8.              parser_classes = [JSONParser,FormParser]  #表示服务器可以解析的数据格式的种类
  9.              media_type_list = ['application/json','application/x-www-form-urlencoded']
  10.  
  11.              如果客户端的Content-Type的值和 application/json 匹配：JSONParser处理数据
  12.              如果客户端的Content-Type的值和 application/x-www-form-urlencoded 匹配：FormParser处理数据
  13.  
  14.          配置：
  15.              单视图：
  16.              class UsersView(APIView):
  17.                  parser_classes = [JSONParser,]
  18.  
  19.              全局配置：
  20.                  REST_FRAMEWORK = {
  21.                      'VERSION_PARAM':'version',
  22.                      'DEFAULT_VERSION':'v1',
  23.                      'ALLOWED_VERSIONS':['v1','v2'],
  24.                      # 'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.HostNameVersioning"
  25.                      'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",
  26.                      'DEFAULT_PARSER_CLASSES':[
  27.                          'rest_framework.parsers.JSONParser',
  28.                          'rest_framework.parsers.FormParser',
  29.                      ]
  30.                  }
  31.  
  32.                  class UserView(APIView):
  33.                      def get(self,request,*args,**kwargs):
  34.                          return Response('ok')
  35.                      def post(self,request,*args,**kwargs):
  36.                          print(request.data)  #以后取值就在这里面去取值
  37.                          return Response('...')

具体讲解

根据请求头 content-type 选择对应的解析器就请求体内容进行处理。

a. 仅处理请求头content-type为application/json的请求体

  1. from django.conf.urls import url, include
  2. from web.views.s5_parser import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.request import Request
  6. from rest_framework.parsers import JSONParser
  7.  
  8. class TestView(APIView):
  9.     parser_classes = [JSONParser, ]
  10.  
  11.     def post(self, request, *args, **kwargs):
  12.         print(request.content_type)
  13.  
  14.         # 获取请求的值，并使用对应的JSONParser进行处理
  15.         print(request.data)
  16.  
  17.         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  18.         print(request.POST)
  19.         print(request.FILES)
  20.  
  21.         return Response('POST请求，响应内容')
  22.  
  23.     def put(self, request, *args, **kwargs):
  24.         return Response('PUT请求，响应内容')

views.py

b. 仅处理请求头content-type为application/x-www-form-urlencoded 的请求体

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.request import Request
  6. from rest_framework.parsers import FormParser
  7.  
  8. class TestView(APIView):
  9.     parser_classes = [FormParser, ]
  10.  
  11.     def post(self, request, *args, **kwargs):
  12.         print(request.content_type)
  13.  
  14.         # 获取请求的值，并使用对应的JSONParser进行处理
  15.         print(request.data)
  16.  
  17.         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  18.         print(request.POST)
  19.         print(request.FILES)
  20.  
  21.         return Response('POST请求，响应内容')
  22.  
  23.     def put(self, request, *args, **kwargs):
  24.         return Response('PUT请求，响应内容')

views.py

c. 仅处理请求头content-type为multipart/form-data的请求体

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.request import Request
  6. from rest_framework.parsers import MultiPartParser
  7.  
  8. class TestView(APIView):
  9.     parser_classes = [MultiPartParser, ]
  10.  
  11.     def post(self, request, *args, **kwargs):
  12.         print(request.content_type)
  13.  
  14.         # 获取请求的值，并使用对应的JSONParser进行处理
  15.         print(request.data)
  16.         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  17.         print(request.POST)
  18.         print(request.FILES)
  19.         return Response('POST请求，响应内容')
  20.  
  21.     def put(self, request, *args, **kwargs):
  22.         return Response('PUT请求，响应内容')

views.py

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <form action="http://127.0.0.1:8000/test/" method="post" enctype="multipart/form-data">
  9.     <input type="text" name="user" />
  10.     <input type="file" name="img">
  11.  
  12.     <input type="submit" value="提交">
  13.  
  14. </form>
  15. </body>
  16. </html>

upload.html

d. 仅上传文件

  1.  from django.conf.urls import url, include
  2.  from web.views import TestView
  3.  
  4.  urlpatterns = [
  5.      url(r'test/(?P<filename>[^/]+)', TestView.as_view(), name='test'),
  6.  ]

urls.py

  1.  #!/usr/bin/env python
  2.  # -*- coding:utf-8 -*-
  3.  from rest_framework.views import APIView
  4.  from rest_framework.response import Response
  5.  from rest_framework.request import Request
  6.  from rest_framework.parsers import FileUploadParser
  7.  
  8.  class TestView(APIView):
  9.      parser_classes = [FileUploadParser, ]
  10.  
  11.      def post(self, request, filename, *args, **kwargs):
  12.          print(filename)
  13.          print(request.content_type)
  14.  
  15.          # 获取请求的值，并使用对应的JSONParser进行处理
  16.          print(request.data)
  17.          # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  18.          print(request.POST)
  19.          print(request.FILES)
  20.          return Response('POST请求，响应内容')
  21.  
  22.      def put(self, request, *args, **kwargs):
  23.          return Response('PUT请求，响应内容')

views.py

  1.  <!DOCTYPE html>
  2.  <html lang="en">
  3.  <head>
  4.      <meta charset="UTF-8">
  5.      <title>Title</title>
  6.  </head>
  7.  <body>
  8.  <form action="http://127.0.0.1:8000/test/f1.numbers" method="post" enctype="multipart/form-data">
  9.      <input type="text" name="user" />
  10.      <input type="file" name="img">
  11.  
  12.      <input type="submit" value="提交">
  13.  
  14.  </form>
  15.  </body>
  16.  </html>

upload.html

e. 同时多个Parser

当同时使用多个parser时，rest framework会根据请求头content-type自动进行比对，并使用对应parser

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework.request import Request
  6. from rest_framework.parsers import JSONParser, FormParser, MultiPartParser
  7.  
  8. class TestView(APIView):
  9.     parser_classes = [JSONParser, FormParser, MultiPartParser, ]
  10.  
  11.     def post(self, request, *args, **kwargs):
  12.         print(request.content_type)
  13.  
  14.         # 获取请求的值，并使用对应的JSONParser进行处理
  15.         print(request.data)
  16.         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  17.         print(request.POST)
  18.         print(request.FILES)
  19.         return Response('POST请求，响应内容')
  20.  
  21.     def put(self, request, *args, **kwargs):
  22.         return Response('PUT请求，响应内容')

views.py

f.全局使用

  1. REST_FRAMEWORK = {
  2.     'DEFAULT_PARSER_CLASSES':[
  3.         'rest_framework.parsers.JSONParser'
  4.         'rest_framework.parsers.FormParser'
  5.         'rest_framework.parsers.MultiPartParser'
  6.     ]
  7.  
  8. }

settings.py

  1. from django.conf.urls import url, include
  2. from web.views import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5.  
  6. class TestView(APIView):
  7.     def post(self, request, *args, **kwargs):
  8.         print(request.content_type)
  9.  
  10.         # 获取请求的值，并使用对应的JSONParser进行处理
  11.         print(request.data)
  12.         # application/x-www-form-urlencoded 或 multipart/form-data时，request.POST中才有值
  13.         print(request.POST)
  14.         print(request.FILES)
  15.         return Response('POST请求，响应内容')
  16.  
  17.     def put(self, request, *args, **kwargs):
  18.         return Response('PUT请求，响应内容')

views.py

request.data取POST的值

注意：个别特殊的值可以通过Django的request对象 request._request 来进行获取

获取get的数据，可以通过request._request.GET或者request.query_params或request.GET

因为

  1.     def dispatch(self, request, *args, **kwargs):
  2.         """
  3.         `.dispatch()` is pretty much the same as Django's regular dispatch,
  4.         but with extra hooks for startup, finalize, and exception handling.
  5.         """
  6.         self.args = args
  7.         self.kwargs = kwargs
  8.         # 第一步：对request进行加工（添加数据）
  9.         request = self.initialize_request(request, *args, **kwargs)
  10.         self.request = request

APIView.dispatch

  1.     def __init__(self, request, parsers=None, authenticators=None,
  2.                  negotiator=None, parser_context=None):
  3.         assert isinstance(request, HttpRequest), (
  4.             'The `request` argument must be an instance of '
  5.             '`django.http.HttpRequest`, not `{}.{}`.'
  6.             .format(request.__class__.__module__, request.__class__.__name__)
  7.         )
  8.  
  9.         self._request = request  #将django中的request对象封装到了_request中

Request.__init__

  1.     def __getattr__(self, attr):
  2.         """
  3.         If an attribute does not exist on this instance, then we also attempt
  4.         to proxy it to the underlying HttpRequest object.
  5.         """
  6.         try:
  7.             return getattr(self._request, attr) #当在新的request中找不到时，就去原来的request中找
  8.         except AttributeError:
  9.             return self.__getattribute__(attr)

Request.__getattar__

三、序列化

序列化用于对用户请求数据进行验证和数据进行序列化（为了解决queryset序列化问题）。

那什么是序列化呢？序列化就是把对象转换成字符串，反序列化就是把字符串转换成对象

a. 自定义字段

  1. from django.conf.urls import url, include
  2. from web.views.s6_serializers import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework import serializers
  6. from .. import models
  7.  
  8. class PasswordValidator(object):
  9.     def __init__(self, base):
  10.         self.base = base
  11.  
  12.     def __call__(self, value):
  13.         if value != self.base:
  14.             message = 'This field must be %s.' % self.base
  15.             raise serializers.ValidationError(message)
  16.  
  17.     def set_context(self, serializer_field):
  18.         """
  19.         This hook is called by the serializer instance,
  20.         prior to the validation call being made.
  21.         """
  22.         # 执行验证之前调用,serializer_fields是当前字段对象
  23.         pass
  24.  
  25. class UserSerializer(serializers.Serializer):
  26.     ut_title = serializers.CharField(source='ut.title')
  27.     user = serializers.CharField(min_length=6)
  28.     pwd = serializers.CharField(error_messages={'required': '密码不能为空'}, validators=[PasswordValidator('')])
  29.  
  30. class TestView(APIView):
  31.     def get(self, request, *args, **kwargs):
  32.  
  33.         # 序列化，将数据库查询字段序列化为字典
  34.         data_list = models.UserInfo.objects.all()
  35.         ser = UserSerializer(instance=data_list, many=True)
  36.         # 或
  37.         # obj = models.UserInfo.objects.all().first()
  38.         # ser = UserSerializer(instance=obj, many=False)
  39.         return Response(ser.data)
  40.  
  41.     def post(self, request, *args, **kwargs):
  42.         # 验证，对请求发来的数据进行验证
  43.         ser = UserSerializer(data=request.data)
  44.         if ser.is_valid():
  45.             print(ser.validated_data)
  46.         else:
  47.             print(ser.errors)
  48.  
  49.         return Response('POST请求，响应内容')

views.py

b. 基于Model自动生成字段

  1. from django.conf.urls import url, include
  2. from web.views.s6_serializers import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework import serializers
  6. from .. import models
  7.  
  8. class PasswordValidator(object):
  9.     def __init__(self, base):
  10.         self.base = str(base)
  11.  
  12.     def __call__(self, value):
  13.         if value != self.base:
  14.             message = 'This field must be %s.' % self.base
  15.             raise serializers.ValidationError(message)
  16.  
  17.     def set_context(self, serializer_field):
  18.         """
  19.         This hook is called by the serializer instance,
  20.         prior to the validation call being made.
  21.         """
  22.         # 执行验证之前调用,serializer_fields是当前字段对象
  23.         pass
  24.  
  25. class ModelUserSerializer(serializers.ModelSerializer):
  26.  
  27.     user = serializers.CharField(max_length=32)
  28.  
  29.     class Meta:
  30.         model = models.UserInfo
  31.         fields = "__all__"
  32.         # fields = ['user', 'pwd', 'ut']
  33.         depth = 2
  34.         extra_kwargs = {'user': {'min_length': 6}, 'pwd': {'validators': [PasswordValidator(666), ]}}
  35.         # read_only_fields = ['user']
  36.  
  37. class TestView(APIView):
  38.     def get(self, request, *args, **kwargs):
  39.  
  40.         # 序列化，将数据库查询字段序列化为字典
  41.         data_list = models.UserInfo.objects.all()
  42.         ser = ModelUserSerializer(instance=data_list, many=True)
  43.         # 或
  44.         # obj = models.UserInfo.objects.all().first()
  45.         # ser = UserSerializer(instance=obj, many=False)
  46.         return Response(ser.data)
  47.  
  48.     def post(self, request, *args, **kwargs):
  49.         # 验证，对请求发来的数据进行验证
  50.         print(request.data)
  51.         ser = ModelUserSerializer(data=request.data)
  52.         if ser.is_valid():
  53.             print(ser.validated_data)
  54.         else:
  55.             print(ser.errors)
  56.  
  57.         return Response('POST请求，响应内容')

views.py

c. 生成URL

  1. from django.conf.urls import url, include
  2. from web.views.s6_serializers import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6.     url(r'detail/(?P<pk>\d+)/', TestView.as_view(), name='detail'),
  7. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework import serializers
  6. from .. import models
  7.  
  8. class PasswordValidator(object):
  9.     def __init__(self, base):
  10.         self.base = str(base)
  11.  
  12.     def __call__(self, value):
  13.         if value != self.base:
  14.             message = 'This field must be %s.' % self.base
  15.             raise serializers.ValidationError(message)
  16.  
  17.     def set_context(self, serializer_field):
  18.         """
  19.         This hook is called by the serializer instance,
  20.         prior to the validation call being made.
  21.         """
  22.         # 执行验证之前调用,serializer_fields是当前字段对象
  23.         pass
  24.  
  25. class ModelUserSerializer(serializers.ModelSerializer):
  26.     ut = serializers.HyperlinkedIdentityField(view_name='detail')
  27.     class Meta:
  28.         model = models.UserInfo
  29.         fields = "__all__"
  30.  
  31.         extra_kwargs = {
  32.             'user': {'min_length': 6},
  33.             'pwd': {'validators': [PasswordValidator(666),]},
  34.         }
  35.  
  36. class TestView(APIView):
  37.     def get(self, request, *args, **kwargs):
  38.  
  39.         # 序列化，将数据库查询字段序列化为字典
  40.         data_list = models.UserInfo.objects.all()
  41.         ser = ModelUserSerializer(instance=data_list, many=True, context={'request': request})
  42.         # 或
  43.         # obj = models.UserInfo.objects.all().first()
  44.         # ser = UserSerializer(instance=obj, many=False)
  45.         return Response(ser.data)
  46.  
  47.     def post(self, request, *args, **kwargs):
  48.         # 验证，对请求发来的数据进行验证
  49.         print(request.data)
  50.         ser = ModelUserSerializer(data=request.data)
  51.         if ser.is_valid():
  52.             print(ser.validated_data)
  53.         else:
  54.             print(ser.errors)
  55.  
  56.         return Response('POST请求，响应内容')

views.py

d. 自动生成URL

  1. from django.conf.urls import url, include
  2. from web.views.s6_serializers import TestView
  3.  
  4. urlpatterns = [
  5.     url(r'test/', TestView.as_view(), name='test'),
  6.     url(r'detail/(?P<pk>\d+)/', TestView.as_view(), name='xxxx'),
  7. ]

urls.py

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from rest_framework.views import APIView
  4. from rest_framework.response import Response
  5. from rest_framework import serializers
  6. from .. import models
  7.  
  8. class PasswordValidator(object):
  9.     def __init__(self, base):
  10.         self.base = str(base)
  11.  
  12.     def __call__(self, value):
  13.         if value != self.base:
  14.             message = 'This field must be %s.' % self.base
  15.             raise serializers.ValidationError(message)
  16.  
  17.     def set_context(self, serializer_field):
  18.         """
  19.         This hook is called by the serializer instance,
  20.         prior to the validation call being made.
  21.         """
  22.         # 执行验证之前调用,serializer_fields是当前字段对象
  23.         pass
  24.  
  25. class ModelUserSerializer(serializers.HyperlinkedModelSerializer):
  26.     ll = serializers.HyperlinkedIdentityField(view_name='xxxx')
  27.     tt = serializers.CharField(required=False)
  28.  
  29.     class Meta:
  30.         model = models.UserInfo
  31.         fields = "__all__"
  32.         list_serializer_class = serializers.ListSerializer
  33.  
  34.         extra_kwargs = {
  35.             'user': {'min_length': 6},
  36.             'pwd': {'validators': [PasswordValidator(666), ]},
  37.             'url': {'view_name': 'xxxx'},
  38.             'ut': {'view_name': 'xxxx'},
  39.         }
  40.  
  41. class TestView(APIView):
  42.     def get(self, request, *args, **kwargs):
  43.         # # 序列化，将数据库查询字段序列化为字典
  44.         data_list = models.UserInfo.objects.all()
  45.         ser = ModelUserSerializer(instance=data_list, many=True, context={'request': request})
  46.         # # 如果Many=True
  47.         # # 或
  48.         # # obj = models.UserInfo.objects.all().first()
  49.         # # ser = UserSerializer(instance=obj, many=False)
  50.         return Response(ser.data)
  51.  
  52.     def post(self, request, *args, **kwargs):
  53.         # 验证，对请求发来的数据进行验证
  54.         print(request.data)
  55.         ser = ModelUserSerializer(data=request.data)
  56.         if ser.is_valid():
  57.             print(ser.validated_data)
  58.         else:
  59.             print(ser.errors)
  60.  
  61.         return Response('POST请求，响应内容')

views.py

1、基本操作

  1. from django.db import models
  2.  
  3. # Create your models here.
  4. class Group(models.Model):
  5.     title = models.CharField(max_length=32)
  6.     mu = models.ForeignKey(to='Menu',default=1)
  7.  
  8. class UserInfo(models.Model):
  9.     name = models.CharField(max_length=32)
  10.     pwd = models.CharField(max_length=32)
  11.     group = models.ForeignKey(to="Group")
  12.  
  13.     roles = models.ManyToManyField(to="Role")
  14. class Menu(models.Model):
  15.     name = models.CharField(max_length=21)
  16.  
  17. class Role(models.Model):
  18.     name = models.CharField(max_length=32)

models.py

  1.  from django.shortcuts import render,HttpResponse
  2.  from rest_framework.views import APIView
  3.  from rest_framework.response import Response
  4.  from rest_framework.versioning import BaseVersioning
  5.  from rest_framework.versioning import QueryParameterVersioning  #获取version的值
  6.  from rest_framework.versioning import URLPathVersioning #支持版本
  7.  from rest_framework.versioning import HostNameVersioning
  8.  from rest_framework.parsers import JSONParser  #解析器
  9.  from rest_framework import serializers
  10.  from app03 import models
  11.  class UsersSerializer(serializers.Serializer):
  12.      name = serializers.CharField()  #字段名字
  13.      pwd = serializers.CharField()
  14.  
  15.  class UserView(APIView):
  16.      def get(self,request,*args,**kwargs):
  17.          # 方式一实现
  18.          # user_list = models.UserInfo.objects.values('name','pwd','group__mu','group__title')
  19.          # print(type(user_list))
  20.          # return Response(user_list)
  21.  
  22.          # 方式二之多对象
  23.          # user_list = models.UserInfo.objects.all()  #直接这样查会报错，借助他提供的系列化
  24.          # ser = UsersSerializer(instance=user_list,many=True) #可允许多个
  25.          # # print(type(ser))  #<class 'rest_framework.serializers.ListSerializer'>
  26.          # print(ser.data)  #返回的是一个有序字典
  27.  
  28.          #方式三之单对象
  29.          user = models.UserInfo.objects.all().first()
  30.          ser = UsersSerializer(instance=user,many=False)
  31.  
  32.          return Response(ser.data)

views.py

2、跨表

  1.  x1 = serializers.CharField(source='group.mu.name')

   如果你想跨表拿你任何需要的数据，都可以用上面的这种操作，内部做判断，如果可用内部就加括号调用了

  1.  from rest_framework.views import APIView
  2.  from rest_framework.response import Response
  3.  from rest_framework import serializers
  4.  from app03 import models
  5.  class UsersSerializer(serializers.Serializer):
  6.      name = serializers.CharField()  #字段名字
  7.      pwd = serializers.CharField()
  8.      # group = serializers.CharField()  #会显示对象
  9.      # group_id = serializers.CharField()  #会显示id
  10.      x1 = serializers.CharField(source='group.mu.name')
  11.      roles = serializers.CharField(source='roles.all') #多对多关系的这样查出的是queryset对象
  12.  
  13.  class UserView2(APIView):
  14.      '''跨表操作'''
  15.      def get(self,request,*args,**kwargs):
  16.  
  17.          user = models.UserInfo.objects.all()
  18.          ser = UsersSerializer(instance=user,many=True)
  19.  
  20.          return Response(ser.data)

Views.py

3、复杂序列化

自定义类和方法

解决方案一：

  1.  class MyCharField(serializers.CharField):
  2.  
  3.      def to_representation(self, value): ##打印的是所有的数据
  4.          data_list = []
  5.          for row in value:
  6.              data_list.append(row.name)
  7.          return data_list
  8.  
  9.  class UsersSerializer(serializers.Serializer):
  10.      name = serializers.CharField() # obj.name
  11.      pwd = serializers.CharField()  # obj.pwd
  12.      group_id = serializers.CharField() # obj.group_id
  13.      xxxx = serializers.CharField(source="group.title") # obj.group.title
  14.      x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
  15.      # x2 = serializers.CharField(source="roles.all") #  多对多关系的这样查出的是queryset对象
  16.      x2 = MyCharField(source="roles.all") # obj.mu.name

Views.py

解决方案二：

  1.  class MyCharField(serializers.CharField):
  2.      def to_representation(self, value):
  3.          return {'id':value.pk, 'name':value.name}
  4.  
  5.  class UsersSerializer(serializers.Serializer):
  6.      name = serializers.CharField() # obj.name
  7.      pwd = serializers.CharField()  # obj.pwd
  8.      group_id = serializers.CharField() # obj.group_id
  9.      xxxx = serializers.CharField(source="group.title") # obj.group.title
  10.      x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
  11.      # x2 = serializers.CharField(source="roles.all") # obj.mu.name
  12.      x2 = serializers.ListField(child=MyCharField(),source="roles.all") # obj.mu.name

Views.py

解决方案三（推荐使用）

  1.  class UsersSerializer(serializers.Serializer):
  2.      name = serializers.CharField() # obj.name
  3.      pwd = serializers.CharField()  # obj.pwd
  4.      group_id = serializers.CharField() # obj.group_id
  5.      xxxx = serializers.CharField(source="group.title") # obj.group.title
  6.      x1 = serializers.CharField(source="group.mu.name") # obj.mu.name
  7.      # x2 = serializers.CharField(source="roles.all") # obj.mu.name
  8.      # x2 = serializers.ListField(child=MyCharField(),source="roles.all") # obj.mu.name
  9.      x2 = serializers.SerializerMethodField()
  10.  
  11.      def get_x2(self,obj):  #get_字段名
  12.          print(obj)   ##UserInfo object
  13.          obj.roles.all()
  14.          role_list = obj.roles.filter(id__gt=1)
  15.          data_list = []
  16.          for row in role_list:
  17.              data_list.append({'pk':row.pk,'name':row.name})
  18.          return data_list
  19.

Views.py

4、基于Model

  1. class UsersSerializer(serializers.ModelSerializer):
  2.     x1 = serializers.CharField(source='name')
  3.     group = serializers.HyperlinkedIdentityField(view_name='detail')
  4.     class Meta:
  5.  
  6.         model = models.UserInfo
  7.         # fields = "__all__"
  8.         fields = ['name','pwd','group','x1']  #自定义字段的时候注意要指定source,scource里面的数据必须是数据库有的数据
  9.         depth = 1 #表示深度
  10.  
  11. class UsersView(APIView):
  12.     def get(self,request,*args,**kwargs):
  13.         self.dispatch
  14.         # 方式一：
  15.         # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
  16.         # return Response(user_list)
  17.  
  18.         # 方式二之多对象
  19.         user_list = models.UserInfo.objects.all()
  20.         # [obj1,obj2,obj3]
  21.         ser = UsersSerializer(instance=user_list,many=True)
  22.         return Response(ser.data)

Views.py

 当我们想定义一个model中没有的字段时，可以采用以下方式

  1. class NewhomeSerializer(serializers.ModelSerializer):
  2.     published_time = serializers.SerializerMethodField()  # 自定义一个字段
  3.  
  4.     class Meta:
  5.         model = models.Article
  6.         fields = ['title', 'source', 'brief', 'view_num', 'comment_num',
  7.                   'collect_num', 'published_time', 'head_img', 'content', 'agree_num']  # 将自定义的字段放到fields中，通过fields='__all__'也可以
  8.  
  9.         depth = 1  # 表示深度
  10.  
  11.     def get_published_time(self, obj):　　# 定义方法，def get_自定义的字段名:
  12.         time = (now() - obj.pub_date).days
  13.  
  14.         week, day = divmod(time, 7)
  15.         hour, min = divmod(int((now() - obj.pub_date).seconds), 3600)
  16.         # print(week)
  17.         # print(day)
  18.         if week > 1:
  19.             return '%s周前' % week
  20.         elif day > 1:
  21.             return '%s天前' % day
  22.         elif hour > 1:
  23.             return '%s小时前' % hour
  24.         elif min > 1:
  25.             return '%s小时前' % min
  26.         else:
  27.             return '刚刚'

5、指定生成URL

  1. class UsersSerializer(serializers.ModelSerializer):  #
  2.     group = serializers.HyperlinkedIdentityField(view_name='detail')   #让group的结果为按照urls中name为detail的url反向生成url
  3.     class Meta:
  4.         model = models.UserInfo
  5.         fields = "__all__"
  6.         # fields = ['name', 'pwd','group']
  7.         depth = 1
  8.  
  9. class UsersView(APIView):
  10.     def get(self,request,*args,**kwargs):
  11.         self.dispatch
  12.         # 方式一：
  13.         # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
  14.         # return Response(user_list)
  15.  
  16.         # 方式二之多对象
  17.         user_list = models.UserInfo.objects.all()
  18.         # [obj1,obj2,obj3]
  19.         ser = UsersSerializer(instance=user_list,many=True,context={'request':request}) #要反向生成url时，必须带上这个context,否则报错
  20.         return Response(ser.data)

views.py

  1. from django.conf.urls import url,include
  2. from django.contrib import admin
  3. from app03 import views
  4. urlpatterns = [
  5.  
  6.     url(r'^users4/', views.UserView4.as_view(), name='xxx'),
  7.     url(r'^users5/(?P<pk>.*)', views.UserView5.as_view(), name='detail'),  #必须叫pk
  8. ]

6、全部自动生成URL

  1.  class UsersSerializer(serializers.HyperlinkedModelSerializer): #继承他自动生成
  2.      class Meta:
  3.          model = models.UserInfo
  4.          fields = "__all__"
  5.  
  6.          # fields = ['id','name','pwd']  
  7.  
  8.  class UsersView(APIView):
  9.      def get(self,request,*args,**kwargs):
  10.          self.dispatch
  11.          # 方式一：
  12.          # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
  13.          # return Response(user_list)
  14.  
  15.          # 方式二之多对象
  16.          user_list = models.UserInfo.objects.all()
  17.          # [obj1,obj2,obj3]
  18.          ser = UsersSerializer(instance=user_list,many=True,context={'request':request})
  19.          return Response(ser.data)

views.py

全部自动生成时，默认使用的反向生成的名字是 '字段名-detail',

exclude排除某字段，其余保留

四、请求数据验证：

a、自己手写

  1.  class PasswordValidator(object):
  2.      def __init__(self, base):
  3.          self.base = base
  4.  
  5.      def __call__(self, value):
  6.          if value != self.base:
  7.              message = '用户输入的值必须是 %s.' % self.base
  8.              raise serializers.ValidationError(message)
  9.  
  10.      def set_context(self, serializer_field):
  11.          """
  12.          This hook is called by the serializer instance,
  13.          prior to the validation call being made.
  14.          """
  15.          # 执行验证之前调用,serializer_fields是当前字段对象
  16.          pass
  17.  
  18.  class UsersSerializer(serializers.Serializer):
  19.          name = serializers.CharField(min_length=6)
  20.          pwd = serializers.CharField(error_messages={'required': '密码不能为空'}, validators=[PasswordValidator('')])

views.py

b、基于model

  1.  class PasswordValidator(object):
  2.      def __init__(self, base):
  3.          self.base = base
  4.  
  5.      def __call__(self, value):
  6.          if value != self.base:
  7.              message = '用户输入的值必须是 %s.' % self.base
  8.              raise serializers.ValidationError(message)
  9.  
  10.      def set_context(self, serializer_field):
  11.          """
  12.          This hook is called by the serializer instance,
  13.          prior to the validation call being made.
  14.          """
  15.          # 执行验证之前调用,serializer_fields是当前字段对象
  16.          pass
  17.  
  18.  class UsersSerializer(serializers.ModelSerializer):
  19.      class Meta:
  20.          model = models.UserInfo
  21.          fields = "__all__"
  22.          #自定义验证规则
  23.          extra_kwargs = {
  24.              'name': {'min_length': 6},
  25.              'pwd': {'validators': [PasswordValidator(666), ]}
  26.          }

views.py

使用

  1.  class UsersView(APIView):
  2.      def get(self,request,*args,**kwargs):
  3.          self.dispatch
  4.          # 方式一：
  5.          # user_list = models.UserInfo.objects.all().values('name','pwd','group__id',"group__title")
  6.          # return Response(user_list)
  7.  
  8.          # 方式二之多对象
  9.          user_list = models.UserInfo.objects.all()
  10.          # [obj1,obj2,obj3]
  11.          ser = UsersSerializer(instance=user_list,many=True,context={'request':request})
  12.          return Response(ser.data)
  13.  
  14.      def post(self,request,*args,**kwargs):
  15.          ser = UsersSerializer(data=request.data)
  16.          if ser.is_valid():
  17.              print(ser.validated_data)
  18.          else:
  19.              print(ser.errors)
  20.          return Response('...')

viewS.py

钩子函数

  1. def validate_字段(self,validated_value):
  2.        raise ValidationError(detail='xxxxxx')
  3.        return validated_value
  4.

Django Rest Framework(版本、解析器、序列化、数据验证)的更多相关文章

  1. Django Rest framework 之 解析器

    RESTful 规范 django rest framework 之 认证(一) django rest framework 之 权限(二) django rest framework 之 节流(三) ...

  2. DRF Django REST framework 之 解析器（二）

    引入 Django Rest framework帮助我们实现了处理application/json协议请求的数据,如果不使用DRF,直接从 request.body 里面拿到原始的客户端请求的字节数据 ...

  3. Django Rest Framework之解析器

    基本代码结构 urls.py: from django.conf.urls import url, include from web.views.s5_parser import TestView u ...

  4. Django REST framework的解析器与渲染器

    解析器 解析器的作用 解析器的作用就是服务端接收客户端传过来的数据,把数据解析成自己可以处理的数据.本质就是对请求体中的数据进行解析. 在了解解析器之前,我们要先知道Accept以及ContentTy ...

  5. Django REST framework 中文教程1:序列化

    建立环境 在我们做任何事情之前,我们将使用virtualenv创建一个新的虚拟环境.这将确保我们的包配置与我们正在开展的任何其他项目保持良好的隔离. virtualenv envsource env/ ...

  6. Django rest framework（6）----序列化

    目录 Django rest framework(1)----认证 Django rest framework(2)----权限 Django rest framework(3)----节流 Djan ...

  7. Django REST Framework - 分页 - 渲染器 - 解析器

    为什么要使用分页? 我们数据表中可能会有成千上万条数据,当我们访问某张表的所有数据时,我们不太可能需要一次把所有的数据都展示出来,因为数据量很大,对服务端的内存压力比较大还有就是网络传输过程中耗时也会 ...

  8. day71:drf:API接口&Restful API规范&Django Rest Framework&drf中的序列化和反序列化功能

    目录 1.web应用模式 2.API接口 3.Restful API规范 4.序列化 5.Django Rest Framework 1.drf的简单介绍 2.drf的特点 3.如何安装drf 4.d ...

  9. rest framework 之解析器

    一.示例 1.api/urls.py from django.urls import path, re_path from api.views import UserView, ParserView ...

随机推荐

  1. WdatePicker日历控件动态设置属性参数值

    首先吐槽一下需求人员给了我一个很坑的需求:WdatePicker日历控件里面选择的最小时间(minDate)的值是级联动态改变的,而且这个值要从数据库获取,这样子只能使用 ajax 来发起请求获取mi ...

  2. linux之nginx的安装

    (一)这次是自己折腾服务器的环境,所以自己算是都装过一遍,在装的过程中也是在网上搜索,其实最后在公司运维的指导下知道自己安装出错在哪里的.不说了,直接说安装和问题 (二):首先从 http://ngi ...

  3. hdu 3118 Arbiter

    http://acm.hdu.edu.cn/showproblem.php?pid=3118   题意:删除最少的边使图没有奇环   二分图的定义:如果顶点能分为两个互不相交的子集,则图为二分图 二分 ...

  4. java绝对路径和相对路径的理解

    日常开发中引用东西经常会遇到路径问题,各种尝试,各种出错,其实只要理解了这两种路径,问题便迎刃而解. 在java中路径有两种表示方法:绝对路径和相对路径. (1) 相对路径:它以不带“\”的目录名表示 ...

  5. 【洛谷 P2764】 最小路径覆盖问题（最大流）

    题目链接 首先有\(n\)条路径,每条路径就是一个点,然后尽量合并,答案就是点数-合并数. 套路拆点,源连入,出连汇,原有的边入出连. 最大流就是最大合并数,第一问解决. 然后怎么输出方案? 我是找到 ...

  6. 重载jquery on方法实现click事件在移动端的快速响应

    额,这个标题取的还真是挺装的... 其实我想表达的是jquery click事件如何在移动端自动转换成touchstart事件. 因为移动端click事件会比touchstart事件慢几拍 移动设备某 ...

  7. 网络抓包wireshark(转)

    下载地址:https://www.wireshark.org/download/win64/   抓包应该是每个技术人员掌握的基础知识,无论是技术支持运维人员或者是研发,多少都会遇到要抓包的情况,用过 ...

  8. iTextSharp之pdfRead（两个文件文本内容的比较，指定页数的pdf截取，水印的添加）

    using iTextSharp.text; using iTextSharp.text.pdf; using iTextSharp.text.pdf.parser; using System; us ...

  9. 简单实现JS上传图片预览功能

    HTML代码 <div class="upload"> <input type="button" class="btn" ...

  10. 在flask中返回requests响应

    在flask服务端,有时候需要使用requests请求其他url,并将响应返回回去.查阅了flask文档,About Responses,可以直接构造响应结果进行返回. If a tuple is r ...