面向对象的三大特性

继承：

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

python中类的继承可以分为单继承和多继承。

class ParentClass1:#定义父类
    pass
class ParentClass2:#定义父类
    pass
class SubClass1(ParentClass1):#单继承，基类是ParentClass1，派生是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2):#python支持多继承，用逗号隔开多个继承的类
    pass

单继承和多继承

查看继承

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

查看继承

当子类当中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量,父类中的方法不会被自动执行

如果我们既想要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中调用父类的方法：

父类名.方法名(self,...)

super().方法名(...)

如果没有指定基类，python的类会默认继承object类，object是所有python类的基类。

#抽象类

抽象类是一个规范，他基本不会实现什么具体的功能，抽象类是不能被实例化。

要想写一个抽象类：

from abc import ABCMeta,abstractmethod

在这个类创建的时候指定 metaclass = ABCMeta

在你希望子类实现的方法上加上一个 @abstractmethod装饰器

使用抽象类：

继承这个类

必须实现这个类中被@abstractmethod装饰器装饰的方法

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):   # 模板的功能
    @abstractmethod     # abstractmethod是一个装饰器，装饰器怎么用？放在函数/类的上一行
    def pay(self):pass

    @abstractmethod
    def shouqian(self):pass

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

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

class ApplePay(Payment):
    def pay(self,money):
        print('使用applepay支付了%s元' % money)

def pay(obj,money):
    obj.pay(money)

p = Payment()

抽象类

#多继承

# class Animal:
#     def __init__(self,name):
#         self.name = name
# class FlyAnimal(Animal):
#     def fly(self):
#         print('%s在飞'%self.name)
# class WalkAnimal(Animal):
#     def walk(self):
#         print('%s在走路'%self.name)
# class SwimAnimal(Animal):
#     def swim(self):
#         print('%s在游泳'%self.name)
# class Tiger(SwimAnimal,WalkAnimal):
#     pass
# class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
#     pass
# class Parrot(FlyAnimal,WalkAnimal):
#     def talk(self):
#         print('%s说话了'%self.name)
# swan = Swan('天鹅')
# swan.fly()
# swan.walk()
# swan.swim()

#新式类

在python3.x版本中所有的类都是新式类

所有的新式类都有一个默认的父类： object

python2.7中经典类和新式类并存。

多继承的顺序：钻石顺序

当类是经典类时，多继承情况下，会按照深度优先方式查找。

当类是新式类时，多继承情况下，会按照广度优先方式查找。

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中才分新式类与经典类

继承顺序

#新式类和经典类的区别：

新式类：1.所有的多继承关系寻找方法的顺序：遵循广度优先方法。

2.继承object

3.mro方法

4.super：super不是单纯的找父类，而是遵循mro顺序的。

经典类：1.不主动继承object

2.在找父类的方法过程中遵循深度优先

3.不提供mro方法和super