面向对象编程：类的封装、多态，反射方法

2022.4.8封装、多态、反射等

• 继承下派生实际应用
• 面向对象三大特性之封装
• 面向对象三大特征之多态
• 反射

一、继承下派生实际应用

以datetime模块和json模块为例

1.序列化字典
d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1)  # 传入字典发现报错，见下方
print(res)
'''
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
    json.JSONEncoder
'''
1.手动将不能序列化的类型先转字符串
    {'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
2.研究json源码并重写序列化方法
    研究源码发现报错的方法叫default
        raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
    我们可以写一个类继承JSONEncoder然后重写default方法

2.尝试使用代码，定义一个类继承json.JSONEncoder
class MyJsonEncoder(json.JSONEncoder):
    def default(self,o):  # 形参o就是即将要被序列化的数据对象
        print('重写了',o)
        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)  # 不满足上述两种情况则调用父类default(让父类的default方法继续执行，防止有其他额外操作)
res = json.dumps(d1,cls=MyJsonEncoder)
print(res)  
# 重写了 2022-04-08 18:48:43.589847
# 重写了 2022-04-08
# {"t1": "2022-04-08 18:48:43", "t2": "2022-04-08"}

二、面向对象三大特征之封装

1、封装的含义

封装就是将类中的某些名字'隐藏'起来，不让外界直接调用，隐藏的目的是为了提供专门的通道去访问，在通道内可以添加额外的功能。

2、代码实操

（1）如何封装名字

​ 在变量名的前面加上两个下划线__

（2）封装名字的语法

封装的功能只在类定义阶段才能生效!!!
在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已

 __变量名       >>>     _类名__变量名

class Student(object):
    school = '清华大学'
    __label = '逆来顺受'  # 由于python崇尚自由 所以并没有真正的隐藏  而是自动转换成了特定的语法
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def choose_course(self):
        print('%s正在选课'%self.name)
stu1 = Student('jason', 18)
print(stu1.school)  # 清华大学
print(stu1.name)  # jason
print(stu1.age)  # 18
print(stu1.__label) # 报错,看不到结果
print(Student.__dict__)  # {...,'_Student__label': '逆来顺受',...}
print(Student._Student__label)  # 逆来顺受
print(stu1._Student__label)  # 逆来顺受

（3）接口（通道）

我们虽然指定了封装的内部变形语法 但是也不能直接去访问
看到了就表示这个属性需要通过特定的通道(接口)去访问

class Student(object):
    __school = '清华大学'
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    # 专门开设一个访问学生数据的通道(接口)
    def check_info(self):
        print("""
        学生姓名:%s
        学生年龄:%s
        """ % (self.__name, self.__age))
    # 专门开设一个修改学生数据的通道(接口)
    def set_info(self,name,age):
        if len(name) == 0:
            print('用户名不能为空')
            return
        if not isinstance(age,int):
            print('年龄必须是数字')
            return
        self.__name = name
        self.__age = age

stu1 = Student('jason', 18)
stu1.check_info()  # json 18
stu1.set_info('jasonNB',28)
stu1.check_info()  # json 18, jasonNB 28
stu1.set_info('','haha')
"""
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，
    接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
    
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
    比如插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
"""

3、property

刚才在数据前面加双下方法可以将数据隐藏，那么如何将方法隐藏起来呢，property方法可以解决这个问题。

了解这个方法之前我们先举个例子：

BMI指数：

体质指数（BMI）=体重（kg）÷身高^2（m）

有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
BMI指数>>>:应该属于人的数据而不是人的功能

接下来定义一个人类，封装BMI指数方法：

class Person(object):
    def __init__(self, name, height, weight):
        self.__name = name
        self.height = height
        self.weight = weight
    @property  # 封装方法关键字
    def BMI(self):
        return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))  # 返回计算之后的格式化输出
    

p1 = Person('jason', 1.83, 77)
p1.BMI()  # TypeError: 'str' object is not callable，不能作为函数调用
print(p1.BMI)  # jason的BMI指数是:22.99262444384723
因此，封装后的方法可以使用点的方式直接实现，而不需要加括号运行

三、面向对象三大特性之多态

1、什么是多态？

一种事物的多种状态

eg：

水：固态，液态，气态

动物：猫，狗，猪

2、多态性

代码模拟，结合使用继承方法

class Animal(object):
    def speak(self):
        pass

class Cat(Animal):
    def miao(self):
        print('喵喵喵')

class Dog(Animal):
    def wang(self):
        print('汪汪汪')

class Pig(Animal):
    def heng(self):
        print('哼哼哼')

上述代码通过单继承Animal，虽然呈现了动物的多态性，但是并没有完整的体现，因为从代码角度需要调用不同的方法才能实现不同动物的叫声，所以可以想到优化成只要说话就调用同一个方法，如下：

class Animal(object):
    def speak(self):
        pass

class Cat(Animal):
    def miao(self):
        print('喵喵喵')

class Dog(Animal):
    def wang(self):
        print('汪汪汪')

class Pig(Animal):
    def heng(self):
        print('哼哼哼')
        
c1 = Cat()  # 生成对象
d1 = Dog()  # 生成对象
P1 = Pig()  # 生成对象
c1.speak()  # 调用speak方法
d1.speak()  # 调用speak方法
p1.speak()  # 调用speak方法

因此，总体来说，多态性并不是什么方法，而是一个理论，就是在编写类对象的时候，假如子类有父类相同功能的情况下，可以将功能的名字统一，便于使用，就不用调用多个方法那么麻烦了

"""
多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()

面向对象的多态性也需要python程序员自己去遵守

虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性
    不推荐使用
"""

3、强制子类定义父类方法

有一种方法可以限制子类必须定义相关父类的方法的操作，如下：

import abc
指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
    def talk(self): # 抽象方法中无需实现具体的功能
        pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
    def talk(self):
        pass
p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

4、鸭子理论

说到这里，由多态衍生出一个鸭子理论：

只要你里看着像鸭子，走路像鸭子，说话像鸭子，那么你就是鸭子！

鸭子类型实战案例：

"""
在linux系统中有一句话>>>:一切皆文件!!!
    内存可以存取数据
    硬盘可以存取数据
    ...
    那么多有人都是文件
"""
class Memory(object):
    def read(self):
        pass
    def write(self):
        pass
class Disk(object):
    def read(self):
        pass
    def write(self):
        pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁，都是用来存取文件数据

四、面向对象之反射

1、什么是反射？

专业解释：指程序员可以访问、检测和修改本身状态或者行为的一种能力

大白话：其实就是通过字符串来操作对象的数据和功能

2、反射的四个方法

引入：attr，及attribute属性的简写

hasattr(obj,...):判断对象是否含有字符串对应的数据或者功能
getattr(obj,...):根据字符串获取对应的变量名或者函数名
setattr(obj,...):根据字符串给对象设置键值对(名称空间中的名字)
delattr(obj,...):根据字符串删除对象对应的键值对(名称空间中的名字)

3、反射实际应用

需求：编写一个小程序 判断Student名称空间中是否含有用户指定的名字 如果有则取出展示

class Student(object):
    school = '清华大学'
    def det(self):
        pass
    
# 不使用反射不太容易实现，因为获取用户输入一般都是字符串，因此可以使用反射的两种方法
1.hasattr判断Student是否有指定名字
print(hasattr(Student, 'school'))  # True
print(hasattr(Student, 'get'))  # True
print(hasattr(Student, 'post'))  # False
2.getattr获取名字对应的值
print(getattr(Student, 'school'))  # 清华大学
print(getattr(Student, 'get'))  # <function Student.get at 0x10527a8c8>

# 代码实现
guess_name = input('请输入你想要查找的名字>>>:').strip()
if hasattr(Student,guess_name):
    target_name = getattr(Student,guess_name)
	if callable(target_name):
        print(f'存在功能名{target_name}')
    else:
        print(f'存在数据名{target_name}')
else:
    print('该方法不在该类中')

"""
什么时候使用反射 可以记固定的口诀
	以后只要在业务中看到关键字 
		对象 和 字符串(用户输入、自定义、指定) 那么肯定用反射
"""
    

4、反射实际案例

利用反射获取配置文件中的配置信息（一切皆对象，文件也是对象）

import settings

dir(settings)  # 获取对象中所有可以使用的名字
getattr(settings,'NAME')  # 配置文件中一般为常量，大写

class FtpServer:
     def serve_forever(self):
         while True:
             inp=input('input your cmd>>: ').strip()
             cmd,file=inp.split()
             if hasattr(self,cmd): # 根据用户输入的cmd，判断对象self有无对应的方法属性
                 func=getattr(self,cmd) # 根据字符串cmd，获取对象self对应的方法属性
                 func(file)
     def get(self,file):
         print('Downloading %s...' %file)
     def put(self,file):
         print('Uploading %s...' %file)

obj = FtpServer()
obj.serve_forever()

预习

拔高:面向对象大作业>>>:选课系统(暂时可不看 学有余力者可提前思考)
角色:学校、学员、课程、讲师
要求:
    1. 创建北京、上海 
    2 所学校2. 创建linux , python , go 
    3个课程 ， linux\py 在北京开， go 在上海开3. 课程包含，周期，价格，通过学校创建课程 
    4. 通过学校创建班级， 班级关联课程、讲师
    5. 创建学员时，选择学校，关联班级5. 创建讲师角色时要关联学校， 
    6. 提供三个角色接口  
    6.1 学员视图， 可以注册， 交学费， 选择班级，  
    6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩   
    6.3 管理视图，创建讲师， 创建班级，创建课程7. 上面的操作产生的数据都通过pickle序列化保存到文件里