标签：name python max self publish 学习 length 序列化 Day56

今日学习内容

序列化类常用字段类和字段参数

常见字段类

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)

记住一下

CharField
BooleanField
IntegerField
DecimalField

ListField    hobby:['篮球','足球']
DictField    wife:{'name':'刘亦菲','age':33}

常用字段参数

给CharField字段类使用的参数

参数名称	作用
max_length	最大长度
min_lenght	最小长度
allow_blank	是否
trim_whitespace	是否截断空白字符

给IntegerField字段类使用的参数

参数名称	作用
max_value	最小值
min_value	最大值

通用参数：放在哪个字段类上都可以的

参数名称	作用
required	表明该字段在反序列化时必须输入，默认为True
default	反序列化时使用的默认值
allow_null	表明该字段是否允许传入为None，默认False
validators	该字段使用的验证器（了解）
error_messages	包含错误编号与错误信息的字段
label	用HTML展示API页面时，显示的字段名称
help_text	用于HTML展示页面时，显示的字段名称
* read_only	只读，只用于序列化输出，默认为False 读到前端有该字段，返回来不带该字段
* write_only	只写，只用于序列化输入，默认为False 不能返回到前端展示，只将数据由前端到后端数据库保存

序列化类高级用法之source（修改序列化字段名字）

source的作用

可以指定序列化表中的某一个字段
可以指定方法，伪属性，重命名
可以做跨表查询

代码演示

class BookSerializer(serializers.Serializer):
    name_detail = serializers.CharField(max_length=8, min_length=3,source='name')
    '''原表中字段是 name ，将name字段在前端显示的时候为book_name'''
    # 或
    publish_name = serializers.CharField(max_length=8, min_length=3,source='publish.name')
    '''publish外键字段表的跨表查询'''
    # 或
    xx = serializers.CharField(max_length=8, min_length=3,source='xx') 、
    '''source的xx表示表模型中得方法'''

序列化类高级用法之定制序列化字段的两种方式

需求：

{
    "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}
# 第二种：在【表模型】中写方法（又多一些）
	def publish_detail(self):
        return {'name':self.publish.name, 'city':self.publish.city, 'email':self.publish.email}
    在序列化中取
    publish_detail=serializers.DictField()
    
# 在模型类中写逻辑代码，称之为ddd，领域驱动模型

代码演示方式一：使用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:[email protected]}
    # 方式一：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

代码演示方式二：在表模型中写

# 表模型中
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

 # 序列化类中

    #   反序列化
    publish = serializers.IntegerField(write_only=True)
    authors = serializers.ListField(write_only=True)

    #   序列化
    publish_detail = serializers.DictField(read_only=True)
    # 练习，使用方式二实现，显示所有作者
    author_list = serializers.ListField(read_only=True)

有关联关系表的反序列化的保存

   # 新增，必须要重写create

    def create(self, validated_data):
        # validate_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 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish_date = validated_data.get('publish_date')
        instance.publish_id = validated_data.get('publish')

        authors1 = validated_data.get('authors')
        instance.authors.set(authors1)

        instance.save()
        return instance

注意：

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

# 缺点
	1 在序列化中每个字段都要写，无论是序列化还是反序列化
    2 如果新增或者修改，在序列化类中都需要重写create或update
    
# 解决这个缺点，使用ModelSerializer来做

反序列化之数据校验

# 跟forms很像
	-字段自己的校验规则
    -局部钩子
    -全局钩子

字段自己的校验规则

如果继承的是Serializer，写法如下:
    name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
    -如果继承的是ModelSerializer，写法如下
       extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
        }

局部钩子

如果继承的是Serializer,写法一样。
如果继承的是ModelSerializer，写法一样。

def validate_name(self, name):
    if name.startswith('sb'):
        # 校验不通过，抛异常
        raise ValidationError('不能以sb卡头')
    else:
        return name

全局钩子

def validate(self, attrs):
    if attrs.get('name') == attrs.get('publish_date'):
        raise ValidationError('名字不能等于日期')
    else:
        return attrs

模型类序列化（ModelSerializer）的使用

class BookModelSerializer(serializers.ModelSerializer):
    # 不需要写字段， 字段从表模型映射出来
    # put = serializers.SerializerMethodField()

    class Meta:
        model = Book
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail', 'authorDetail_list',
                  'author_list']  # 所有字段都序列化

        # 给authors和publish加write_only属性
        # name加max_len属性
        extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3,
                     'error_messages': {'min_length': "书名长度过短！", 'max_length': '书名长度过长！'}},
            'price': {'max_value': 199, 'min_value': 9},
            'publish': {'write_only': True},
            'authors': {'write_only': True},
            # 'authorDetail': {'write_only': True}
        }

    # 给name字段加局部钩子，一定不要写在内部类中
    def validate_name(self, name):
        if name.count('sb') >= 1:
            raise ValidationError('名字内不能有sb')
        else:
            return name

    def validate_price(self, price):
        if price == 66:
            raise ValidationError('不能为66')
        return price

    # 用于校验密码和确认密码的两次一不一样。
    # def validate(self, attr):
    #     if attrs.get('name') == attrs.get('publish_date'):
    #         raise ValidationError('名字不能等于日期')
    #     else:
    #         return attrs

    # 定制要序列化的字段，有两种方式
    publish_detail = serializers.SerializerMethodField(read_only=True)

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

    author_list = serializers.SerializerMethodField(read_only=True)

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

总结

定义一个类继承ModelSerializer
类内部写内部内 class Meta:
在内部类中指定model(要序列化的表)
在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
在内部类中指定extra_kwargs，给字段添加字段参数的

在序列化类中，可以重写某个字段，优先使用你重写的
        name = serializers.SerializerMethodField()
    	def get_name(self, obj):
        	return 'sb---' + obj.name

以后不需要重写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

断言assert

# 框架的源码中，大量使用断言


# assert :断言，作用的判断，断定一个变量必须是xx，如果不是就报错

# 你的土鳖写法
# name = 'lqz1'
# if not name == 'lqz':
#     raise Exception('name不等于lqz')
#
# print('程序执行完了')

# assert的断言写法
name = 'lqz1'
assert name == 'lqz', 'name不等于lqz'
print('程序执行完了')

标签：name,python,max,self,publish,学习,length,序列化,Day56
From： https://www.cnblogs.com/bjyxxc/p/16736331.html

学习python-Day56