昨日回顾

# 1.web的两种开发模式
# 2.web api
# 3.posman的使用（路径必须完全正确）
# 4.restful规范 10条
# 5.drf的安装和使用
# 6.cbv源码分析
    -视图类，必须继承View（读View的源码）
    -在类里写get，post方法就可以了，只要get请求来，就会走get方法（方法跟之前的fbv写法完全一样）
    -路由：views.Books.as_view()---这个函数执行完一定是一个内存地址---》view（闭包函数）内层函数的地址
    -请求来了，路由匹配上执行view(request)--->self.dispatch(request, *args, **kwargs)
    -dispatch-->把请求方法转成小写---》通过反射，去对象中找，有没有get方法，有就加括号执行，并且把request传进去了
    
#7.APIView源码分析（drf提供的，扩展了View的功能）
    -视图类，继承APIView（读APIView的源码）
    -在类里写get，post方法就可以了，只要get请求来，就会走get方法（方法跟之前的fbv写法完全一样）
    -路由：views.Books.as_view()---这个函数执行完一定是一个内存地址---》view（闭包函数）内存函数的地址，解除了csrf校验，所有请求就都没有csrf校验了
    -请求来了，路由匹配上--->view(request)--->self.dispatch(request, *args, **kwargs)，现在这个dispatch不是View中的dispatch，而是APIView中的dispatch
    
    -def dispatch(self, request, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs
        #  self.initialize_request(request, *args, **kwargs)  request是当次请求的request
        # request = self.initialize_request  request是一个新的Request对象
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        try:
            # 三大认证模块(request是新的request)
            self.initial(request, *args, **kwargs)

            # Get the appropriate handler method
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed

            # 响应模块
            response = handler(request, *args, **kwargs)

        except Exception as exc:
            # 异常模块
            response = self.handle_exception(exc)

        # 渲染模块
        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

今日内容

1.序列化组件介绍

1.序列化组件功能

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

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

2.序列化组件两大类

# 1.基本类序列化器--Serializer（跟表模型没有必然联系）
    -写出要序列化的字段（尽量跟模型表的字段类对应）
    -source属性（用的很少）
    
# 2.序列化类之ModelSerializer（跟表模型没有必然联系）
    -写一个内部类  
    -class Meta:
        model=表模型
        fields=['字段','方法']
        extra_kwargs={'name':{}}
    -重写要序列化的字段字段
    -要序列化的字段，类是通过表模型映射过来的
    -ModelSerializer不需要重写create和update（ModelSerializer帮我们写了）


# 以5个接口为例：
查询所有  http://127.0.0.1:8000/books/      get
新增一个  http://127.0.0.1:8000/books/      post  # 新增时，外键字段:id 就行

查询一个  http://127.0.0.1:8000/books/1/    get
修改一个  http://127.0.0.1:8000/books/1/    put
删除一个  http://127.0.0.1:8000/books/1/    delete 
        

# 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)

2.查询数据(序列化)

# get请求： 从后端拿数据 (python对象 --序列化--> json)


# 过程：
1.写一个序列化的类，继承Serializer
2.在类中写要序列化的字段 (想序列化哪个字段，就在类中写哪个字段)
3.在视图类中使用，导入--》实例化得到序列化类的对象，把要序列化的对象传入
4.序列化类的对象.data   是一个字典
5.把字典返回，如果不使用rest_framework提供的Response,就得使用JsonResponse


# ser.py
from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    # price=serializers.DecimalField()
    price = serializers.CharField()
    author = serializers.CharField()  
    publish = serializers.CharField()
    
# views.py
from rest_framework.view import APIView
from rest_framework.response import Response
from app01 import models

class BookView(APIView):
    def get(self,request,pk):
        book = models.Book.objects.filter(id=pk).first()
        # 用一个类，毫无疑问，一定要实例化
        # 要序列化谁，就把谁传过来 
        book_ser = BookSerializer(book)  # 默认：序列化单条数据
        # book_ser.data   序列化对象.data就是序列化后的字典 (还不是json格式)
        # drf的Response，会自动将返回的数据json.dumps() 转json格式
        return Response(book_ser.data)  
    
# 故 视图类中返回的数据两种处理方式：
    1.采用drf的Response() 自动转json格式 但需要setting中配置 app='rest_framework'  # 推荐使用
    2.直接使用django原生的 JsonResponse 转json格式
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

3.字段类型

有很多，不需要都记住 
# 只需要记住：CharField，IntegerField，DateField。。。

# 以及下面三个 
# 若Python的字典或列表中有包含Python格式的字符串，使用这两个字段，可将对象内部也序列化
ListField(child=, min_length=None, max_length=None) 
DictField(child=)     

SerializerMethodField()  # 序列方法字段  字段名无需与模型表对应上
# 顾名思义，字段可以用自定义方法来序列化显示

# 例：给价格显示 加上 '元'
price_str = serializers.SerializerMethodField()
# 它需要有个配套方法，方法名叫get_字段名，返回值就是返回给前端的 该字段的对应值
def get_price_str(self, instance):
    return str(instance.price) + '元'

字段类型

字段	字段构造方式
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=)

4.修改数据(反序列化)

# put请求： 修改数据 前端传数据给后端  ( json --反序列化--> python对象)


# 过程：
1.写一个反序列化的类，继承Serializer
2.在类中写要反序列化的字段、字段的属性(max_lenth等来校验数据) 以及重写update() 方法进行数据的保存 
3.在类中写数据校验规则 (1.字段属性 2.钩子函数 3.字段函数 具体见下)
4.在视图类中使用，导入--》实例化得到反序列化类的对象，把 要修改的对象传入 与 修改的数据 传入
    book_ser=BookSerializer(book,request.data)
    book_ser=BookSerializer(instance=book,data=request.data)    
5.进行数据校验 if book_ser.is_valid():
6.如果校验通过，就保存
    book_ser.save() # 注意不是book.save()	
7.如果不通过，逻辑自己写

"""
数据校验规则(三种):
1.序列化类 字段的选项参数 来校验 (最基本的校验)
    # 主要是CharField
    max_length	最大长度
    min_lenght	最小长度
    allow_blank	是否允许为空
    trim_whitespace	是否截断空白字符
    
    # 主要是IntegerField 针对数据类型
    max_value	最小值   
    min_value	最大值     

2.写钩子函数（局部和全局）  # 推荐使用
    # 局部钩子：如果价格小于10，就校验不通
    def validate_price(self, data):  # validate_字段名  接收一个参数data 就是该局部钩子字段对应的值
        # print(type(data))  # str
        # print(data)  # 33.10
        if float(data)>10:
            return data
        else:
            # 校验失败，抛异常
            raise ValidationError('价格太低')
       
    # 全局钩子：作者名字跟出版社不能一样 
    def validate(self, validate_data):   # validate  接收一个参数validate_data 就是验证通过的数据字典
        print(validate_data)
        author=validate_data.get('author')
        publish=validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字跟出版社一样')
        else:
            return validate_data
                    
3.使用字段的选项参数： validators=[校验函数地址]  来校验数据   # 通常不使用这种，知道就行
    # author=serializers.CharField(validators=[check_author])
    - 1.自定义写一个普通校验函数
    def check_author(data):
        if data.startswith('sb'):
            raise ValidationError('作者名字不能以sb开头')
        else:
            return data
    - 2. 配置在字段的选项参数中：
        validators=[check_author]
"""

    
# ser.py
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

# 普通校验函数 放 字段的选项参数 来校验数据
def check_author(data):
    if data.startswith('sb'):
        raise ValidationError('作者名字不能以sb开头')
    else:
        return data

class BookSerializer(serializers.Serializer):
    name=serializers.CharField(max_length=16,min_length=4)
    price=serializers.CharField()
    author=serializers.CharField(validators=[check_author])  # validators=[] 列表中写函数内存地址 这种了解就行
    publish=serializers.CharField()
	
    # 局部钩子：如果价格小于10，就校验不通过
    def validate_price(self, data):   # validate_字段名  参数data 就是该局部钩子字段对应的值
        # print(type(data))  # str
        # print(data)  # 33.10
        if float(data)>10:
            return data
        else:
            # 校验失败，抛异常
            raise ValidationError('价格太低')
            
    # 全局钩子：作者名字跟出版社不能一样 
    def validate(self, validate_data):  # validate  参数validate_data 就是验证通过的数据字典
        # print(validate_data)
        author=validate_data.get('author')
        publish=validate_data.get('publish')
        if author == publish:
            raise ValidationError('作者名字跟出版社一样')
        else:
            return validate_data
        
    # 必须 重写保存方法 (原因：1.因为父类接口的规定--接口的规范与统一 2.数据保存时也需要和校验通过的字段名一一对应上)
    def update(self, instance, validated_data):
        # instance是views类中传过来的要修改的对象
        # 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() 由django的orm提供的对象.save()
        return instance  # 一定要返回该对象，若不返回，view类中book_ser.data 就拿不到序列化的数据，就无法返回给前端
    
# views.py
class BookView(APIView): 
    
    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)

        # 进行数据验证（对照form组件的验证）
        if book_ser.is_valid():  # 返回True 表示前端传递的数据验证通过
            book_ser.save()  # 注意：不是对象.save()  是序列化对象.save()
            response_msg['data']=book_ser.data
        else:
            response_msg['status']=101
            response_msg['msg']='数据校验失败'
            response_msg['data']=book_ser.errors
        return Response(response_msg)
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

5.字段选项参数

校验参数：是反序列化时，进行数据的校验(部分字段会有该参数)

参数名称	作用
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页面时，显示的字段帮助提示信息

6.字段通用参数

# 如果序列化和反序列化都是同一个序列化类，可以使用如下两个字段进行控制 (都不写，默认是可读可写)
read_only	表明该字段仅用于序列化输出，默认False, 如果设置成True，前端查询时可看到该字段，修改时，不需要传该字段
write_only	表明该字段仅用于反序列化输入，默认False，如果设置成True，前端查询时看不到该字段，修改时，该字段需要传

# 若觉得麻烦，直接写一个序列化类，再一个反序列化类

# 其他了解

7.查询所有(序列化)

# views.py

# 最好新建视图 View 因为restful规范，查询都是get请求，虽然也可以都写在get氢气 再根据参数判断，但写在一起比较混乱
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)
    
#urls.py
path('books/', views.BooksView.as_view()),

8.新增数据(反序列化)

# views.py
class BooksView(APIView):
    # 新增
    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()
            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  # 一定要返回对象，若不返回，view类中book_ser.data 就拿不到序列化的数据，就无法返回给前端
    
# urls.py
path('books/', views.BooksView.as_view()),

9.删除一个数据

# 删除数据，就不需要用序列化组件
# 直接使用orm 对象.delete() 根据pk 删除就行

# views.py
class BookView(APIView):
    def delete(self,request,pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'status':100,'msg':'删除成功'})
    
# urls.py
re_path('books/(?P<pk>\d+)', views.BookView.as_view()),

10.模型类序列化器

form rest_framework import serializers

# ser.py
class BookModelSerializer(serializers.ModelSerializer):
    # 自定义序列化字段
    # re_password = serializers.CharField(write_only=True)

    # 指定跟表的对应关系
    class Meta:
        model=Book   # 对应上models.py中的模型
        fields='__all__'  # model表所有字段 只序列化字段，不序列化方法
       
        fields=('name','price','id','author')  # 指定的字段或方法 (方法默认是只读不写)
        
        # 使用extra_kwargs，给字段 传递参数、属性
        # 类似于这种形式name=serializers.CharField(max_length=16,min_length=4)
        extra_kwargs = { 
            'price': {'write_only': True},
            # 're_password': {'write_only': True}
            # 注意，extra_kwargs不能给 自定义序列化字段 加额外的参数 ，只能在定义字段时自己写参数
        }
        
        # 了解
        exclude=('name',)  # 跟fields只能有一个，写谁，就表示排除谁

        # 表示把外键关联的表也序列化出来
        depth=1   # 序列化的层数
        

        # 注意：
           1. fields为'all'时，是包含models表所有字段(不含方法) + 上面自定义的字段
           2. exclude，也是从 models表所有字段+ 上面自定义的字段，去排除某些字段


        
# 1. 不需要重写create和updata方法了

# 2. 在出版社名字后加 _vip (序列化)
        # 方式一: SerializerMethodField() 来重写字段
        name=serializers.SerializerMethodField()
        def get_name(self,obj):
            return obj.name+'_vip'
        # 方式二，在表模型中定义一个name_detail方法，再添加到fields中 
        
        # 序列化的时候使用name_detail，反序列化的时候使用name
        name = serializers.CharField(write_only=True)
        # name_detail = serializers.CharField(read_only=True)  如果是个方法，这句可以不写

        
# 3. 限制字段，最大长度8，最小长度3
    # 使用extra_kwargs，给字段 传递参数、属性
    	 extra_kwargs={ 
             'addr':{'max_length':8,'min_length':3,'write_only':True},
             'name':{'write_only':True}
        }
        
# 视图层中，和基本类一样的使用

11. 高级用法

# 1. source的选项参数使用--指向来自哪个表的哪个字段  (使用较少)

# 作用：
    # 1.字段名字可以自定义，不用再和表字段名对应上   
    xxx=serializers.CharField(source='title')    
    # 2.通过'.' 跨表  可指向关联表的字段
    publish=serializers.CharField(source='publish.email') 
    # 3.可以执行models中表的方法，使得 字段 对应 该方法的返回值   (就是下面 方式二的变形 来源指向一个方法)
    # test是Book表模型中的方法 
    pub_date=serializers.CharField(source='test')  
    
    
# 2. 字段 以自定义的方法来序列化显示字段 (两种方式)：  # 方法的返回值就是该字段的对应值

    # 方式一：(在序列化类中写方法)使用SerializerMethodField()字段
    # 它需要有个配套方法，方法名叫get_字段名
    # 例1. 作者显示详情
    authors_detail = serializers.SerializerMethodField()

    def get_authors_detail(self, instance):
        # instance 就是使用该序列化类时，传入的对象
        authors = instance.authors.all()  
        res = []
        for author in authors:
            res.append({'name': author.name, 'age': author.age})
        return res
    
    # 方式二：(在模型类中写方法) 再序列化类中 字段指向该方法（可包装成数据属性）   # 使用较多
    # 例2. 出版社显示详情
    # models.py
    class Book:
        # @property
	def publish_detail(self):
            res = {'name': self.publish.name, 'email': self.publish.email, 'addr': self.publish.address}
            return res
    # ser.py
    publish_detail = serializers.DictField()
    
    # 若是继承ModelsSerializers，需要将该字段 添加到 fields中


    # 方式三：django的 model_to_dict() 方法
    # model_to_dict()  可以将orm的model表，转化字典形式，但默认会跳过有editable=False属性字段的展示，
        # 对于有auto_now_add=True和auto_now=True属性的 datetime字段 会默认添加editable=False隐藏属性

    from django.forms import model_to_dict
    model_to_dict(model_obj, exclude=［'create_time', 'update_time'］)

    # 源码函数：
    def model_to_dict(instance, fields=None, exclude=None):
        
    # 参数instance是对象实例，fields是指定需要哪些字段，exclude是指定排除哪些字段，exclude比fields优先级高。

12.源码分析(了解，学其思想)

1. many=True参数的作用

# 序列化多条，需要传many=True
 
book_ser=BookModelSerializer(books,many=True)
print(type(book_ser))  # <class 'rest_framework.serializers.ListSerializer'> 
# ListSerializer实际是列表中套了很多BookModelSerializer

book_one_ser=BookModelSerializer(book)
print(type(book_one_ser))  # <class 'app01.ser.BookModelSerializer'>

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

# 源码：肯定是根据many=True进行处理，触发生成不同类的对象
def __new__(cls, *args, **kwargs):
    if kwargs.pop('many', False):  # 字典.pop(key, default) 要删除的键值 如果没有key，返回default值
        return cls.many_init(*args, **kwargs)
    # 没有传many=True,走下面，正常的对象实例化
    return super().__new__(cls, *args, **kwargs)

2. 如果继承Serializer类， 修改和新增时必须重写save和update方法

# 源码：Serializer类--父类-->BaseSerializer类中:
# 根据 BaseSerializer.save()中是否参数：instance 模型对象，
# 若有则是修改update()，若无则是新增create() 都必须返回该对象
def save(self, **kwargs):
    if self.instance is not None:
        self.instance = self.update(self.instance, validated_data)      
    else:
        self.instance = self.create(validated_data)
    return self.instance

3. 局部和全局钩子的执行

# 执行顺序：
    ---> 1.view.py中 book_ser.is_valid()  # 校验数据开始 (入口处)
    ---> 2.Serializer类--父类-->BaseSerializer类的is_valid()  # 执行的是BaseSerializer类的is_valid方法
    ---> 3.self._validated_data = self.run_validation(self.initial_data)
    # 注意：self.run_validation()是哪个类的run_validation？不是Field类的，而是Serializer类的(self是Serializer对象)
    # 若由pycharm Ctrl键寻找，只会往上层找，但实际应该从自身对象开始寻找，再依次类-->分类...
    ---> 4.核心：
    ----Serializer类:
            def run_validation(self, data=empty): 
                value = self.to_internal_value(data)  # 执行自己的规则和局部钩子
                try:
                    self.run_validators(value)
                    value = self.validate(value)  # 执行全局钩子
                    assert value is not None, '.validate() should return the validated data'
                except (ValidationError, DjangoValidationError) as exc:  # 捕获校验出错的异常
                    raise ValidationError(detail=as_serializer_error(exc))
                return value
            
            def to_internal_value(self, data):
                for field in fields:
                    # 找局部钩子方法的地址
                    validate_method = getattr(self, 'validate_' + field.field_name, None)
                    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[field.field_name] = exc.detail
                    else:
                        set_value(ret, field.source_attrs, validated_value)
                return ret
    
    # 源码可知：
    校验数据的执行顺序：
    	1.先循环检验每个字段的自己规则和字段的局部钩子规则
        2.全部通过之后，再把数据传递给全局钩子检验
        3.最后校验成功和失败信息，都是字典形式(OrderedDict)返回

补充

1.如果有这个错（把rest_framework在app中注册一下）

2.补充自己封装Respons对象

# 在实际中，除了使用框架封装好的方法，也会自己写一些方法工具

# 例如：因为需要重复返回这个字典:  response_msg={'status':100,'msg':'成功'}
# 将字典 封装成一个 类， 使用时，就可以'.'操作，修改'status'或'msg' 和 新增 data

class MyResponse():
    def __init__(self):
        self.status=100  # 初始化，封装对象两个属性
        self.msg='成功'
        
    @property
    def get_dict(self):
        return self.__dict__  # 返回的对象.__dict__

if __name__ == '__main__':
    res=MyResponse()
    res.status=101
    res.msg='查询失败'
    res.data={'name':'lqz'} 
    print(res.get_dict)

作业：

# 1 定义两个表，图书和出版社表
    -出版社的5个接口
    	- 新增出版社时候，addr最大8，最小3，不能以sb开头，地址不能包含名字
    -图书的5个接口
    	-查询的时候，出版社显示详情
        -新增和修改带出版社
        -价格显示成  xx元

# 面试：什么是"鸭子类型"？
答：在Python中，不需要父类有一个接口来约束子类的行为，只要子类有父类中的方法，就认定两者是同一类型。但在实际开发中，不采用作者的这种"鸭子类型"，还是希望父类有一个接口来约束子类的行为 采用ABC模块 或者父类的方法抛异常的形式 以及人为约束。