day72 serialization family

Serialization family

1、Serializer类：底层序列化-了解的类
重点：单表序列化

2、modelSerializer类：模型序列化类-核心类
重点：多表序列化

3、ListSerializer类:群操作序列化类-辅助类
    重点：辅助完成单表多表群增群改操作

三流：
import sys

# 标准输出流
sys.stdout.write('123\n')
sys.stdout.write('456\n')

# 标准输入流
res=sys.stdin.readline()
print(res)

# 标准错误流
sys.stderr.write('jdjf\n')
sys.stderr.write('hsh\n')

内部类：
def fn():
    def func():
        pass


class A:
    class B:  # B类的名称可以通过A类来访问
        x = 10
        y = 20


print(A.B.x)  # 10

Serializer Serialization (understand)

View class

 # 单查群查
    #视图类序列化过程
    #1）ORM操作得到数据
    #2）将数据序列化成可以返回给前台的数据
    #3）返回数据给前台

    def get(self,request,*args,**kwargs):
        pk=kwargs.get('pk')
        if pk:
            user_obj=models.User.objects.filter(is_delete=False,pk=pk).first()
            if not user_obj:
                return Response({
                    'status':1,
                    'msg':'pk error',
                },status=400)

            user_ser=serializers.UserSerializer(user_obj,many=False)#将从数据库查到的数据对象传进去，many默认为False，单查，返回的也是一个类实例化的对象
            user_obj_data=user_ser.data
            return Response({
                'status':0,
                'msg':'ok',
                'results':user_obj_data
            })
        else:
            #将对象对外提供的字段，已经整个序列化过程封装，形成序列化类
            user_query=models.User.objects.filter(is_delete=False).all()
            user_ser=serializers.UserSerializer(user_query,many=True)#将从数据库查到的query对象传进去，many为True，群查，返回的也是一个类实例化的对象
            user_list_data=user_ser.data
            return Response({
                'status': 0,
                'msg': 'ok',
                'results': user_list_data
            })

Class sequence

1, a sequence of fields, model class name field corresponds to the field type to be treated (type of sequences which are involved only necessary to provide conditions)
2, model class and some fields, but there is no corresponding sequence of field, which does not participate in serialization
3, the custom serialization field (a method), the type field is SerializerMethodField (), values are get_ custom field name (self, obj) method provides, with typical values are involved in the object model serialization (model_obj) related

from rest_framework import serializers
from django.conf import settings
from . import models


class UserSerializer(serializers.Serializer):
    # 1）字段名与字段类型要处理的model类对应
    # 2）不提供的字段，就不参与序列化给前台
    # 3）可以自定义序列化字段，采用方法序列化，方法固定两个参数，第二个参数就是参与序列化的model对象
    #   （严重不建议自定义字段与数据库字段重名，由get_自定义字段名方法的返回值提供字段值）
    usernamae = serializers.CharField()
    # sex=serializers.SerializerMethodField()不建议这样命名
    gender = serializers.SerializerMethodField()

    def get_gender(self, obj):
        return obj.get_sex_display()  # 返回的值给gender

    # 注：在高级序列化与高级视图类中，drf默认帮我们处理图片等子资源
    icon = serializers.SerializerMethodField()

    def get_icon(self, obj):
        return '%s%s%s' % (settings.BASE_URL, settings.MEDIA_URL, obj.img)

Serializer deserialization (understand)

View class

 #单增
    #视图类反序列化过程
    #1）从请求对象中获取前台提交的数据
    #2）交给序列化类完成反序列化（数据的校验）
    #3）借助序列化类完成数据入库
    #4）反馈给前台处理结果

    def post(self,request,*args,**kwargs):
        request_data=request.data#取出前端传来的数据
        user_ser=serializers.UserDeSerializer(data=request_data)
        if user_ser.is_valid():
            #入库
            user_obj=user_ser.save()
            return Response({
                'status':0,
                'msg':'ok',
                'results':serializers.UserSerializer(user_obj).data#将入库得到的user对象重新序列化的数据返回给前台
            })
        else:
            return Response({
                'status': 1,
                'msg': user_ser.errors,
            })

Class sequence

1, the system verifies the checksum field with a custom field definition no difference: Field Type field = serializers (Condition)
2, custom check field is not directly warehousing, storage rules need to set or remove no storage (such field is involved in the use of global parity)
3, all the fields may be provided corresponding local checksum hook, hook method validate_ field name (self, value field value)
rules: direct return value success, failure throw the ValidationError information check fails ( 'error')
4, a sequence of existence a global parity may be overall hook, hook method validate all fields (self, all the field values attrs dictionary)
rules: attrs successfully returned directly , failed verification failure message is thrown ValidationError ({ 'anomaly field', 'error'})
5, a method implemented by rewriting create storage, storage returns successful object
6, the update method implemented change rewritable storage, returns the object storage success

class UserDeSerializer(serializers.Serializer):
    # 系统校验字段
    usernamae = serializers.CharField(min_length=3, max_length=16, error_messages={
        'min_length': '太短',
        'max_length': '太长'
    })
    password = serializers.CharField(min_length=3, max_length=16)
    # 不写，不参加反序列化，写了就必须参加反序列化（但可以设置required=False取消必须）
    # required=False的字段，前台不提供，走默认值，提供就一定进行校验，不写前台不提供都采用默认值
    sex = serializers.BooleanField(required=False)

    # 自定义校验字段：其设置语法与系统字段没有区别，但是这些字段不能参与入库操作，需要在全局钩子中，将其取出
    re_password = serializers.CharField(min_length=3, max_length=16)

    # 局部钩子
    # 方法就是validate_校验的字段名（self,校验的字段数据）
    # 校验规则：成功直接返回value，失败跑出校验失败信息
    def validate_usernamae(self, value):
        if 'g' in value.lower():
            raise serializers.ValidationError('名字中不能有g')
        return value

    # 全局钩子
    # 方法就是validate（self，所有的校验数据）
    # 校验规则：成功直接返回attrs，失败跑出校验失败信息
    def validate(self, attrs):
        password = attrs.get('password')
        re_password = attrs.pop('re_password')
        if password != re_password:
            raise serializers.ValidationError({'re_password':'两次密码不一致'})
        return attrs

    # 在视图类中调用序列化类的save方法完成入库，Serializer类能做的增入库走create方法，改入库走update方法
    # 但Serializer没有提供两个方法的实现体 自己写

    def create(self, validated_data):
        return models.User.objects.create(**validated_data)

    #instance要被修改的对象，validated_data代表校验后用来盖instance的数据
    def update(self, instance, validated_data):
        #用户名不能被修改
        validated_data.pop('usernamae')
        models.User.objects.filter(pk=instance.id).update(**validated_data)
        return instance

ModelSerializer serialization and de-serialization (focus)

View class

class UserV3APIView(APIView):
    # 单查群查
    def get(self,request,*args,**kwargs):
        pk=kwargs.get('pk')
        if pk:
            user_obj=models.User.objects.filter(is_delete=False,pk=pk).first()
            if not user_obj:
                return Response({
                    'status':1,
                    'msg':'pk error',
                },status=400)

            user_ser=serializers.UserModelSerializer(user_obj,many=False)#将从数据库查到的数据对象传进去，many默认为False，单查，返回的也是一个类实例化的对象

            return Response({
                'status':0,
                'msg':'ok',
                'results':user_ser.data
            })
        else:
            #将对象对外提供的字段，已经整个序列化过程封装，形成序列化类
            user_query=models.User.objects.filter(is_delete=False).all()
            user_ser=serializers.UserModelSerializer(user_query,many=True)#将从数据库查到的query对象传进去，many为True，群查，返回的也是一个类实例化的对象
            return Response({
                'status': 0,
                'msg': 'ok',
                'results': user_ser.data
            })
 # 单增
    def post(self,request,*args,**kwargs):
        user_ser=serializers.UserModelSerializer(data=request.data)
        if user_ser.is_valid():
            #入库
            user_obj=user_ser.save()
            return Response({
                'status':0,
                'msg':'ok',
                'results':serializers.UserModelSerializer(user_obj).data#将入库得到的user对象重新序列化的数据返回给前台
            })
        else:
            return Response({
                'status': 1,
                'msg': user_ser.errors,
            })

Serialization

ModelSerializer class serialization and deserialization summarized
1, class inheritance ModelSerializer sequence, it needs to be configured in the configuration class Meta
2, model configuration: a Model binding sequence correlation table
3, fields arranged: a plug-in to set all participation serialization and deserialization field
4, extra_kwargs configuration:
divide the system into three fields: read-only (read_only), write only (write_only), read-write (not set)
field is necessary: required
optional field: in extra_kwargs configuration, without setting required, and has a default value of
5, the custom serialization fields:
a first (not promote): in the class with the sequence SerializerMethodField () to achieve
a second (advocates): model class @property achieved with pluggable
6, custom deserialization fields:
only in this statement is provided with Serializer classes and rules, or hooks provided, in its inactive in extra_kwargs provided
custom deserializing system fields and fields, set rules, it must be provided WRITE_ONLY
. 7, the local hook, with the overall hook Serializer class
8, and need not rewrite create u pdate method

class UserModelSerializer(serializers.ModelSerializer):
    #第一种自定义序列化字段，该字段必须在fileds中设置
    #第二种：在models.py中定义
    # gender=serializers.SerializerMethodField()
    # def get_gender(self,obj):
    #     return obj.get_sex_display()

    #自定义反序列化字段同Serializers类，且规则只能在此声明中设置，或是在钩子中设置
    #在extra_kwargs中对其设置的无效
    #注：自定义反序列化字段与系统字段，设置规则一样，所有必须设置write_only
    re_password=serializers.CharField(min_length=3,max_length=16,write_only=True)

    class Meta:
        model=models.User
        #fileds采用插拔式  设置所有参与序列化字段
        fields=('usernamae','gender','icon','password','sex','re_password')
        extra_kwargs={
            'usernamae':{#系统字段不设置read_only和write_only，默认都参加
                'min_length':3,
                'max_length':10,
                'error_messages':{
                    'min_length': '太短',
                    'max_length': '太长'
                }
            },
            'gender':{
                'read_only':True,#自定义的序列化字段默认就是read_only,且不能修改，可以忽略
            },
            'password':{
                'write_only':True,
            },
            'sex':{ #像sex有默认值的字段，为选填字段（‘required’：True可以将其变为必填字段
                'write_only':True
                # 'required':True
            }
        }

    # 局部全局钩子同Serializer类，是与 Meta 同缩进的
    def validate_username(self, value):
        if 'g' in value.lower():
            raise serializers.ValidationError('名字中不能有g')
        return value

    def validate(self, attrs):
        password = attrs.get('password')
        re_password = attrs.pop('re_password')
        if password != re_password:
            raise serializers.ValidationError({'re_password': '两次密码不一致'})
        return attrs
# create和update方法不需要再重写，ModelSerializer类已提供，且支持所有关系下的连表操作

Model Class

from django.db import models

# Create your models here.
class User(models.Model):
    SEX_CHOICES=(
        (0,'女'),
        (1,'男')
    )
    usernamae=models.CharField(max_length=64,verbose_name='用户名',blank=True,unique=True)
    password=models.CharField(max_length=64,verbose_name='密码')
    sex=models.IntegerField(choices=SEX_CHOICES,default=0,verbose_name='性别')
    img=models.ImageField(upload_to='img',default='img/default.png',verbose_name='头像')
    #开发中，数据不会直接删除，用过字段控制
    is_delete=models.BooleanField(default=False,verbose_name='是否注销')
    #数据库数据入库，一般都会记录该数据第一次入库时间，有时候还会记录最后一次更新时间
    create_time=models.DateTimeField(auto_now_add=True,verbose_name='创建时间')

    #第二种自定义序列化字段（插拔式，提倡使用）
    @property
    def gender(self):
        return self.get_sex_display()

    @property
    def icon(self):
        from django.conf import settings
        return '%s%s%s' % (settings.BASE_URL, settings.MEDIA_URL, self.img)

    class Meta:#配置类，给你所属类提供配置信息
        db_table='old_boy_user'
        verbose_name_plural='用户表'

    def __str__(self):#不要在这里进行连表操作，admin页面可能会崩溃
        return self.usernamae