drf之day03，序列化常用字段类 字段参数 序列化类高级用法source 序列化类高级用法之定制序列化字段的2种方法 有关联关系表的反序列化的数据保存 反序列化之数据校验

已于 2022-09-27 23:05:04 修改
阅读量372 收藏
点赞数
分类专栏： django 文章标签： python 前端 开发语言
于 2022-09-27 22:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yydsaoligei/article/details/127079815
版权

目录标题

一：序列化常用字段类

字段类作用
CharField字符类型
BooleanField布尔类型
IntegerField整型类型
DecimalField浮点类型
ListField{name:‘lqz’,age:19,hobby:[‘篮球’,‘足球’]}
DictField{name:‘lqz’,age:19,wife:{‘name’:‘刘亦菲’,‘age’:33}}

二：常用字段参数

1.CharField字段参数
参数类型作用
max_length最大长度
min_lenght最小长度
allow_blank是否允许为空
trim_whitespace是否截断空白字符
2.IntegerField字段参数
参数类型作用
max_value最小值
min_value最大值
3.通用参数
参数类型作用
required表明该字段在反序列化时必须输入，默认True
default反序列化时使用的默认值
allow_null表明该字段是否允许传入None，默认False
validators该字段使用的验证器【不需要了解】
error_messages包含错误编号与错误信息的字典
label用于HTML展示API页面时，显示的字段名称
help_text用于HTML展示API页面时，显示的字段帮助提示信息
4.重点的2个参数
参数类型作用
read_only表明该字段仅用于序列化输出，默认False
write_only表明该字段仅用于反序列化输入，默认False

三：序列化类高级用法source

1.作用：修改序列化字段名字
2.功能：
  • 1.source可以指定序列化表中的字段
book_name = serializers.CharField(max_length=8, min_length=3,source='name')
  • 2.可以指定方法, 用于重命名
 xx = serializers.CharField(max_length=8, min_length=3,source='xx')  # xx表示表模型中得方法
  • 3.跨表查询
publish_name = serializers.CharField(max_length=8,min_length=3,source='publish.name')

四：序列化类高级用法之定制序列化字段的2种方法

前端显示形式

{
        "name": "西游记",
        "price": 33,
        "publish": {name:xx,city:xxx,email:sss}
}
方法一：
  • 在序列化类中写serializerMethodField()
publish = serializers.SerializerMethodField()
def get_publish(self, obj):
    # obj 是当前序列化的对象
    return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
  • 整个代码演示：使用SerializerMethodField
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(min_value=10, max_value=99)
    publish_date = serializers.DateField()
    # publish要序列化成 {name:北京出版社，city：北京，email:2@qq.com}
    # 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么
    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

    # 练习，用方式一，显示所有作者对象  []
    authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        res_list = []
        for author in obj.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list
方法二：
  • 1.在表模型中写方法
 def publish_detail(self):
     return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
  • 2.在序列化中取
 publish_detail=serializers.DictField()
  • 整个代码演示：在表模型中写
# 表模型中
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField(null=True)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    # 写了个方法，可以包装成数据属性，也可以不包
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}

    def author_list(self):
        res_list = []
        for author in self.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

# 序列化类中
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(min_value=10, max_value=99)
    publish_date = serializers.DateField()

    # 方式二：在表模型中写方法
    publish_detail = serializers.DictField(read_only=True)
    # 练习，使用方式二实现，显示所有作者
    author_list = serializers.ListField(read_only=True)
补充小知识点
  • 在模型类中写逻辑代码，称之为ddd，领域驱动模型

五：有关联关系表的反序列化的数据保存

1.序列化作用的字段

publish_detail = serializers.DictField(read_only=True)
author_list = serializers.ListField(read_only=True)

2.反序列化作用的字段

publish = serializers.CharField(write_only=True)
authors = serializers.ListField(write_only=True)

3.使用继承Serializer的序列化类保存需要重写create方法

# 2 一定要重写create  【序列化类中】
	    def create(self, validated_data): 
            # validated_data 校验过后的数据  
              {"name":"三国1演义",
                "price":19,
                "publish_date": "2022-09-27",
                "publish":1,
                "authors":[1,2]
                }
            book = Book.objects.create(name=validated_data.get('name'),
                                       price=validated_data.get('price'),
                                       publish_date=validated_data.get('publish_date'),
                                       publish_id=validated_data.get('publish'),
                                       )
            authors = validated_data.get('authors')
            book.authors.add(*authors)
            return book

六：反序列化之数据校验

1.跟forms组件很像
  • 字段自己的校验
  • 全局钩子
  • 局部钩子
2.字段自己的校验规则
  • 1.继承的是Serializer，写法如下
name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
  • 2.如果继承的是ModelSerializer，写法如下
 extra_kwargs = {
'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
        }
3.局部钩子
  • 继承的是Serializer和继承的是ModelSerializer，写法一样
def validate_name(self, name):
    if name.startswith('sb'):
        # 校验不通过，抛异常
        raise ValidationError('不能以sb卡头')
    else:
        return name
4.全局钩子
  • 继承的是Serializer和继承的是ModelSerializer，写法一样
def validate(self, attrs):
        if attrs.get('name') == attrs.get('publish_date'):
            raise ValidationError('名字不能等于日期')
        else:
            return attrs
七：模型类序列化器（ModelSerializer）的使用
class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
    # 不需要写字段了，字段从表模型映射过来
    class Meta:
        model = Book  # 要序列化的表模型
        # fields='__all__' # 所有字段都序列化
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
                  'author_list']  # 列表中有什么，就是序列化哪个字段
        # 给authors和publish加write_only属性
        # name加max_len属性
        extra_kwargs = {
            'name': {'max_length': 8},
            'publish': {'write_only': True},
            'authors': {'write_only': True},
        }  
   publish_detail = serializers.SerializerMethodField(read_only=True)
	 ...
   author_list = serializers.SerializerMethodField(read_only=True)
	...
总结：

  • 1.定义一个类继承ModelSerializer

  • 2 类内部写内部内 class Meta:

  • 3.在内部类中指定model(要序列化的表)

  • 4.在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])

  • 5 在内部类中指定extra_kwargs，给字段添加字段参数的

  • 6 在序列化类中，可以重写某个字段，优先使用你重写的

  •  name = serializers.SerializerMethodField()
    	def get_name(self, obj):
        	return 'sb---' + obj.name

  • 7.以后不需要重写create和update,ModelSerializer写好了，兼容性更好，任意表都可以直接存

八：反序列化数据校验源码分析（了解）

# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：validate_name，全局叫：validate 为什么？

# 入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
	-BaseSerializer内的is_valid()方法
	    def is_valid(self, *, raise_exception=False):
            if not hasattr(self, '_validated_data'):
                try:
                    # 真正的走校验，如果成功，返回校验过后的数据
                    self._validated_data = self.run_validation(self.initial_data)
                except ValidationError as exc:
            return not bool(self._errors)
    
    -内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
    	-如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
    	-这不是代码的执行，代码执行要从头开始找，从自己身上再往上找
    	    def run_validation(self, data=empty):
                #局部钩子的执行
                value = self.to_internal_value(data)
                try:
                    # 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
                    value = self.validate(value)
                except (ValidationError, DjangoValidationError) as exc:
                    raise ValidationError(detail=as_serializer_error(exc))

                return value
  -全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的
     def to_internal_value(self, data):
        for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象
            # 反射：去self：序列化类的对象中，反射 validate_字段名 的方法
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 这句话是字段自己的校验规则（最大最小长度）
                validated_value = field.run_validation(primitive_value)
                # 局部钩子
                if validate_method is not None:
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
                errors[field.field_name] = exc.detail

        return ret
    
 # 你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field

九：断言

1.定义：
  • 判断，断定一个变量必须的值，如果不是就报错
2.案例：
name = 'lqz1'
assert name == 'lqz', 'name不等于lqz'
print('程序执行完了')

作业1

  • 继承ModelSerializer写五个接口

models.py定制序列化类

 def publish_de(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}

    def author_li(self):
        res_list = []
        for author in self.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

serializer.py

class BookModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_de', 'author_li']
        extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3,
                     'error_messages': {'min_length': "最短长度不能小于3", 'max_length': '最大长度不能超过8'}
                     },
            'publish': {'write_only': True},
            'authors': {'write_only': True},
            'price': {'max_value': 199, 'min_value': 9}
        }

    def validate_name(self, name):
        if 'sb' in name:
            raise ValidationError('名字中不能出现sb')
        else:
            return name

    def validate_price(self, price):
        if price == 66:
            raise ValidationError('书的价格不能是66')
        else:
            return price

作业2

  • 继承Serializer写五个接口

serializer.py

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(max_value=199, min_value=9)
    publish_date = serializers.DateField()

    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

    authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        res_list = []
        for author in obj.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)

    def create(self, validated_data):
        # validated_data 校验过后的数据
        book = Book.objects.create(name=validated_data.get('name'),
                                   price=validated_data.get('price'),
                                   publish_date=validated_data.get('publish_date'),
                                   publish_id=validated_data.get('publish'),
                                   )
        authors = validated_data.get('authors')
        book.authors.add(*authors)
        return book

    def update(self, instance, validated_data):
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_data = validated_data.get('publish_date')
        instance.publish_id = validated_data.get('publish')
        instance.authors.set(validated_data.get('authors'))
        instance.save()
        return instance

views.py

from rest_framework.views import APIView
from .models import Book
# from app01.serializer import BookModelSerializer
from app01.serializer import BookSerializer
from rest_framework.response import Response


class BookView(APIView):
    # 查看所有数据
    def get(self, request):
        book = Book.objects.all()
        ser = BookSerializer(instance=book, many=True)
        # ser = BookModelSerializer(instance=book, many=True)
        return Response(ser.data)

    # 新增数据
    def post(self, request):
        ser = BookSerializer(data=request.data)
        # ser = BookModelSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book)
        # ser = BookModelSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book, data=request.data)
        # ser = BookModelSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            Response(ser.errors)

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

作业3

  • 出版社，作者，作者详情，5个接口写完
class AuthorModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['name', 'age', 'author_de']

        extra_kwargs = {
            'author_de': {'read_only': True},

        }

class AuthorView(APIView):
    def get(self, request):
        author_list = Author.objects.all()
        ser = AuthorModelSerializer(instance=author_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = AuthorModelSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)

class AuthorDetailView(APIView):
    def get(self, request, pk):
        author_list = Author.objects.filter(pk=pk).first()
        ser = AuthorModelSerializer(instance=author_list)
        return Response(ser.data)

    def put(self, request, pk):
        auth_list = Author.objects.filter(pk=pk).first()
        ser = AuthorModelSerializer(instance=auth_list, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)
    def delete(self, request, pk):
        Author.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})
Jayxieming
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DRF---序列化组件
Yietong的博客
09-26 348
可以加property装饰 也可以不加 序列化组件可以不用加括号拿到@property有关联关系表数据创建# 只写不读 只反序列化不序列化# 只读不写 只序列化不反向序列化# 继承serializers.Serializer一定要重写creata方法和update方法# 创建书籍数据# 添加书籍和作者关系 多对多总结：继承Serializer的序列化组件需要写校验的每个字段，创建和修改数据时，需要重写create和update方法。而使用ModelSerializer，不需要写这些。
python drf_Python正课134 —— DRF 进阶1
weixin_39575502的博客
12-22 259
restful就是一个接口开发的约定俗成的开发规范。不局限于django或者drf，即便我们不使用drf，其实也能实现符合restful规范的api接口。同时，drf框架不是restful作者开发出来的！！！一：序列化器-Serializer作用：1.序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串2.反序列化,把客户端发送过来的数据,经过视图调用r...
DRF学习笔记（一）运用Django实现DRF功能
weixin_44747173的博客
01-04 1433
(一)项目结构 (一)创建数据库模型booktest/models.py from django.db import models class Book(models.Model): id = models.AutoField(primary_key=True) # id 会自动创建，可以手动写入 title = models.CharField(max_length=32) # 书籍名称 # DecimalField用来限制数字大小，max_digits=5表示价格最大为
DRF序列化和反序列化——基本使用
zy010101博客
11-26 1613
DRF序列化和反序列化 定义序列化器 DRF中有serializer的类，我们可以从rest_framework进行导入。 from rest_framework import serializers 我们自定义的序列化器必须继承自 rest_framework.serializers.Serializer 现在假如我们有一个模型类，如下： class BookInfo(models.Model): """书籍信息模型""" name = models.CharField(max_leng
drf : source，定制序列化字段以及反序列化新增。局部钩子(validate_字段名)，全局钩子(validate)...
felix的博客
04-01 398
source,SerializerMethodField,局部钩子，全局钩子 serialzer.py : source 用处1对应字段：起别名， 用处2对应方法：在表模型中定义一个方法，source可以与其关联 用处3对应方法：可以当做字段 第三种方法的扩展用法：使用程度高。 model.py from django.db import models # Create your mo...
DRF的序列化——Serializers 序列化组件
01-20
为什么要用序列化组件 当我们做前后端分离的项目~~ 我们前后端交互一般都选择JSON数据格式，JSON是一个轻...Django的序列化方法 class BooksView(View): def get(self, request): book_list = Book.objects.values(id
Django框架序列化与反序列化操作详解
01-20
使用`serialize()`函数进行序列化，而`deserialize()`函数（在DRF中是`to_representation()`和`to_internal_value()`方法）用于反序列化。 例如，当一个POST请求包含图书数据时，`BookInfoSerializer`会将这些数据...
django序列化时使用外键的真实值操作
09-16
除了Django自带的序列化库，还可以使用Django REST Framework（DRF）进行更高级的序列化操作。DRF提供了更多的定制选项，如自定义序列化器、字段选择、分页、过滤等，使得API接口的构建更加灵活和高效。 总之，通过...
Django框架中序列化和反序列化的例子
09-18
`serializers.Serializer` 类是基础序列化器，可以定义与模型类字段对应的序列化字段。例如： ```python class BookInfoSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) ...
python-DRF_修改删除接口_source用法_模型类序列化器_SerializerMethodField_drf的请求响应_many=True_局部全局钩子解析
qq_31455841的博客
11-03 1033
hhhhhh
DRF-(3)
最新发布
AL_QX的博客
09-27 443
序列化类
DRF 序列化器常用字段与参数
m0_63969219的博客
06-10 779
DRF 序列化器常用字段与参数
drf 序列化组件
go|Python的个人博客
03-09 788
文章目录DRF 序列化组件1 序列化组件介绍2 简单使用步骤3 序列化类的字段类型与选项4 序列化组件修改数据5 read_only 和 write_only6 查询所有7 新增数据8 删除一个数据9 模型类序列化器10 源码分析11 Serializer高级用法 DRF 序列化组件 1 序列化组件介绍 序列化: 序列化器会把模型对象装换成字典，经过response以后变成json字符串 反序列化: 把客户端发送过来的数据进行数据校验，通过后经过reques
DRF框架——序列化器的使用
钟灵毓秀的博客
07-29 1026
一、什么是DRF框架？ Django REST framework 框架是一个用于构建Web API 的强大而又灵活的工具。通常简称为DRF框架 或 REST framework。DRF框架是建立在Django框架基础之上，由Tom Christie大牛二次开发的开源项目。 特点 提供了定义序列化器Serializer的方法，可以快速根据 Django ORM 或者其它库自动序列化/反序列化； ...
django DRF序列化器参数说明
weixin_45983953的博客
06-22 194
参数名称 作用 max_length 最大长度 min_lenght 最小长度 allow_blank 是否允许为空 trim_whitespace 是否截断空白字符 max_value 最小值 min_value 最大值 参数名称 说明 read_only 表明该字段仅用于序列化输出，默认False write_only 表明该字段仅用于反序列化输入，默认False required
【DRF】定义序列化器类和常用的字段类型和参数选项归纳总结（3）
python全栈
05-11 509
序列化器的作⽤： 进⾏数据的校验 对数据对象进⾏转换 一、定义⽅法 模型类： from django.db import models # Create your models here. class NewsChannel(models.Model): '''新闻频道''' name=models.CharField(max_length=30,unique=True,verbose_name='频道名称') url=models.CharField(default='',n
Django REST framework - 序列化组件、source、钩子函数
qq_43520820的博客
08-26 1164
[Django REST framework - 序列化组件、source、钩子函数] 序列化器-Serializer 什么是rest_framework序列化？ 在写前后端不分离的项目时： 我们有form组件帮我们去做数据校验 我们有模板语法，从数据库取出的queryset对象不需要人为去转格式 当我们写前后端分离项目的时： 我们需要自己去做数据校验 我们需要手动去转数据格式，因为跨平台数据传输都用json字符串，不能直接jsonqueryset对象 序列化器的作用 1 序列化：把python中的对象转
自定义控件的问题:如何设置 ListSource
aibi9196的博客
01-04 80
自定义控件的问题:如何设置 ListSource VCL组件开发及应用http://www.delphi2007.net/DelphiVCL/html/delphi_20061221084905233.html 某自定义控件继承于 EDIT,功能是弹出DBGRID,选择其中某一字段 现在我想增加两个属性 ListSource和ListFiel...
DRF框架学习的小结
qq_39801390的博客
07-24 2393
DRF框架 一. 认识restful架构 REST，即Representational State Transfer的缩写 ,我们一般叫他'表现层状态转化' REST的路径设计思路是简洁:资源(比如HTML,或者图片,文档之类的)他应是名词的,我们之前在获取商品的时候,我们可能会这样写:/get_products/ 但是这样是不对的.错的.我们在路径中不应该出现动词也就是get,我们使用re...
DRF框架入门：序列化与反序列化的深度解析
本资源是一份名为《DRF框架基础.pdf》的文档，针对初学者介绍了Django Rest Framework (DRF) 的基础知识，主要关注序列化和反序列化的概念以及处理关联字段的问题。以下是主要内容的详细说明： **序列化** 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值