面向对象：派生，三大特性封装，多态，反射

派生实操

import json
import datetime

d = {
    't1': datetime.date.today(),
    't2': datetime.datetime.today(),
    't3': 'jason'
}
res = json.dumps(d)
print(res)
# 上列格式的字典树一句无法进行序列化:会报如下错误
"""
raise TypeError(f'Object of type {o.__class__.__name__} '
TypeError: Object of type date is not JSON serializable
"""
# 这是因为能进行序列化的数据是有限的:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+

# 我们只需要将键对应的值转换类型即可
# 转换方式一:
d = {
    't1': str(datetime.date.today()),
    't2': str(datetime.datetime.today()),
    't3': 'jason'
}
# 转换方式二:
"""
1.查看json下的dumps的源码：
def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
2.注意cls参数：默认传JsonEncoder
if cls is None:
    cls = JSONEncoder

3.查看JsonEncoder的源码，发现default方法是报错的发起者
def default(self, o):
    raise TypeError(f'Object of type {o.__class__.__name__} '
                        f'is not JSON serializable')

4.我们只需编写类继承JsonEncoder并且重写default方法，之后调用dumps手动传入cls=我们自己写的类                    
"""
# 重写后的类：
class MyJsonEncoder(json.JSONEncoder):
    def default(self, o):
        """
        :param o:    # 接收无法被序列化的数据
        :return:     # 返回可以被序列化的数据
        """
        if isinstance(o,datetime.datetime):
            return o.strftime('%Y-%m-%d %X')
        elif isinstance(o,datetime.date):
            return o.strftime('%Y-%m-%d')
        return super().default(o)
    # 最后还是调用原来的方法，防止有一些额外操作没有做
res = json.dumps(d, cls = MyJsonEncoder)
print(res)

伪装

class Person(object):
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight

    @property     # 加了此装饰器，调用此方法时就会伪装成数据，不用加括号了
    def BMI(self):
        return self.weight / (self.height ** 2)
p1 = Person('jason',1.68,52)
print(p1.BMI)     # 利用装饰器伪装成数据就不用加括号了



class Foo:
    def __init__(self,val):
        self.__NAME = val

        @property
        def name(self):
            return self.__NAME

        @name.setter
        def name(self,value):
            if not isinstance(value, str):   # 在设定值之前进行进行类型检查
                raise TypeError('%s must be str' % value)
            self.__NAME = value              # 通过类型检查后，将值value放到真实的位置self。__NAME
        @name.deleter
        def name(self):
            raise PermissionError('Can not delete')

f = Foo('jason')
print(f.name)
f.name = 'jason123'
print(f.name)
del f.name
# f.name = 'jason'       触发name.setter装饰器对应的函数name(f,'jason')
# f.name = '123'         触发name.setter对应的函数name(f,123),抛出异常TypeError
# del f.name             触发name.deleter对应的函数name(f),抛出异常PermissionError

三大特性之多态

1. 多态：一种事物的多种形态

# 面向对象中的多态意思是一种事物可以有多种形态，但是针对相同功能应该定义相同的方法。这样

不管我们拿到的是哪种具体事物，都可以通过相同的方法调用该功能

2.鸭子类型

浅层理解：走路像鸭子，说话像鸭子，它就是鸭子类型

深层理解：指的是面向对中，子类不需要显示的继承某个类，只要有某个的方法和属性，那我就属于这个类


"""
python永远提倡简介大方，不约束程序员行为，但是多态提供了约束的方法
"""

import abc

# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不可以被实例化

class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk(self): # 抽象方法中无需实现具体的功能
pass

class Cat(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk(self):
pass

cat = Cat() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

面向对象之反射

# 反射:利用字符串操作对象的数据和方法

1.什么时候考虑使用反射：
需求中出现关键字 ： 对象....字符串...


2.反射的方法：
# 1.hasattr()    重点
    判断对象是否含有某个字符串对应的属性名或方法名
# 2.getattr()     重点
    根据字符串获取对象对应的属性名(值)或方法名(函数体代码)
# 3.setattr()    
    根据字符串给对象设置或修改数据
# 4.delattr()
    根据字符串删除对象里面的名字


使用：
class C1:
    school_name = '老男孩'

    def choice_course(self):
        print('用户正在选课')

obj = C1()
while True:
    target_name = input('请输入您想要操作的名字>>>:')
    if hasattr(obj, target_name):
        print('系统中存在该名字')
        # 获取该名字对应的数据(值 函数)
        data_or_func = getattr(obj, target_name)
        if callable(data_or_func):
            print('您本次使用的是系统中某个方法')
            data_or_func()
        else:
            print('您本次使用的是系统中某个数据')
            print(data_or_func)
    else:
        print('系统中不存在该名字')

面向对象三大特性之封装

1. 封装： 封装就是将数据和功能封装起来
2. 隐藏： 将数据和功能隐藏起来不让用户直接调用，而是开发一些接口间接调用从而在接口内添加额外的操作
3. 伪装： 将类里面的方法伪装成类里面的数据

class C：
    def func(self):pass
obj = C()
obj.func()
"""经过伪装"""
obj.func
# 在类的定义阶段，名字前面有连个下划线，则会将名字隐藏起来无法直接点出来访问。但是python中的隐藏是墨守成规的，所谓的隐藏就是换了一个名字而已，_类名__名字。

# 隐藏属性

class Person:
    def __init__(self,name,age,hobby):
        self.__name = name
        self.__age = age
        self.__hobby = hobby
    def get_info(self):
        # 类体代码中，是可以直接使用隐藏的名字的
        print(f"""
        姓名:{self.__name}
        年龄:{self.__age}
        爱好:{self.__hobby}
        """)
    # 隐藏的属性开放修改的接口，可以自定义很多功能
    def set_name(self,new_name):
        if len(new_name) == 0:
            raise ValueError('名字不可以为空')
        if new_name.isdigit():
            raise ValueError('名字不能出现数字')
        self.__name = new_name

obj = Person('jason', 18, 'read')
obj.get_info()
obj.set_name('tony')
obj.get_info()
obj.set_name('')
# 我们在编程中如果遇到单下划线开头的名字，其所表达的意思通常是:不要直接访问,而是查找一下下面可能定义的接口