drf序列化与序列化器的使用

序列化类的使用

使用序列化类实现五个接口功能,但是我们发现并没有做数据校验,也没有做反序列化,是我们自己手动去进反序列化,是我们自己使用for来进行拼接的,很不方便,我们可以使用一个drf自带的名叫序列化器,来完成

路由

urlpatterns = [
    path('admin/', admin.site.urls),
    path('publish/',views.PublishView.as_view()),
]

视图函数

class PublishView(APIView):
    def get(self, request):
        publish_list = Publish.objects.all()
        l = []
        for i in publish_list:
            l.append({'name': i.name, 'addr': i.addr, })
        return Response({'code': 100, 'msg': 'ok', 'results': l})

    def post(self, request):
        publish_list = Publish.objects.create(name=request.data.get('name'), addr=request.data.get('addr'))
        return Response({'code': 100, 'msg': 'ok', 'results': {'name': publish_list.name, 'price': publish_list.addr}})


class PublishDetail(APIView):
    def get(self, request, pk):
        book_list = Publish.objects.filter(id=pk).first()
        l = []
        for i in book_list:
            l.append({'name': i.name, 'price': i.price, })
        return Response({'code': 100, 'msg': 'ok', 'results': l})

    def delete(self, request, pk):
        book_list = Publish.objects.filter(id=pk).delete()
        return Response({'code': 100, 'msg': 'ok', 'results': book_list})

    def put(self, request):
        publish_list = Publish.objects.update(**request.data)
        return Response({'code': 100, 'msg': 'ok', 'results': {'name': publish_list.name, 'price': publish_list.addr}})

序列化类-Serializer

Django REST framework中的Serializer使用类来定义,须继承自rest_framework.serializers.Serializer。

from rest_framework import serializers

from app01.models import Publish


class PublishSerializer(serializers.ModelSerializer):
        name=serializers.CharField()
        addr=serializers.CharField()

        class Meta:
                model=Publish
                fields=['name','addr'] # 或指定所有__all__
  1. 建立一个名为Serializer的py文件·
  2. 写一个类,继承为Serializer.Serializer
  3. 在类中写需要序列化的字段
  4. 在视图类中使用,完成序列化

使用序列化类
导入我们自己的序列化器
from app01.Serializer import PublishSerializer


# 使用序列化类做序列化
class PublishView(APIView):
    def get(self, request):
        publish_list = Publish.objects.all()
        ser=PublishSerializer(instance=publish_list,many=True)
        return Response({'code': 100, 'msg': 'ok', 'results': ser.data})



class PublishDetail(APIView):
    def get(self, request, pk):
        publish_list = Publish.objects.filter(id=pk).first()
        ser=PublishSerializer(instance=publish_list)
        return Response({'code': 100, 'msg': 'ok', 'results': ser.data}))
  1. 如果序列化多个则需要加上many=Ture,

使用序列化类进行校验

三层校验:

  1. 字段的校验
  2. 局部钩子:校验失败,主动使用ValidationError抛出错误
  3. 全局钩子
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

from app01.models import Publish, Books


class PublishSerializer(serializers.ModelSerializer):
    # 第一层:写需要序列化的字段名
    name = serializers.CharField()
    addr = serializers.CharField()
# 第二层 局部钩子
    def validate_name(self, name):
        if name.startswith('sb'):
            raise ValidationError('不能以sb开头')
        else:
            return name

    def validate_addr(self, addr):
        if 'sb'in addr:
            raise ValidationError("不能以sb开头")
        else:
            return addr


# 第三层全局钩子
    def validate(self, attrs):
        # attrs是校验过后的数据
        print(attrs)
        if attrs.get('name')[:3]==attrs.get('addr')[:3]:
            raise ValidationError("名称不能重复")

        return attrs


    class Meta:
        model = Publish
        fields = ['name', 'addr']  # 或指定所有__all__

全局钩子:def validate(self, attrs):

补充:attrs是已经校验过后的数据,如果前端传入了数据字段,但是我的类中并没有这个字段,那么最终校验过后的数据attrs中是没有前端传入的数据的,因为那条数据已经被删除了

put和post保存到数据库
class BookSerializer(serializers.ModelSerializer):
    name = serializers.CharField(max_length=18, min_length=3)
    price = serializers.IntegerField(max_value=999, min_value=10)
    pub_date = serializers.CharField(max_length=32)

    def validate_name(self, name):
        l = ['金瓶梅', 'sb', '傻逼']
        for i in l:
            if i in name:
                raise ValidationError('不能使用敏感字')
        return name

    def validate_price(self, price):
        if price < 10:
            raise ValidationError('价格不能小于10')
        elif price > 999:
            raise ValidationError('价格不能大于999')
        else:
            return price

    def validate(self, attrs):
        # attrs是校验过后的数据
        print(attrs)
        if attrs.get('pub_date')[:3] == attrs.get('name')[:3]:
            raise ValidationError("名称不能重复")
        return attrs

    def create(self, validated_data):
        # validated_data:校验过的数据,之前传入没有校验的数据,在这没有
        publish = Publish.objects.create(**validated_data)

        return publish  # 一定要返回publish对象,后续会拿着这个对象进行序列化,ser.



    def update(self, instance, validated_data):
        # 本方法
        # instance.name = validated_data.get('name')
        # instance.price = validated_data.get('price')
        # instance.pub_date = validated_data.get('pub_date')
        # instance.save() # book的对象save的对象保存到数据库中
        # 高级写法
        for item in validated_data:
            # setattr(books,'name','上海出版社')
            setattr(instance, item, validated_data[item])
            instance.save()

        return instance

    class Meta:
        model = Books
        fields = ['name', 'price', 'pub_date']

路由

class BookView(APIView):
    def get(self, request):
        book_list = Books.objects.all()
        ser = BookSerializer(instance=book_list, many=True)
        return Response({'code': 100, 'msg': 'ok', 'results': ser.data})

    def post(self, request):
        ser = BookSerializer(data=request.data)

        if ser.is_valid():

            ser.save()  # 使用序列化类进行保存,但是会报错,因为没有指定到哪一个表,所以需要重新写create
            print(ser.data)
            return Response({'code': 100, 'msg': 'ok', 'results': ser.data})
        else:
            print(ser.errors)
            return Response({'code': 100, 'msg': ser.errors})

    def delete(self, request, pk):
        book_list = Books.objects.filter(id=pk).delete()
        ser = BookSerializer(instance=book_list)
        return Response({'code': 100, 'msg': 'ok', 'results': ser.data})

    def put(self, request):
        book_list = Books.objects.update(**request.data)
        ser = BookSerializer(instance=book_list, data=request.data)

        if ser.is_valid():
            ser.save()
            print(ser.data)
            return Response({'code': 100, 'msg': '修改成功', 'results': ser.data})
        else:
            print(ser.errors)
            return Response({'code': 100, 'msg': ser.errors})
  1. instance:需要序列化的数据,如果是queryset对象,即便是一个数,也需要使用many=Ture
  2. serializers.data 转为字典格式,return Response(serializers.data)这样就实现序列化了
  3. 视图中使用新增与修改:
"""新增"""
serializers=Bookserializers(data=reuqest.data)
新增后执行视图函数中的is_valid:就是执行三层校验
成功后保存ser.save()
"""修改"""
ser = BookSerializer(instance=book_list, data=request.data)
is_valid()
ser.save()


    def update(self, instance, validated_data):
    	Book.objects.filer(pk=instanc).update(*validated_data)
        
        return instance



修改第二种方式

    def update(self, instance, validated_data):
    	Book.objects.filer(pk=instanc).update(**validated_data)
        
        return instance

常用的字段名

小技巧:如果跟表模型中对不上,可以直接使用CharField。

字段类型

字段

字段构造方式

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(max_length=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页面时,显示的字段帮助提示信息

字段校验有四层:

  1. 字段自己
  2. validdators校验
  3. 局部钩子
  4. 全局钩子

序列化高级之soruce

soruce:用来修改返回字段的

1 修改字段,映射字段 publish_name表中不存在

publish_name = serializers.CharField(source='name')

2 修改字段,映射方法

sb_name是表模型中一个方法

name = serializers.CharField(source='sb_name')

3 修改字段,跨表查询

book表中可以链表查询

publish=models.ForeignKey(to='Publish.name')

序列化高级之返回字段

定制序列化返回字段格式

  1. 在表模型中写,在序列化中做映射,可以使用soruce

建表

from django.db import models


class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)

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

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    age = models.IntegerField()
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)

    def __str__(self):
        return self.name


class AuthorDetail(models.Model):
    telephone = models.BigIntegerField()
    birthday = models.DateField()
    addr = models.CharField(max_length=64)


class Publish(models.Model):
    name = models.CharField(max_length=32)
    city = models.CharField(max_length=32)
    email = models.EmailField()

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = '出版社'
        verbose_name_plural = verbose_name

models

class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)

    publish_name = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    author = models.ManyToManyField(to='Author')
    def __str__(self):
        return self.name

    # def book_name(self):
    #     return self.name+'sb'

    # def publish_detail(self):
    #     return {'name': self.name, 'price': self.price, 'publish_name': self.publish_name.addr}
    #
    # def author_list(self):
    #     l=[]
    #     for i in self.author.all():
    #         l.append({'name':i.name, 'age':i.age})
    #
    #     return l

    # def publish_detail(self):
    #     return {'name': self.name, 'price': self.price, 'publish_name': self.publish_name.addr}
    #
    #
    # def author_list(self):
    #     l=[]
    #     for i in self.author.all():
    #         l.append({'name':i.name, 'age':i.age})
    #         return l
    #

    class Meta:
        verbose_name_plural='图书表'

view

class BookView(APIView):
    def get(self, request):
        obj = Book.objects.all()
        ser = BookSerializer(instance=obj, many=True)

        '''
        [
            {
                "name": "西游记",
                "price": "66.00",
                "publish_detail": {name:名字,city:城市},
                "authors_list":[{name:名字,age:19}]
            },
    
        ]
        
        '''
        return Response(ser.data)

序列化类

### 定制返回字段
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.CharField()
    #### 定制返回字段---》方案一:在表模型中写方法,在序列化类中做映射
    # publish_detail = serializers.CharField()  # publish_detail 会映射表模型中 publish_detail方法,方法返回值是 字典,强行用CharField字符串接收
    # publish_detail = serializers.DictField()  # publish_detail 会映射表模型中 publish_detail方法,方法返回值是 字典,用DictField接收
    # author_list = serializers.ListField()

    ###定制返回字段---》方案二:在序列化类中写  SerializerMethodField
    # 只要写了这个字段类SerializerMethodField,必须配合一个方法:get_字段名,这个方法返回什么,前端这个字段就显示什么
    publish_detail = serializers.SerializerMethodField()

    def get_publish_detail(self, obj):
        # 当前序列化到的book对象
        return {'name': obj.publish.name, 'city': obj.publish.city}

    author_list = serializers.SerializerMethodField()

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

    book_name = serializers.SerializerMethodField()
	
    def get_book_name(self, obj):
        return obj.name + 'sb'

多表关联反序列化
# 反序列化保存
# 使用同一个序列化类会出现
	-序列化字段和反序列化字段不一致
   	-序列化字段
    	name
        price
        publish_detail
        author_list
    -反序列化字段:
    	name
        price
        publish
        author
        
    -如果是共同的,不需要额外处理
    -如果是不同的,需要通过字段参数控制
        read_only	表明该字段仅用于序列化输出,默认False,序列化过程
        write_only	表明该字段仅用于反序列化输入,默认False,反序列化过程

serializer
class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=18, min_length=3, required=True) # 公共的
    price = serializers.IntegerField() # 公共的

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

    publish_detail=serializers.SerializerMethodField(read_only=True) #序列化
    author_list = serializers.SerializerMethodField(read_only=True) #序列化




    def validate_name(self, name):
        if name.startswith('sb'):
            raise ValidationError("不能使用敏感字开头")
        return name


    def validate_price(self, price):
        if price <= 0:
            raise ValidationError("不能等于0")
        return price



    def validate(self, attrs):
            # attrs是校验过后的数据
        if attrs.get('name')[:3] == attrs.get('addr')[:3]:
            raise ValidationError("名称不能重复")

        return attrs


    def get_publish_detail(self, obj):
        # obj就是当前序列化到的
        return {'name': obj.publish_name.name ,'addr': obj.publish_name.addr}
        # 返回的' name':obj.publish.name, 'price':obj.publish.addr就相当于给了这个publish_detail


    def get_author_list(self,obj):
        l=[]
        for i in obj.author.all():
            l.append({'name':i.name, 'age':i.age})
        return l

    def create(self, validated_data):
        author=validated_data.pop('author')
        book = Book.objects.create(**validated_data)
        # book=Book.objects.create(name=validated_data['name'], price=validated_data['price'],publish_name=validated_data['publish_name'])
        book.author.add(*author)
        return book

ModelSerializer
  1. ModelSerializer跟表是一一对应的,r,需要重写create和update
  2. 之前写的Serializer.serializer跟表没有必然的联系
  3. 继承ModleSerializer可以少写很多代码
### 继承ModelSerializer--->少写代码
class BookSerializer(serializers.ModelSerializer):
    # name = serializers.CharField(max_length=18,min_length=3)  # 公共的
    # price = serializers.CharField()  # 公共的
    # publish = serializers.IntegerField(write_only=True)  # 只用来做反序列化
    # authors = serializers.ListField(write_only=True)  # 只用来做反序列化
    # 上述操作,通过 Meta实现了

    # 扩写的字段,也要在fields注册
    # 方式二:定制字段
    # publish_detail = serializers.SerializerMethodField(read_only=True)  # 只用来做序列化
    # author_list = serializers.SerializerMethodField(read_only=True)  # 只用来做序列化
    # def get_publish_detail(self, obj):
    #     return {'name': obj.publish.name, 'city': obj.publish.city}
    # def get_author_list(self, obj):
    #     l = []
    #     for author in obj.authors.all():
    #         l.append({'name': author.name, 'age': author.age})
    #     return l

    # 方式二:定制字段方式一
    # publish_detail = serializers.DictField(read_only=True)
    # author_list = serializers.ListField(read_only=True)
    class Meta:
        model = Book  # 写了这两句,会把表模型中Book,所有字段映射过来
        # fields='__all__'
        fields = ['name', 'price', 'publish', 'authors', 'publish_detail', 'author_list']
        extra_kwargs = {  # 给某个或某几个字段设置字段属性
            'name': {'max_length': 18, 'min_length': 3},
            'publish': {'write_only': True},
            'authors': {'write_only': True},
            'publish_detail': {'read_only': True},
            'author_list': {'read_only': True},
        }

    # 一般不需要写create和update了---》ModelSerializer帮咱们实现了
    # 局部钩子和全局钩子,该怎么写还怎么写

反序列化的源码分析
#1  执行 ser.is_valid() 就会执行 反序列化的校验---》字段自己--》局部钩子---》全局钩子
#2  入口是:ser.is_valid()---》BaseSerializer 找到了
	1 自己写的BookSerializer---》serializer.Serializer---->BaseSerializer 
    2 源码如下
    def is_valid(self, *, raise_exception=False):
        # self 是 ser对象---》自己写的BookSerializer的对象--》一开始没有
        # 一旦有了,就不执行了,优化is_valid被多次调用,只会走一次校验
        if not hasattr(self, '_validated_data'):
            try:
                # 一旦执行过,以后self中就有_validated_data
                # 接下来看self.run_validation(self.initial_data)
                self._validated_data = self.run_validation(self.initial_data)
            except ValidationError as exc:
                self._validated_data = {}
                self._errors = exc.detail
            else:
                self._errors = {}

        if self._errors and raise_exception:
            raise ValidationError(self.errors)

        return not bool(self._errors)
	  3 self.run_validation(self.initial_data)---》serializer.Serializer类的,不要按住ctrl点击,否则会进 Field 类,看错了
        
      4 serializer.Serializer类的run_validation
        def run_validation(self, data=empty):
            # data前端传入的--{"name":"张三","age":68}
            # value是---》前端传入的,字段自己校验通过的字典---{"name":"张三","age":68}
            value = self.to_internal_value(data) # 执行局部钩子
            try:
                self.run_validators(value) # 先不看,忽略掉
                # self 是 BookSerializer的对象,如果我们写了全局钩子,走我们自己的,如果没写,走父类的,父类的根本没做校验
                # value={"name":"张三","age":68}
                value = self.validate(value)# 执行全局钩子
            except (ValidationError, DjangoValidationError) as exc:
                raise ValidationError(detail=as_serializer_error(exc))

            return value
        
        
      5 全局钩子读完了:self 是 BookSerializer的对象,如果我们写了全局钩子,走我们自己的,如果没写,走父类的,父类的根本没做校验
      6 局部钩子:value = self.to_internal_value(data)--》Serializer类的
        # for循环着去BookSerializer的对象中反射  validate_字段名的方法,如果有就执行,没有就不执行
     def to_internal_value(self, data):
        for field in fields: # 序列化类中所有字段类的对象 name=CharField()
            # self 是BookSerializer类的对象
            # 去BookSerializer类中,反射  validate_field字段类的对象.field_name
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            try:
                # 如果能拿到,说明咱么写了局部钩子
                if validate_method is not None:
                    # 执行局部钩子--》传入了当前字段的value值
                    validated_value = validate_method(validated_value)
            except ValidationError as exc:
               # 如果抛异常,会被捕获
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)

        return ret
        	
        
# #####读了局部和全局钩子的执行位置#####
# 保存,修改也好,都要用validated_data,它是最准确的

执行is_valid()就会执反序列化的校验

  • 字段自己的校验
  • 局部钩子
  • 全局钩子
  1. 查看源码从is_valid()中去查看,建议不使用ctrl点击查看,去ser,is_valid()的对象就是Booksserializer中查看-----没有找到,去父类的serializer中去寻找,没有继续去Serializer中找is_valiid(),没有继续去BaseSerializer中找,如果直接从ctrl中点击的话,可能直接跳转到不是BaseSerializer中了。
  2. 源码如下
 2 源码如下
    def is_valid(self, *, raise_exception=False):
        #判断self中有没有_validated_data
        if not hasattr(self, '_validated_data'):
            try:
                self._validated_data = self.run_validation(self.initial_data)
            except ValidationError as exc:
                self._validated_data = {}
                self._errors = exc.detail
            else:
                self._errors = {}

        if self._errors and raise_exception:
            raise ValidationError(self.errors)

        return not bool(self._errors)

逐步解析:

  1. if not hasattr(self, '_validated_data'):----判断self中有没有_validated_data
  • 其中的self就是ser对象,ser对象其实就是自己写的BookSerializer类的对象,因为从BookSerializer进入的
  • 一开始是没有_validated_data,(如果有就不会执行下面的hasattr,如果执行过is_valid(),那么之后的is_valid就不会执行了,多次调用也只会执行一次)所以执行下面的反射hasattr
  1. self._validated_data = self.run_validation(self.initial_data)------去Serializer中去找run_validation

不要直接ctrl直接进去找,不然找到了fild里就不对了

    def run_validation(self, data=empty):
        # 局部钩子
          value = self.to_internal_value(data)
        try:
            self.run_validators(value) 
            value = self.validate(value) # 全局钩子
            # 不符合直接捕获错误
        
        except (ValidationError, DjangoValidationError) as exc:
            raise ValidationError(detail=as_serializer_error(exc))

        return value

在run_validation中

全局钩子: 不符合直接捕获错误 value = self.validate(value) 全局钩子:self是BookSerializer的对象,如果自己写了钩子,那么就执行我们的,没写走父类,父类中直接返回了,并没有做校验

局部钩子

value = self.to_internal_value(data)-----是Serializer的

for循环去BookSerializer的对象去反射,validata_字段名的方法,如果有就执行,

  • value就前端传入的数据
    def to_internal_value(self, data):

        for field in fields:
            validate_method = getattr(self, 'validate_' + field.field_name, None)
            #去BookSerializer中反射validate_加上字段名 :  validate_field字段类的对象.field_name
            primitive_value = field.get_value(data)
            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中
                errors[field.field_name] = exc.detail
            except DjangoValidationError as exc:
                errors[field.field_name] = get_error_detail(exc)
            except SkipField:
                pass
            else:
                set_value(ret, field.source_attrs, validated_value)

        if errors:
            raise ValidationError(errors)
    	# 最终返回
        return ret

for field in fields: 序列化类中所有字段的对象:

validate_method = getattr(self, 'validate_' + field.field_name, None)

去BookSerializer中反射validate_加上字段名 : validate_field字段类的对象.field_name

断言
   assert hasattr(self, 'initial_data'), (
            'Cannot call `.is_valid()` as no `data=` keyword argument was '
            'passed when instantiating the serializer instance.'
        )
判断self里有没有'initial_data'没有就报错
a = 10

## assert 后写条件,只要不符合条件,就会抛AssertionError异常,后面写异常信息
assert a == 11, ("不等于11,报错了")

# 等同于---》上面只要一行代码,源码中喜欢用
if not a == 11:
    raise Exception('不等于11,报错了')
    
    
   

# 源码中使用
assert value is not None, '.validate() should return the validated data'

你可能感兴趣的:(python,windows,开发语言)