一、接口类与抽象类
1、实现接口类和抽象类的语法
from abc import abstractclassmethod, ABCMeta
class 父类(mateclass=ABCMeta): # 抽象类/接口类
@abstractclassmethod
def function（）: pass
2、接口类
继承有两种用途：（1）继承基类的方法，并做出自己的改变和扩展；（2）声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
接口类：可以多继承，且最好不实现具体功能
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta): #抽象类/接口类：子类的规范
@abstractmethod
def payment(self,money):pass
class Applepay():
def payment(self,money):
print('apple 支付了 %d元'%money)
class Alipay():
def payment(self,money):
print('支付宝 支付了 %d元' % money)
class Wechatpay():
def payment(self,money):
print('微信 支付了 %d元' % money)
def pay(pay_obj,money): #归一化设计
pay_obj.payment(money)
apple = Applepay()
ali = Alipay()
wechat = Wechatpay()
pay(wechat,100)
pay(apple,200)
pay(ali,300)
依赖倒置原则： 高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程。
3、抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。 如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
抽象类：最好单继承，且可以简单的实现功能
例1：抽象类可以简单的实现功能
from abc import abstractmethod,ABCMeta
class Foo(metaclass=ABCMeta): #抽象类
@abstractmethod
def read(self):
f = open()
f.close()
@abstractmethod
def write(self):
f = open()
f.close()
class File(Foo):
def read(self):
super().read()
def write(self):
super().write()
class Disk(Foo):
def read(self):
super().read()
def write(self):
super().write()
例2：抽象类不实现功能
#一切皆文件
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): #子类继承抽象类，但是必须定义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()
二、钻石继承
1、经典类与新式类
父类继承object类，称为新式类，否则称为经典类，python3中只有新式类，而python2中同时存在两种类。
class A(object): #新式类，若不继承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):
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类
2、继承顺序
如上例，若F类没有test（）方法，则会按照继承的属性向上所继承的类进行寻找，找到位置。但是不同的类（新式或者经典）继承的顺序是不同的。其中新式类和经典类继承的顺序如下：
钻石继承：新式类为广度优先，经典类为深度优先的原则进行继承，其中在新式类中可以用：子类名.__mro__ 查看继承顺序，而经典类中此方法不存在。
三、多态特性
python天生支持多态性。
1、多态
指的同一事物有多种形态，如动物有：人、狗、猪形态
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')
2、多态性
多态性是指在不考虑实例类型的情况下使用实例。
peo=People()
dog=Dog()
pig=Pig()
#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()
#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
obj.talk()