python开发面向对象基础：接口类&抽象类&多态&钻石继承

一，接口类

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

开发中容易出现的问题

 class Alipay:
     '''
     支付宝支付
     '''
     def pay(self,money):
         print('支付宝支付了%s元'%money)

 class Applepay:
     '''
     apple pay支付
     '''
     def pay(self,money):
         print('apple pay支付了%s元'%money)

 class Wechatpay:
     def fuqian(self,money):
         '''
         实现了pay的功能，但是名字不一样
         '''
         print('微信支付了%s元'%money)

 def pay(payment,money):
     '''
     支付函数，总体负责支付
     对应支付的对象和要支付的金额
     '''
     payment.pay(money)

 p = Wechatpay()
 pay(p,200)   #执行会报错

接口初成：手动报异常：NotImplementedError来解决开发中遇到的问题

借用abc模块来实现接口

 from abc import ABCMeta,abstractmethod

 class Payment(metaclass=ABCMeta):
     @abstractmethod
     def pay(self,money):
         pass

 class Wechatpay(Payment):
     def fuqian(self,money):
         print('微信支付了%s元'%money)

 p = Wechatpay() #不调就报错了

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

依赖倒置原则： 高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

*****接口提取了一群类共同的函数，可以把接口当做一个函数的集合。 然后让子类去实现接口中的函数。 这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。 归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

二，抽象类

什么是抽象类

    与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

为什么要有抽象类

  如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

　 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

    从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

 #一切皆文件
 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)

抽象类与接口类

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计 

在python中，并没有接口类这种东西，即便不通过专门的模块定义接口，我们也应该有一些基本的概念。

1.多继承问题

在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口

接口隔离原则：
使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

2.方法的实现

在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现

三,钻石继承

 class A(object):
     def test(self):
         print('from A')

 class B(A):
     def test(self):
         print('from B')

 class C(A):
     def test(self):
         print('from C')

 class D(B):
     def test(self):
         print('from D')

 class E(C):
     def test(self):
         print('from E')

 class F(D,E):
     # def test(self):
     #     print('from F')
     pass
 f1=F()
 f1.test()
 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

 #新式类继承顺序:F->D->B->E->C->A
 #经典类继承顺序:F->D->B->A->E->C
 #python3中统一都是新式类
 #pyhon2中才分新式类与经典类

 继承顺序

继承原理

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

四,多态

多态指的是一类事物有多种形态

动物有多种形态：人，狗，猪

 import abc
 class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
     @abc.abstractmethod
     def talk(self):
         pass

 class People(Animal): #动物的形态之一:人
     def talk(self):
         print('say hello')

 class Dog(Animal): #动物的形态之二:狗
     def talk(self):
         print('say wangwang')

 class Pig(Animal): #动物的形态之三:猪
     def talk(self):
         print('say aoao')

文件有多种形态：文本文件，可执行文件

 import abc
 class File(metaclass=abc.ABCMeta): #同一类事物:文件
     @abc.abstractmethod
     def click(self):
         pass

 class Text(File): #文件的形态之一:文本文件
     def click(self):
         print('open file')

 class ExeFile(File): #文件的形态之二:可执行文件
     def click(self):
         print('execute file')

多态性

一 什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

多态性分为静态多态性和动态多态性

　　静态多态性：如任何类型都可以用运算符+进行运算

　　动态多态性：如下

 peo=People()
 dog=Dog()
 pig=Pig()

 #peo、dog、pig都是动物,只要是动物肯定有talk方法
 #于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
 peo.talk()
 dog.talk()
 pig.talk()

 #更进一步,我们可以定义一个统一的接口来使用
 def func(obj):
     obj.talk()

鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系

 #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
 class TxtFile:
     def read(self):
         pass

     def write(self):
         pass

 class DiskFile:
     def read(self):
         pass
     def write(self):
         pass

 例子

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass