前后端分离djangorestframework——序列化与反序列化数据

最新推荐文章于 2024-11-07 10:43:53 发布
最新推荐文章于 2024-11-07 10:43:53 发布
阅读量185 收藏
点赞数
分类专栏： django 文章标签： django python flask
原文链接：https://www.cnblogs.com/Eeyhan/p/10416005.html
版权

转载 https://www.cnblogs.com/Eeyhan/p/10416005.html

from django.db import models
 
# 使用这个可以提前声明表名，在使用外键约束时可以不用考虑表前后顺序
__all__ = ['Book', 'Publisher', 'Author']
 
 
# Create your models here.
 
class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name='图书名称')
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = models.IntegerField(choices=CHOICES, verbose_name='图书类别')
    pub_time = models.DateField(verbose_name='出版时间')
    publisher = models.ForeignKey(to='Publisher', on_delete=None)
    author = models.ManyToManyField(to='Author')
 
    def __str__(self):
        return self.title
 
    class Meta:
        # 自定义数据库表名
        verbose_name_plural = 'book'
        db_table = verbose_name_plural
 
 
class Publisher(models.Model):
    title = models.CharField(max_length=32, verbose_name='出版社名称')
 
    def __str__(self):
        return self.title
 
    class Meta:
        verbose_name_plural = 'publish'
        db_table = verbose_name_plural
 
 
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name='作者名称')
 
    def __str__(self):
        return self.name
 
    class Meta:
        verbose_name_plural = 'author'
        db_table = verbose_name_plural

class BookView(View):
    def get(self, request):
        book_list = models.Book.objects.values('id', 'title','pub_time')
        book_list = list(book_list)
        ret = json.dumps(book_list, ensure_ascii=False)
        return HttpResponse(ret)

# coding:utf-8
from django.shortcuts import HttpResponse
from django.http import JsonResponse
from django.views import View
import json
# Create your views here.
from demo1 import models
 
 
class BookView(View):
    def get(self, request):
        book_list = models.Book.objects.values("id", "title", 'pub_time')
        book_list = list(book_list)
        # ret = json.dumps(book_list, ensure_ascii=False)
        # print(book_list)
        return JsonResponse(book_list, safe=False, json_dumps_params={'ensure_ascii': False})

class BookView(View):
    def get(self, request):
        book_list = models.Book.objects.values("id", "title", 'pub_time','publisher')
        book_list = list(book_list)
        ret = []
        for field in book_list:
            pub_id = field['publisher']
            publish_obj = models.Publisher.objects.filter(id=pub_id).first()
            field['publisher'] = {
                'id':pub_id,
                'title':publish_obj.title
            }
            ret.append(field)
 
        return JsonResponse(ret, safe=False, json_dumps_params={'ensure_ascii': False})

# coding:utf-8
from django.shortcuts import HttpResponse
from django.http import JsonResponse
from django.views import View
import json
# Create your views here.
from demo1 import models
from django.core import serializers
 
class BookView(View):
    def get(self,request):
        book_list = models.Book.objects.all()
        ret = serializers.serialize('json',book_list,ensure_ascii=False)
        return HttpResponse(ret)

from rest_framework import serializers


class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES,source='get_category_display')
    pub_time = serializers.DateField()

    publisher = PublishSerializer()
    author = AuthorSerializer(many=True)

# coding:utf-8
from django.shortcuts import HttpResponse
from django.http import JsonResponse
from django.views import View
import json
# Create your views here.
from demo1 import models
from django.core import serializers

from rest_framework.views import APIView
from rest_framework.response import Response
from demo1.serializers import BookSerializer


class BookView(APIView):
    def get(self, request):
        book_list = models.Book.objects.all()
        ret = BookSerializer(book_list, many=True)
        return Response(ret.data)

from rest_framework import serializers
from demo1 import models


class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)



class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES, source='get_category_display', read_only=True)

    w_category = serializers.ChoiceField(choices=CHOICES, write_only=True)
    pub_time = serializers.DateField()

    publisher = PublishSerializer(read_only=True)
    w_publish = serializers.IntegerField(write_only=True)
    author = AuthorSerializer(many=True, read_only=True)

    # 作者字段只需要传入一个列表对象
    w_author = serializers.ListField(write_only=True)

    def create(self, validated_data):
        book_obj = models.Book.objects.create(title=validated_data['title'],
                                              category=validated_data['w_category'],
                                              pub_time=validated_data['pub_time'],
                                              publisher_id=validated_data['w_publish'])
        book_obj.author.add(*validated_data['w_author'])
        return book_obj

# coding:utf-8
from django.shortcuts import HttpResponse
from django.http import JsonResponse
from django.views import View
import json
# Create your views here.
from demo1 import models
from django.core import serializers

from rest_framework.views import APIView
from rest_framework.response import Response
from demo1.serializers import BookSerializer


class BookView(APIView):
    def get(self, request):
        book_list = models.Book.objects.all()
        ret = BookSerializer(book_list, many=True)
        return Response(ret.data)

    def post(self, request):
        # post的数据不再是在request.POST里
        # 而在request.data
        print(request.data)
        serialize = BookSerializer(data=request.data)
        if serialize.is_valid():
            # save是存储
            serialize.save()
            return Response(serialize.validated_data)
        else:
            return Response(serialize.errors)

class BookEditView(APIView):
    def get(self, request, id):
        book_obj = models.Book.objects.filter(id=id).first()
        ret = BookSerializer(book_obj)
        return Response(ret.data)

    def put(self, request, id):
        book_obj = models.Book.objects.filter(id=id).first()
        # partial参数表示只对部分数据验证
        serialize = BookSerializer(book_obj, data=request.data, partial=True)
        print(book_obj)

        if serialize.is_valid():
            # save是存储
            serialize.save()
            return Response(serialize.validated_data)
        else:
            return Response(serialize.errors)

from rest_framework import serializers
from demo1 import models


class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    title = serializers.CharField(max_length=32)


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField(max_length=32)


bookdata = {
    "title": "kali linux 入门到入狱",
    "w_category": 3,
    "pub_time": "2019-02-08",
    "w_publish": 2,
    "w_author": [1, 2, 4]
}


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES, source='get_category_display', read_only=True)

    w_category = serializers.ChoiceField(choices=CHOICES, write_only=True)
    pub_time = serializers.DateField()

    publisher = PublishSerializer(read_only=True)
    w_publish = serializers.IntegerField(write_only=True)
    author = AuthorSerializer(many=True, read_only=True)

    # 作者字段只需要传入一个列表对象
    w_author = serializers.ListField(write_only=True)

    def create(self, validated_data):
        book_obj = models.Book.objects.create(title=validated_data['title'],
                                              category=validated_data['w_category'],
                                              pub_time=validated_data['pub_time'],
                                              publisher_id=validated_data['w_publish'])
        book_obj.author.add(*validated_data['w_author'])
        return book_obj

    def update(self, instance, validated_data):
        # 次数的instance就是图书表数据库对象
        # 以下字段的key值也同样必须使用上面的只写的属性key
        instance.title = validated_data.get('title',instance.title)
        instance.category = validated_data.get('w_category',instance.category)
        instance.pub_time = validated_data.get('pub_time',instance.pub_time)
        instance.publisher_id = validated_data.get('w_publish',instance.publisher_id)
        if validated_data.get('w_author'):
            instance.author.set(validated_data['w_author'])
        instance.save()
        return instance

class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES, source='get_category_display', read_only=True)

    w_category = serializers.ChoiceField(choices=CHOICES, write_only=True)
    pub_time = serializers.DateField()

    publisher = PublishSerializer(read_only=True)
    w_publish = serializers.IntegerField(write_only=True)
    author = AuthorSerializer(many=True, read_only=True)

    # 作者字段只需要传入一个列表对象
    w_author = serializers.ListField(write_only=True)

    def create(self, validated_data):
        book_obj = models.Book.objects.create(title=validated_data['title'],
                                              category=validated_data['w_category'],
                                              pub_time=validated_data['pub_time'],
                                              publisher_id=validated_data['w_publish'])
        book_obj.author.add(*validated_data['w_author'])
        return book_obj

    def update(self, instance, validated_data):
        # 次数的instance就是图书表数据库对象
        # 以下字段的key值也同样必须使用上面的只写的属性key
        instance.title = validated_data.get('title', instance.title)
        instance.category = validated_data.get('w_category', instance.category)
        instance.pub_time = validated_data.get('pub_time', instance.pub_time)
        instance.publisher_id = validated_data.get('w_publish', instance.publisher_id)
        if validated_data.get('w_author'):
            instance.author.set(validated_data['w_author'])
        instance.save()
        return instance

    def validate_title(self, value):
        if 'python' not in value.lower():
            raise serializers.ValidationError('修改失败，内容必须包含python')
        return value


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32)
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES, source='get_category_display', read_only=True)

    w_category = serializers.ChoiceField(choices=CHOICES, write_only=True)
    pub_time = serializers.DateField()

    publisher = PublishSerializer(read_only=True)
    w_publish = serializers.IntegerField(write_only=True)
    author = AuthorSerializer(many=True, read_only=True)

    # 作者字段只需要传入一个列表对象
    w_author = serializers.ListField(write_only=True)

    def create(self, validated_data):
        book_obj = models.Book.objects.create(title=validated_data['title'],
                                              category=validated_data['w_category'],
                                              pub_time=validated_data['pub_time'],
                                              publisher_id=validated_data['w_publish'])
        book_obj.author.add(*validated_data['w_author'])
        return book_obj

    def update(self, instance, validated_data):
        # 次数的instance就是图书表数据库对象
        # 以下字段的key值也同样必须使用上面的只写的属性key
        instance.title = validated_data.get('title', instance.title)
        instance.category = validated_data.get('w_category', instance.category)
        instance.pub_time = validated_data.get('pub_time', instance.pub_time)
        instance.publisher_id = validated_data.get('w_publish', instance.publisher_id)
        if validated_data.get('w_author'):
            instance.author.set(validated_data['w_author'])
        instance.save()
        return instance

    def validate_title(self, value):
        if 'python' not in value.lower():
            raise serializers.ValidationError('修改失败，内容必须包含python')
        return value

    def validate(self, attrs):
        if attrs['w_publish'] == 1 and attrs['w_category'] == 1:
            return attrs
        else:
            raise serializers.ValidationError('分类和作者id必须一样')

def my_validate(value):
    if '敏感信息' in value.lower():
        raise serializers.ValidationError('不能含有敏感信息')
    else:
        return value


class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=False)
    title = serializers.CharField(max_length=32, validators=[my_validate])
    CHOICES = ((1, 'python'), (2, 'GO'), (3, 'linux'))
    category = serializers.ChoiceField(choices=CHOICES, source='get_category_display', read_only=True)

    w_category = serializers.ChoiceField(choices=CHOICES, write_only=True)
    pub_time = serializers.DateField()

    publisher = PublishSerializer(read_only=True)
    w_publish = serializers.IntegerField(write_only=True)
    author = AuthorSerializer(many=True, read_only=True)

    # 作者字段只需要传入一个列表对象
    w_author = serializers.ListField(write_only=True)

    def create(self, validated_data):
        book_obj = models.Book.objects.create(title=validated_data['title'],
                                              category=validated_data['w_category'],
                                              pub_time=validated_data['pub_time'],
                                              publisher_id=validated_data['w_publish'])
        book_obj.author.add(*validated_data['w_author'])
        return book_obj

    def update(self, instance, validated_data):
        # 次数的instance就是图书表数据库对象
        # 以下字段的key值也同样必须使用上面的只写的属性key
        instance.title = validated_data.get('title', instance.title)
        instance.category = validated_data.get('w_category', instance.category)
        instance.pub_time = validated_data.get('pub_time', instance.pub_time)
        instance.publisher_id = validated_data.get('w_publish', instance.publisher_id)
        if validated_data.get('w_author'):
            instance.author.set(validated_data['w_author'])
        instance.save()
        return instance

    def validate_title(self, value):
        if 'python' not in value.lower():
            raise serializers.ValidationError('修改失败，内容必须包含python')
        return value

    def validate(self, attrs):
        if attrs['w_publish'] == 1 and attrs['w_category'] == 1:
            return attrs
        else:
            raise serializers.ValidationError('出版社和作者id必须一样')

from rest_framework import serializers
from demo1 import models


class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = models.Book
        fields = '__all__'
        depth = 1  # 表示外键查找层级

class BookSerializer(serializers.ModelSerializer):
    category = serializers.CharField(source="get_category_display") # 注意这里是CharField不是ChoicesField

    class Meta:
        model = models.Book
        fields = '__all__'
        depth = 1  # 表示外键查找层级

class BookSerializer(serializers.ModelSerializer):
    category_display = serializers.SerializerMethodField(read_only=True)
    authors = serializers.SerializerMethodField(read_only=True)
    publish_info = serializers.SerializerMethodField(read_only=True)

    def get_category_display(self, obj):
        return obj.get_category_display()

    def get_publish_info(self, obj):
        publish_obj = obj.publisher
        return {"id": publish_obj.id, 'title': publish_obj.title}

    def get_authors(self, obj):
        # obj是Book对象
        author_list = obj.author.all()
        return [{"id": author_obj.id, "name": author_obj.name} for author_obj in author_list]

    class Meta:
        model = models.Book
        fields = '__all__'
        # depth = 1  # 表示外键查找层级
        extra_kwargs = {
            "category": {"write_only": True},
            "publisher": {"write_only": True},
            "author": {"write_only": True},
        }

# coding:utf-8
from django.shortcuts import HttpResponse
from django.http import JsonResponse
from django.views import View
import json
# Create your views here.
from demo1 import models
from django.core import serializers

from rest_framework.views import APIView
from rest_framework.response import Response
from demo1.serializers import BookSerializer



class BookView(APIView):
    def get(self, request):
        book_list = models.Book.objects.all()
        ret = BookSerializer(book_list, many=True)
        return Response(ret.data)

    def post(self, request):
        # post的数据不再是在request.POST里
        # 而在request.data
        print(request.data)
        serialize = BookSerializer(data=request.data)
        if serialize.is_valid():
            # save是存储
            serialize.save()
            return Response(serialize.data)
        else:
            return Response(serialize.errors)


class BookEditView(APIView):
    def get(self, request, id):
        book_obj = models.Book.objects.filter(id=id).first()
        ret = BookSerializer(book_obj)
        return Response(ret.data)

    def put(self, request, id):
        book_obj = models.Book.objects.filter(id=id).first()
        # partial参数表示只对部分数据验证
        serialize = BookSerializer(book_obj, data=request.data, partial=True)

        if serialize.is_valid():
            # print(serialize.validated_data)
            # save是存储
            serialize.save()
            return Response(serialize.data)
        else:
            return Response(serialize.errors)

    def delete(self, request, id):
        book_obj = models.Book.objects.filter(id=id).exists()
        if not book_obj:
            return Response('不存在id为%s的数据，请重试' % id)
        else:
            models.Book.objects.filter(id=id).delete()
            return Response("删除成功")

视图CBV

补充

转载：https://blog.csdn.net/weixin_42820697/article/details/84066497

serializers.Serializer 序列化

①在对序列化器进行save()保存时，可以额外传递数据，这些数据可以在create()和update()中的validated_data参数获取到
serializer.save(owner=request.user)
②默认序列化器必须传递所有required的字段，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新
serializer = CommentSerializer(comment, data={‘content’: u’foo bar’},
partial=True)

模型类序列化器

class HeroInfoSerializer(serializers.Modelserializers)
class Meta:
1–model = 模型 # 指定序列化的数据从哪来
2–fields = [‘字段1’, ‘字段2’] # 指定序列化模型中的具体字段
3–fields = ‘all’ # 序列化所有字段
4–read_only_fields = (‘字段1’, ‘字段2’) # 仅用于序列化输入字段
5–exclude = (‘字段’) # 除了该字段其余的都序列化
6–extra_kwargs = { # 添加或修改原有的选项参数
‘bread’: {‘min_value’: 0, ‘required’: True}},
‘bcomment’: {‘max_value’: 0, ‘required’: True}},
}
7–depth = 1 # 生成层级嵌套,自动序列化它的上一级(BookInfo) 1:表示嵌套的层度 如果图书的属于某个作者,获取该英雄的书籍的作者信息,depth则为2

Vue + drf 打造前后端分离的生鲜电商平台 —— 周报 1
MartinHub
01-18 986
—————— 学习周报 2019.1.20 掌握的技术： Vue + Django REST framework 前后端分离技术 restful api 开发流程 Django REST framework 的功能实现和核心源码分析 Sentry 完成线上系统的错误日志的监控和警告 第三方登录和支付宝支付的集成 本地调试远程服务器代码技巧 ...
django restful API
weixin_42067536的博客
10-24 1150
注意，这里的只是app的路由 ，并不是项目的路由，将数据库内容 转为python的格式。注册APP到django里。运行django,默认l。
Django-Rest framwork框架 序列化与反序列化
Lyajpunov的博客
02-17 878
一、Restful API 可以总结为一句话，REST是所有Web应用都应该遵守的架构设计指导原则，面向资源是REST最明显的特征 1.1、设计规范 资源 统一接口 url 无状态 这里着重说一下无状态，什么是无状态，即所有资源都可以通过URL定位，而且这个定位与其他的资源无关，也不会因为其他资源的变化而变化。 1.2、Http常用动词 GET 从服务器获取资源 POST 在服务器创建资源或者更新资源 PUT 更新资源（客户端提供改变后所有资源） PATCH 更新资源 （客户端提供改变的属性） DELE
DjangoRestFramework的常用知识-序列化器、反序列化器的使用
weixin_49971207的博客
03-16 1261
序列化器：将复杂数据 (如查询集和模型实例) 转换为可以轻松渲染成json等格式 示例：项目信息获取 如下为常规处理方法 def get(self, request): # a.获取所有项目数据（查询集），获取列表数据 queryset = Projects.objects.all() b.将项目的查询集数据转化为嵌套字典的列表 project_list = [] for item in queryset:
django-rest-framework序列化外键操作序列化
junxieshiguan的博客
03-23 7033
项目是有django django-rest-framework django-filter 组合。其中django-rest-framwork的几个组合包一定要记得下载，否则会导致部分功能不能用。 这是依赖包，都得装上。 coreapi（1.32.0+） - 文档生成支持。在django-filter的参数添加后可以直接在这里显示 Markdown（2.1.0+） - Markdown对可浏...
关于 djangorestframework记录一篇：Serializer序列化、反序列化
白骨梦儿
11-16 573
一、django drf快速入门：django项目创建+project独立虚拟环境创建 #pycharm 打开一个新建的文件夹 #安装依赖包virtualenv：创建虚拟环境的工具包 pip install virtualenv #创建一个virtualenv来隔离我们本地的包依赖关系 virtualenv venv #windows下激活（即：使用）虚拟环境 venv\Scripts\activate #在linux中，source env/bin/activate #在创建的虚拟环境中安
DRF框架的使用入门（一）解决DRF跨域请求问题
paul0926的博客
06-03 6819
DRF框架即django rest framework简介配置过程 环境版本(django1.11,python3.5) 前文：推荐看官方文档：https://www.django.cn/course/show-20.html 配置过程 在自己所使用的的workon环境下先pip install pip install djangorestframework 然后安装应用settings.py的...
Django电商平台
qq_43210924的博客
04-29 543
Django电商平台 数据库设计 用户数据库模型设计 class UserProfile(AbstractUser): # 继承Django原先的用户基类 ''' Username and password are required. Other fields are optional. ''' gender_choice = [ ...
Django框架
PAcaption的博客
08-17 1835
Django框架 Django是Python Web应用框架， 基于Python的WSGI（Web Service Gateway Interface）Web服务网关接口， Django从3.0开始运行 ASGI (异步服务网关接口)。 Django三大版本： Django 1.x、Django 2.x, Django 3.x（性能最优， 比较FastAPI/Tornado）。 一、 Django入门 1.1 基本概念 1.2 创建环境与app项目 安装依赖包 pip install djang
Django REST Framework序列化外键获取外键的值方法
09-18
今天小编就为大家分享一篇Django REST Framework序列化外键获取外键的值方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
django restframework serializer 增加自定义字段操作
09-16
主要介绍了django restframework serializer 增加自定义字段操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
serialize-error:将错误序列化为一个普通对象
04-28
序列化错误 将错误序列化/反序列化为普通对象 例如，在需要JSON.stringify()或process.send()错误时JSON.stringify() 。 安装 $ npm install serialize-error 用法 const { serializeError , deserializeError } = require ( 'serialize-error' ) ; const error = new Error ( ':unicorn:' ) ; console . log ( error ) ; //=> [Error: :unicorn:] const serialized = serializeError ( error ) console . log ( serialized ) ; //=> {name: 'Error', message: ':unicorn:', stack: 'Error: :unicorn:\n
djangorestframework序列化时一同返回外键关联表的数据信息
weixin_42143550的博客
03-07 1813
models.py class Snippet(models.Model): created = models.DateTimeField(default=ytime) title = models.CharField(max_length=100, blank=True, default='') code = models.TextField() linenos ...
DjangoRestFramework使用总结
记录一些有用的东西
12-13 4024
本文主要描述DjangoRestFramework的相关内容，内容比较全，可以当使用手册使用。
DjangoRestFramework系列教程（2）：请求（request对象）和响应（response对象）
qq_40733949的博客
07-19 964
教程2：请求和响应 从现在开始，我们将真正开始讨论REST框架的核心。让我们介绍几个基本的构建块。 请求对象（Request objects） REST框架引入了一个Request对象，该对象扩展了HttpRequest，并提供更灵活的请求解析。的核心功能。Request对象是request.data属性，类似于request.POST，但是对于使用WebAPI更有用。 request.POST ...
DjangoRestFramework，序列化组件、视图组件
cnmeimei的博客
07-27 429
一 序列化组件 　　首先按照restful规范咱们创建一些api接口，按照下面这些形式写吧： 　　　　Courses --- GET ---> 查看数据----->返回所有数据列表[{},{},] 　　　　Courses--- POST --->添加数据 -----> 返回添加的数据{ } 　　　　courses/1 ---PUT---> 更新pk=1的数据 ----->返回更新后的数据{ } 　　　　courses/1 --- DELETE---> 删除pk=1.
『Django』APIView视图扩展，实现不同的请求方式
最新发布
weixin_39415598的博客
11-07 342
之前讲DRF时都是用GET请求来讲解，其实DRF还提供了POSTPUTDELETE等方法。只要在视图函数前面加一个装饰器说明一下可支持的请求方法即可。
Python JSON序列化与反序列化实战
"Python Json序列化与反序列化的示例" 在Python中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它基于ECMAScript的一个子集，采用完全独立于语言的文本格式，易于人阅读和编写，同时也易于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值