python Day 25 继承的另一种使用方式、多继承、组合、菱形继承问题（经典类和新式类路线不一样）、接口、抽象类、鸭子类型

　　阅读目录

　　　　内容回顾

　　　　继承的另一种使用方式

　　　　多继承

　　　　组合

　　　　菱形继承问题（经典类和新式类路线不一样）

　　　　接口

　　　　抽象类

　　　　鸭子类型

　　##内容回顾

#属性的的正确存放位置
    类中应该存储所有对象公共的内容
    对象中存储都是每个对象独有的(都不同)
#初始化函数
    给对象的属性赋初值 , 可以保证只要对象被创建就一定有相应的属性
    节省了重复代码

#绑定方法
    指的是 将类或对象与函数进行了绑定
    之所以绑定是为了提高整合度,后续在拿到对象就可以直接调用而无需关心 数据时什么
#如何处理
    对象也可以看做是一个存储数据的容器

    对象绑定方法
        默认情况下就是绑定给对象的
        当执行该方法时,需要访问对象中的内容
        当使用对象调用时 会自动传入对象本身作为第一个参数
        用类来调用时就是一个普通函数  该怎么传就这么传
    类绑定方法
        当执行该方法时,需要访问类中的内容而不需要对象中的内容
        @classmethod
        无论使用类还是对象来调用都会自动传入类本身作为第一个参数
    非绑定方法
        既不需要访问类中的内容 也不需要访问对象中的内容  那就作为非绑定方法  就是一个普通函数  没有自动传值的效果
        @staticmethod

#继承
    说的是类与类之间的关系
    存在基础关系后 子类可以直接使用父类已经存在的内容   总的来说是为了提高代码的复用性
    例如猫 和狗 都属于动物类
    描述的时 什么是什么的关系  如:猫是动物

    要开始累积自己的类库 把经常使用的小功能写到一个模块中  以后可以直接调用

    class 子类(父类):
        pass

#属性查找顺序
    对象本身 -> 所在的类 -> 类的父类 -> .... object

#抽象
    使用基础时 应该先抽象 在继承
    抽象指的是 把一系列类中的相同的特征和行为抽取 形成一个新的类 (公共父类)

#派生
    子类拥有与父类不同的内容
#覆盖
    子类出现了与父类完全相同的名字

#一切皆对象
    在py3里面所有东西全是对象  包括 int list 模块 函数 .....包等等....
    list.append(li,1)


#子类访问父类的内容
    1.指名道姓 直接写死了类名   即时不存在继承关系也能调用
    2.super().要访问的属性 (py3出现的)
    3.super(这个子类的名字,self).属性

　　##继承的另一种使用方式

#继承已有的类来扩展新功能
----用已经有的类建立一个新的类，这样就重用了已经有的软件中的一部分甚至大部分，大大节省了编程工作量，这就是常说的软件重用，不仅可以重用自己的类，
也可以继承别人的，比如标准库，来定制新的数据类型，大大缩短了软件开发周期，对大型软件开发来说，意义重大

#示例
"""
实现一个存储类 在提供基本的存取功能之外 还要可以限制存储元素的类型

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


li = MyList(str)
li.append(10)
li.append("123")
print(li)

# li = list()
# li = MyList()
# # li.append(10)
# # li.append(20)
# #
# # print(li)
#
# li.append("hello")
# li.append(20)
#
# print(li)

　　##多继承

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

好处是更加灵活 

#问题是:属性的查找顺序该怎么确定 

#总结
当你使用super()函数时,Python会在MRO列表上继续搜索下一个类。如果每个重定义的方法统一使用super()并只调用它一次,那么控制流最终会遍历完整个MRO列表,
每个方法也只会被调用一次**(注意注意注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表)

#示例
# 问题:多继承时如果多个父类中出现了同名的属性/函数
# 你不能用眼睛去判断查找顺序 ,需要使用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()

print(C.mro())

#输出
from A
from B
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

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

　　##组合

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

都是用来重用代码的方式:
组合描述的是 什么拥有什么的关系   学生 有 书  学生有手机
继承描述的是 什么是什么的关系      麦兜是猪    猪猪侠也是猪

#示例1
class Equip: #武器装备类
     def fire(self):
         print('release Fire skill')

class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
     camp='Noxus'
     def __init__(self,nickname):
         self.nickname=nickname
         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
r1=Riven('锐雯雯')
r1.equip.fire() #可以使用组合的类产生的对象所持有的方法

#示例2
# 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)
# stu.PC.open_app("pycharm")
stu.notebook.open_app("pycharm")

#直接继承就可以使用open_app方法
# stu.open_app("pycharm")

#示例3：针对示例2做了修改

class PC:
    def opem_app(self,app_name):
        print('open %s'%app_name)
class Student:
    def __init__(self):
        self.pc = PC()#直接将对象赋值给实例的pc属性


stu = Student()#和上面的对比，实例话一个学生对象时就不用传值了
stu.pc.opem_app('qq')

　　##菱形继承问题（经典类和新式类路线不一样）

# 在py2中 A就是一个经典类---即经典类不继承object父类，主动继承变为新式类，py3都是新式类，可以不括号中添加也会继承object，但有时候为为了兼容py2，py3会有添加的
# class A:
#     pass

# 如果你的代码需要兼容py2 那应该显式的继承object  无论是直接还是间接继承
class B(object):
    pass

class A(B):
    pass

#下图：
#1、经典类 ：深度优先   e--->b ---->a ----->c ---->d
#2、新式类：因为是菱形，所以总会存在一个父类，e ——————>b 发现a是b、c、d 的父类，也可以理解为先深度找到相同父类，在按广度优先找：e---->b（发现a是相同父类，不找了，广度来找）------>c ------>d----->a

　　##多菱形示例

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()
# print(e1.a)
# 新式类的顺序
# E  B C D A object 
# 经典类的顺序
# E B A C D
# print(E.mro())

注意:经典类没有mro列表

　　##接口

#什么是接口?

接口其实是一套协议规范：usb就是一种接口,电源插座也是接口,python中没interface关键字，只能模拟成接口模式

#为什么需要接口?
1.让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

2.使得外部使用者可以不加区分的处理所有接口兼容的对象

#注意
完全可以不用去实现接口，没有强制性的要求子类必须实现父类的方法,这就用到了抽象类

#示例1

class USB:
    def  open(self):
        pass
    def work(self):
        pass
    def close(self):
        pass

class Mouse(USB):
    #实现接口规范中的所有功能
    def open(self):
        print('open opened')
    def work(self):
        print('mouse working')
    def close(self):
        print('mouse closed')

class KeyBoard(USB):
　　#实现接口规范中的所有功能
    def open(self):
        print('KeyBoard opened')

    def work(self):
        print('KeyBoard working')

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

class PC:
    def conntent_device(self,usb_device):
        usb_device.open()
        usb_device.work()
        usb_device.close()
#实例化一个PC设备
pc = PC()
#创建一个鼠标设备
mouse1 = Mouse()
#创建一个键盘设备
key1 = KeyBoard()

#连接到电脑
pc.conntent_device(mouse1)
pc.conntent_device(key1)

 #示例2 

class IOInterface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
    def read(self): #定接口函数read
        pass

    def write(self): #定义接口函数write
        pass

class Txt(Interface): #文本，具体实现read和write
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(Interface): #磁盘，具体实现read和write
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(Interface):
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

　　##抽象类

# 抽象:

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

# 抽象方法:

​指的是 没有函数体的方法   用@abc.abstractmethod 装饰器

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

# 抽象类的特点:

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

# 与接口的区别:

​接口是指只有方法声明而没有实现体 ,  接口中所有方法都是抽象的 

#补充
如果接口的子类没有实现接口中的方法,那是没有任何意义的 

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

#示例1
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()

#示例二
#_*_coding:utf-8_*_
#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家的使用方法时完全一致的,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

　　##鸭子类型

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

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

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

#示例1
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

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