首页 > 其他分享 >Django序列化器的简单使用

Django序列化器的简单使用

时间：2023-01-11 10:25:54浏览次数：58  
标签：None serializers ser Django book 简单 序列化 data

[Django序列化器的简单使用 - SSgeek - 博客园](https://www.cnblogs.com/ssgeek/p/13263810.html)

注意：serializer 不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer 是独立于数据库之外的存在。

目录

 

序列化器serializer的介绍：

  • 序列化，序列化器会把模型对象转换成字典，经过response 之后变成json 字符串。
  • 反序列化，把客户端发送过来的数据，经过request 之后变成字典，序列化器可以把字典装换成模型。
  • 反序列化，完成数据的校验功能

为方便理解后面序列化器中的字段，我们先在创建的APP中的models.py 建立一个数据库模型类。

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    author = models.CharField(max_length=32)
    publish = models.CharField(max_length=32)

1、定义Serializer类

drf 中的序列化器使用类来定义，这个类必须继承rest_framework.serializer.Serializer 。在类中写需要序列化的字段，即需要序列化哪些字段就在类中写哪个字段。为使代码清晰、方便管理，我们可以新建一个ser.py 文件来存储序列化器的代码。简单定义代码如下所示：

# ser.py
from rest_framework import serializers

# 声明序列化器，所有的序列化器都要直接或间接的继承于Serializer
class BookSerializer(serializers.Serializer):
    id=serializers.CharField()
    name=serializers.CharField()
    # price=serializers.DecimalField()  
    '''
    可以将各个字段数据类型与数据库中的数据字段类型匹配，也可以将其装换称字符类型进行序列化传递到前段，在前段处理数据时再进行数据类型的变换
    '''
    price=serializers.CharField()
    author=serializers.CharField()  
    publish=serializers.CharField()

注意：serializer 不是只能为数据库模型类定义，也可以为非数据库模型类的数据定义。serializer 是独立于数据库之外的存在。

它的常用字段：

字段 字段构造方式
BooleanField BooleanField()
NullBooleanField NullBooleanField()
CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
SlugField SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
URLField URLField(max_length=200, min_length=None, allow_blank=False)
UUIDField UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' - 如: "123456789012312313134124512351145145114" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"
IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
IntegerField IntegerField(max_value=None, min_value=None)
FloatField FloatField(max_value=None, min_value=None)
DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
DurationField DurationField()
ChoiceField ChoiceField(choices) choices与Django的用法相同
MultipleChoiceField MultipleChoiceField(choices)
FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ImageField ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
ListField ListField(child=, min_length=None, max_length=None)
DictField DictField(child=)

选项参数：

参数名称 作用
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
max_value 最小值
min_value 最大值

通用参数：

参数名称 说明
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于HTML展示API页面时，显示的字段帮助提示信息

2、创建Serializer对象

在定义好序列化器类之后，我们就可以创建序列化对象了。

序列化对象的够造方法为：

Serializer(instance=None, data=empty, **kwarg)

说明：

  • 用于序列化时，将模型类对象传入instance参数
  • 用于反序列化时，将要被反序列化的数据传入data参数
  • 除了instance和data参数外，在构造Serializer对象时，还可通过context参数额外添加数据，如除了instance和data参数外，在构造Serializer对象时，还可通过context参数额外添加数据，如
serializer = AccountSerializer(account, context={'request': request})

通过context参数附加的数据可以通过序列化对象的context属性获取。

注意：

  1. 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
  2. 序列化器无法直接接收数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
  3. 序列化器的字段声明类似于我们前面使用过的表单系统。
  4. 开发restful api时，序列化器会帮我们把模型数据转换成字典。
  5. drf提供的视图会帮我们把字典转换成json,或者把客户端发送过来的数据转换字典。

3、序列化器的使用

序列化器的使用分为两个阶段：即在客户端请求（提交）数据时，使用序列化器可以完成对数据的反序列化。在服务端响应时，使用序列化器可以完成对数据的序列化。将模型类数据装换和其他数据装换成json 格式的数据。

3.1 序列化

假如客户端以get put （查询/修改 一条数据）的请求方式与服务端进行数据交互，其中urls.py 中的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
]

即当所有请求url 为127.0.0.1:8080/books/1 的形式时，会匹配到视图类BookView ，并将pk=1作为关键字参数传递给它。

其中views.py 中有：

from rest_framework.views import APIView
from books.models import Book
from .ser import BookSerializer

class BookView(APIView):
    def get(self,request,pk):
        book=Book.objects.filter(id=pk).first() #获取一个书的对象
        book_ser=BookSerializer(book)  #将学生对象传入上面已经声明的Serializer类中，调用类的__init__方法，实例化一个serializer对象。
        # book_ser.data   序列化对象.data----->就是序列化后的字典
        return Response(book_ser.data)
    
    def put(self,request,pk):
        response_msg={'status':100,'msg':'成功'}
        # 找到这个对象
        book = Book.objects.filter(id=pk).first()
        # 得到一个序列化类的对象
        # book_ser=BookSerializer(book,request.data) # 按照位置传递参数
        book_ser=BookSerializer(instance=book,data=request.data)  # 按照关键字传递参数

        # 要进行数据验证
        if book_ser.is_valid():  # 返回True表示验证通过
            book_ser.save()  
            # 此处的save方法是序列化类提供的。
            # 如果没有重写父类的update方法会报错 这是因为抽象接口限制子类必须要重写该方法（多态）
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=101
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors

        return Response(response_msg)

此时客户端获取到的数据即为序列化后的书数据。

在ser.py 对应的序列化类中重写的update 方法：

    def update(self, instance, validated_data):
        #instance是book这个对象
        #validated_data是校验后的数据
        instance.name=validated_data.get('name')
        instance.price=validated_data.get('price')
        instance.author=validated_data.get('author')
        instance.publish=validated_data.get('publish')
        instance.save()  #book.save()   此处的save方法是django 的orm提供的
        return instance

3.2 反序列化

假如客户端以post get （创建一条 / 查询所有）请求方式与服务端进行数据交互，其中urls.py 的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
    path('books/', views.BooksView.as_view()),
]

即当所有请求的url 为127.0.0.1:8080/books/ 形式时会匹配到视图类BooksView 。

其中view.py 中有：

class BooksView(APIView):
    def get(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        books=Book.objects.all()
        book_ser=BookSerializer(books,many=True)  #序列化多条,如果序列化一条，不需要写
        response_msg['data']=book_ser.data
        return Response(response_msg)
    
    def post(self,request):
        response_msg = {'status': 100, 'msg': '成功'}
        #修改才有instance，新增没有instance，只有data
        book_ser = BookSerializer(data=request.data)
        # book_ser = BookSerializer(request.data)  # 这个按位置传request.data会给instance，就报错了
        # 校验字段
        if book_ser.is_valid():
            book_ser.save()  #没有重写create方法会报错 原因同上
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=102
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors
        return Response(response_msg)

此时服务端保存的就是经过校验和反序列化的客户端发送来的序列化数据。

在ser.py 对应的序列化类中重写的create 方法：

def create(self, validated_data):
    instance=Book.objects.create(**validated_data)
    return instance

3.3 补充delete

假如客户端以post get （创建一条 / 查询所有）请求方式与服务端进行数据交互，其中urls.py 的路由匹配为：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    re_path('books/(?P<pk>\d+)', views.BookView.as_view()),
]

其中view.py 中有：

class BookView(APIView):
    def delete(self,request,pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'status':100,'msg':'删除成功'})

4、数据验证

4.1 is_valid() 方法

使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。

在获取反序列化的数据前，必须调用is_valid() 方法进行验证，验证成功返回True，否则返回False。

验证失败，可以通过序列化器对象的errors 属性获取错误信息，返回字典，包含了字段和字段的错误。如果是非字段错误，可以通过修改REST framework 配置中的NON_FIELD_ERRORS_KEY 来控制错误字典中的键名。

验证成功，可以通过序列化器对象的validated_data属性获取数据。

在定义序列化器时，指明每个字段的序列化类型和选项参数，本身就是一种验证行为。

如我们前面定义过的BookSerializer 。

class BookSerializer(serializers.Serializer):
    id=serializers.CharField(read_only=True)
    name=serializers.CharField(max_length=16,min_length=4)
    # price=serializers.DecimalField()
    price=serializers.CharField(write_only=True,required=True)
    author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址
    publish=serializers.CharField()

is_valid() 方法还可以在验证失败时抛出异常serializers.ValidationError ，可以通过传递raise_exception=True 参数开启，REST framework 接收到此异常，会向前端返回HTTP 400 Bad Request响应。

4.2 validate_字段名

例如对price 字段进行验证，在BookSerializer中定义方法：

def validate_price(self, data):   # validate_字段名  接收一个参数
    #如果价格小于10，就校验不通过
    # print(type(data))
    # print(data)
    if float(data)>10:
        return data
    else:
        #校验失败，抛异常
        raise ValidationError('价格太低')

4.3 validate

    def validate(self, validate_data):   # 全局钩子
        print(validate_data)
        author=validate_data.get('author')
        publish=validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字跟出版社一样')
        else:
            return validate_data

4.4 validators

在字段中添加validators 选项参数，也可以补充验证行为，如

def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者名字不能以sb开头')
    else:
        return data
    
    
class BookSerializer(serializers.Serializer):
       author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址

5、模型类序列化器

如果我们想要使用序列化器对应的是Django的模型类，DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

ModelSerializer与常规的Serializer相同，但提供了：

  • 基于模型类自动生成一系列字段
  • 基于模型类自动为Serializer生成validators，比如unique_together
  • 包含默认的create()和update()的实现

5.1 定义

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book  # 对应上models.py中的模型
        fields='__all__'
  • model 指明参照哪个模型类
  • fields 指明为模型类的哪些字段生成

5.2 指定字段

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book  # 对应上models.py中的模型
        fields = '__all__'
        # fields=('name','price','id','author') # 只序列化指定的字段
        # exclude=('name',) #跟fields不能都写，写谁，就表示排除谁
        # read_only_fields=('price',)
        # write_only_fields=('id',) #弃用了，使用extra_kwargs
        extra_kwargs = {  # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
            'price': {'write_only': True},
        }

我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date', 'bread', 'bcomment')
        extra_kwargs = {
            'bread': {'min_value': 0, 'required': True},
            'bcomment': {'min_value': 0, 'required': True},
        }

# BookInfoSerializer():
#    id = IntegerField(label='ID', read_only=True)
#    btitle = CharField(label='名称', max_length=20)
#    bpub_date = DateField(allow_null=True, label='发布日期', required=False)
#    bread = IntegerField(label='阅读量', max_value=2147483647, min_value=0, required=True)
#    bcomment = IntegerField(label='评论量', max_value=2147483647, min_value=0, required=True)

6、补充

many=True的实际用途

# 序列化多条，需要传many=True
# 
book_ser=BookModelSerializer(books,many=True)
book_one_ser=BookModelSerializer(book)
print(type(book_ser))
#<class 'rest_framework.serializers.ListSerializer'>
print(type(book_one_ser))
#<class 'app01.ser.BookModelSerializer'>

# 对象的生成--》先调用类的__new__方法，生成空对象
# 对象=类名(name=lqz)，触发类的__init__()
# 类的__new__方法控制对象的生成


def __new__(cls, *args, **kwargs):
    if kwargs.pop('many', False):
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面，正常的对象实例化
    return super().__new__(cls, *args, **kwargs)

Serializer高级用法

# source的使用
	1 可以改字段名字  xxx=serializers.CharField(source='title')
    2 可以.跨表publish=serializers.CharField(source='publish.email')
    3 可以执行方法pub_date=serializers.CharField(source='test') test是Book表模型中的方法
    

# SerializerMethodField(）的使用
	1 它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    authors=serializers.SerializerMethodField() #它需要有个配套方法，方法名叫get_字段名，返回值就是要显示的东西
    def get_authors(self,instance):
        # book对象
        authors=instance.authors.all()  # 取出所有作者
        ll=[]
        for author in authors:
            ll.append({'name':author.name,'age':author.age})
        return ll
 

标签：None,serializers,ser,Django,book,简单,序列化,data
From： https://www.cnblogs.com/ministep/p/17042964.html

相关文章

  • Trie树简单应用
    Trie树简单应用首先，Trie的思想很容易理解，一张图解释一切：也即：字符集有多大，则开多少倍空间。在实现上，我们用边来存储字符，然后开一个数组表示当前节点是否是一个字符串的......
  • 3. 主从复制简单搭建(基于位点)
    1.配置参数：server_id：主备server都要配置，数字要不一样，取值范围：1~2^32  log_bin :要开启  log_slave_updates：要开启2.创建用户mysql>CREATEUSE......
  • sqlserver 简单锁实例
    /*以此表为例:SELECT*FROMtb姓名课程分数---------------------张三语文74张三数学83李四语文74李四数学84李四物理94*/--新建第一个会话窗口,......
  • SQLServer 2008 FileStream简单实例
    1.打开服务，内置账户为localsystem。（其它不行）2.选择选项FileStream，勾选以下。然后重启服务3.打开managementstudio，右键服务—属性。点击高级，会看到‘文件流’中‘文件流......
  • Django入门
    入门首先是注意这个发音：D是不发音的，jangoDjango是使用Python语言编写的一个广受欢迎且功能完整的服务器端网站框架。可以方便创建一个基本可用，安全，可扩展，可维护的项......
  • 1011.Django状态保持以及表单
    一、session保持状态状态保持：1.http协议是无状态的：每次请求都是一次新的请求，不会记得之前通信的状态；2.客户端与服务器端的一次通信，就是一次会话实现状态保持的方式：在......
  • leetcode简单(数组,字符串,链表)：[168, 171, 190, 205, 228, 448, 461, 876, 836, 844]
    目录168.Excel表列名称171.Excel表列序号190.颠倒二进制位205.同构字符串228.汇总区间448.找到所有数组中消失的数字461.汉明距离876.链表的中间结点836.矩形重......
  • 学习记录-简单工厂模式
    简单工厂模式工厂模式（FactoryPattern）是Java中最常用的设计模式之一。简单工厂模式（SimpleFactoryPattern），又称为静态工厂方法（StaticFactoryMethod）模式，它属于类创建型......
  • 用python做个简单的监控
    今天在看博客园的时候看到一篇文章，忘记是什么地址了，之前我也做过一个类似的监控，不过不好控制。之前的模式是通过内网地址访问相应的php程序，php调用python程序，能捕获到摄像......
  • JavaScript 中URL 查询字符串(query string)的序列与反序列化
    方法一：在JavaScript中，可以使用URLSearchParams对象来处理URL中的查询字符串。序列化（将JavaScript对象转换为查询字符串）可以使用URLSearchParams对象的append(......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99