继承

继承的另一种方式：

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

当你想要创建一个新的类，发现这个类中的一些最某一个类中已经存在，那就没有必要从头开始写，可以直接继承已有的类然后做补充

案列：

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

super()的问题  mro列表：

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 Person:
#     def __init__(self,name):
#         self.name = name
#
#
# p = Person("rose")
# print(p.name)

例子：

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)

新式类与经典类：

经典类：没有继承Object的类，只出现在py2中

新式类：直接或继承Object的类，只在py3中，所以py3中所有出现都是新式类

如果你的代码要兼容py2，那应该显示的继承Object比如：class B（object）：

pass 即可

菱形继承：

就是一个类有多个父类，然后多个父类又有共同的公有父类，那么这个产生的就是菱形继承。

多层菱形继承：

经典类的是先深度，一条线走完找到公有父类找不到再返回找另外一条线

新式类：就是一条线往上找找不到换另一条，最后再找公有父类

例子：

class A:
    # a = 1
    pass

class B(A):
    # a = 2
    pass

class C(A):
    # a = 3
    pass

class D(A):
    # a = 4
    pass

class E(B,C,D):
    # a = 5
    pass

e1 = E()

注意经典类没有mro列表

接口：

接口是什么：

例如USB

电脑内部具备USB相应的功能，如果要使用的话，就必须给外界提供一个使用方式，该方式就称之为接口

在程序中功能通常是用函数来表示，对于外界而言，无需清楚函数是如何实现的，只要知道函数名即可，这个函数名称就可以称之为接口。

外界调用接口就能完成某个任务 

接口其实就是一组功能的定义，但是只清楚函数名称，而没有具体的实现细节

相当于是一套规范/协议

好处是使用接口可以提高程序的扩展性

只要对象按照接口规定方法来实现，使用者就可以无差别使用所有对象

接口与抽象类：

抽象：

指的是 不清楚，不具体，看不懂

抽象方法：

指的是没有函数体的方法用 abc模块里面的@abc.abstractmethod装饰器

如果类中具备抽象方法，那么这个类就称之为抽象类

抽象类的特点：

不能直接实例化，必须有子类覆盖了所有抽象方法后才能实例化子类

与接口的区别：

接口里面必须全部是抽象方法全部用@abc.abstractmethod装饰器

抽象类里面可以有抽象方法和普通的方法

问题：如果接口的子类没有实现接口中方法，那是没有任何意义的

抽象类之所以出现的意义，通过抽象类来强行限制子类必须覆盖所有的抽象方法

import abc

class Test(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def say_hi(self):
        pass

class TT(Test):

    def say_hi(self):
        print("i am TT obj")

t = TT()
t.say_hi()

鸭子类型

说如果一个对象叫声像鸭子,走路像鸭子,长得像鸭子,那它就是鸭子

是python 推荐的方式,python不喜欢强行限制你

class PC():

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

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

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

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

mouse = Mouse()
pc = PC()

pc.conntent_device(mouse)



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

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

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

key1 = KeyBoard()

# 如果key1的特征和行为都像USB设备 那就把它当做USB设备来使用
# 对于使用者而言可以不用关心这个对象是什么类,是如如何是实现,
pc.conntent_device(key1)
案例2:

```python
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,"一个数据...")
```

例如linux 有一句话叫一切皆文件 

之所以这么设计是为了提高扩展性,让Linux可以无差别对待任何设备!