day25

                                        继承的另一种使用方式 

 

最常见的是直接继承一个已经存在的类。

当你想要创建一个新的类，发现这个类中的一些属性在某一个类中已经存在，

那就没有必要从头开始写 ,可以直接继承已有的类然后做补充 。

 

class MyList(list):
    def __init__(self,element_cls):
        # 当你覆盖了init方法时
        # 不要忘记调用super().init函数让父类完成原有的初始化操作
        super().__init__()
        self.element_cls = element_cls

       
    def append(self, object):
        # if isinstance(object,str)
        if object.__class__ == self.element_cls:
            super().append(object)
        else:
            print("只能存储%s类型!" % self.element_cls.__name__)

 

 

python支持多继承  一个类可以同时继承多个父类

好处是更加灵活

 

问题:多继承时如果多个父类中出现了同名的属性/函数
你不能用眼睛去判断查找顺序 ,需要使用mro列表来查看真正的继承顺序
总结:super在访问父类属性时 是按照mro列表一层层往上找的

#测试
class A:
    def test(self):
        print("from A")
        super().test() # 应该报错..... 但是却执行成功了
class B:
    def test(self):
        print("from B")
    pass

class C(A,B):
    pass

c = C()
c.test()

#最后:尽量不要使用多继承

 

 

                          组合

组合:
指的是 一个类把另一个类的对象作为自己的属性 就称之为组合
无处不在
当你定义一个类 并且这个类拥有某种类型的属性时 就称之为组合

都是用来重用代码的方式:
组合描述的是 什么拥有什么的关系   
基础描述的是 什么是什么的关系

   

class PC:
    def open_app(self,app_name):
        print("open %s" % app_name)

class OldBoyStudent:
    def __init__(self,PC,notebook):
        self.PC = PC
        self.notebook = notebook
    pass

pc = PC()
notebook = PC()

stu = OldBoyStudent(pc,notebook)

 

                  菱形继承

 

py3是新式类。由C3算法来确定继承顺序，先深度再广度

#发现存在同一父类，找另外一条线

 

                     接口

 

无需清楚函数怎么实现，只要知道函数名即可，这个函数名称为接口。

#外界调用接口只能完成某个任务，无具体实现细节。 

 

#abstrctclass
import abc

class USB(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def open(self):
        pass

    @abc.abstractmethod
    def close(self):
        pass

    @abc.abstractmethod
    def work(self):
        pass

 

class Mouse(USB):
    # 实现接口规定的所有功能
    def open(self):
        print("mouse opened")

    def work(self):
        print("mouse working...")

    def close(self):
        print("mouse closed")

class KeyBoard:
    def open(self):
        print("KeyBoard opened")

    def work(self):
        print("KeyBoard working...")

    def close(self):
        print("KeyBoard closed")

# 问题是 无法限制子类必须真正的实现接口中的功能
class Camera(USB):

    def open(self):
        pass

    def work(self):
        pass

    def close(self):
        pass

class PC:

    def conntent_device(self,usb_device):
        usb_device.open()
        usb_device.work()
        usb_device.close()

 

# 在实例化Camera abc模块就会检查Camera是否实现了所有的抽象方法 如果没有则无法实例化
Camera()

# pc = PC()
#
# # 创建一个鼠标设备
# mouse1 = Mouse()
#
# # 创建键盘设备
# key1 = KeyBoard()
#
# # 链接到电脑上
# # pc.conntent_device(mouse1)
# pc.conntent_device(key1)

 

#可通过abc抽象类强行限制字类必须覆盖的所有抽象方法，调用@abc.abcstractmethod

 

                       鸭子类型

 

不关心对象类型，只关心行为。

 

 

class Linux:
    def read_data(self,device):
        data = device.read()
        return data

    def write_data(self,device,data):
        device.write(data)

class Disk:
    def read(self):
        print("disk reading....")
        return "这是一个磁盘上的数据"

    def write(self,data):
        print("disk writing %s..." % data)

class UP:
    def read(self):
        print("disk reading....")
        return "这是一个U盘上的数据"

    def write(self,data):
        print("disk writing %s..." % data)

l = Linux()

d = Disk()
data = l.read_data(d)
l.write_data(d,"这是一个数据....")

up1 = UP()
l.read_data(up1)
l.write_data(up1,"一个数据...")