1 1.正常调用
 2 class Applepay:
 3     def pay(self,money):
 4         print(‘apple pay 支付了%s‘ %money)
 5 
 6 class Alipay:
 7     def pay(self,money):
 8         print(‘支付宝  支付了%s‘ %money)
 9 
10 def payment(pay_obj,money):  #实例化的另一种调用，这个方法让实例化的时候按照payment调用：就像下面的payment(apple1,200)
11         pay_obj.pay(money)
12 
13 apple1 = Applepay()
14 # apple1.pay(200)
15 payment(apple1,200)

 1 # 2.有时候写的时候会把方法写错，自己定义一个主动报错
 2 # 接口初成：手动报异常：NotImplementedError来解决开发中遇到的问题
 3 class Payment:
 4     def pay(self):
 5         raise NotImplementedError  #主动让程序报错
 6 
 7 class Wechatpay(Payment): #微信支付
 8     def pay(self,money):
 9         print(‘微信支付了%s元‘,money)
10 
11 class QQchatpay(Payment): #QQ支付
12     def fuqian(self,money):
13         print(‘QQ支付了%s元‘,money)
14 
15 p = Wechatpay()
16 p.pay(200)   #不报错
17 q = QQchatpay()   #不报错
18 q.pay()  #报错

 1 # 3.借用abc模块来实现接口
 2 #接口类（就是为了提供标准，约束后面的子类）
 3 from abc import ABCMeta,abstractmethod
 4 class Payment(metaclass=ABCMeta):
 5     @abstractmethod
 6     def pay(self,money):
 7         pass
 8 
 9 class Wechatpay(Payment):
10     def fuqian(self,money):
11         ‘‘‘实现了pay的功能，但是方法名字不一样‘‘‘
12         print(‘微信支付了%s元‘%money)
13 
14 class Alipay:
15     def pay(self,money):
16         print(‘支付宝  支付了%s‘ %money)
17 
18 # p = Wechatpay() #报错了（因为上面定义了一个接口类，接口类里面
19 # 定义了一个pay方法，而在下面的Wechatpay方法里没有pay方法，不能
20 # 调用，在接口类里面约束一下，接口类里的pay方法里面不能写其他，直接pass）
21 a = Alipay()
22 a.pay(200)
23 p = Payment() #接口类不能被实例化

 1 接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
 2 
 3 然后让子类去实现接口中的函数。
 4 
 5 这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
 6 
 7 归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
 8 
 9 比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
10 
11 再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
12 
13 为何要用接口

 1 # 抽象类
 2 # 什么叫做抽象?  从小范围到大范围
 3 from abc import ABCMeta,abstractmethod
 4 class Animal(metaclass=ABCMeta):
 5     @abstractmethod
 6     def eat(self):
 7         print(‘打开粮食的袋子‘)
 8         print(‘放一个吃饭的碗‘)
 9         print(‘吧粮食倒在碗里‘)
10 
11     @abstractmethod
12     def sleep(self):
13         pass
14 
15 class Dog(Animal):
16     #实现吃喝睡的方法
17     def eat(self):
18         super().eat()
19         # super(Dog, self).eat()
20         print(‘dog is eating‘)
21     def sleep(self):
22         print(‘dog is sleeping‘)
23 
24 # d = Dog()
25 # d.eat()
26 a = Animal()  #抽象类不能被实例化

 1 class A:
 2     def test(self):
 3         print(‘from A‘)
 4 class B(A):
 5     def test(self):
 6         print(‘from B‘)
 7 class C(A):
 8     def test(self):
 9         print(‘from C‘)
10 class D(A):
11     def test(self):
12         print(‘from D‘)
13 class E(B):pass
14     # def test(self):
15     #     print(‘from E‘)
16 
17 class F(E,D,C):pass
18     # def test(self):
19         # print(‘from F‘)
20 
21 
22 # b= B()
23 # b.test()
24 # d = D()
25 # d.test() #一级一级往上找，自己没有，就继承爹的，爹没有就找爷爷的
26         # 再找不到就报错了
27 f = F()
28 f.test()
29 print(F.mro()) #查看找父类的顺序

 1 from abc import ABCMeta,abstractmethod
 2 class Animal(metaclass=ABCMeta):
 3     @abstractmethod
 4     def eat(self):pass
 5 class Cat(Animal):  #动物的形态之一：猫
 6     def eat(self):
 7         print(‘cat eat‘)
 8 class Dog(Animal):  #动物的形态之二：狗
 9     def eat(self):
10         print(‘dog eat‘)
11 
12 class Pig(Animal):pass  #动物的形态之三：猪
13 def eat_fun(animal_obj): #定义一个函数让这个函数名去调用
14     animal_obj.eat()
15 c = Cat()
16 eat_fun(c)  #函数名(对象)
17 
18 d = Dog() 
19 eat_fun(d)
20 
21 c = Cat()
22 c.eat()