Python之多重继承

一、多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

class A:
  def aa(self):
    print("aa")
​
class B:
  def bb(self):
    print("bb")
​
class C(B,A):
  def cc(self):
    print("cc")
​
c = C()
c.cc()
c.bb()
c.aa()

类结构为：

二、MRO方法解析顺序

Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

MRO（Method Resolution Order）：方法解析顺序。 我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

class A:
  def aa(self):
    print("aa")
​
  def say(self):
    print("say AAA!")
​
class B:
  def bb(self):
    print("bb")
​
  def say(self):
    print("say BBB!")
class C(B,A):
  def cc(self):
    print("cc")
​
c = C()
print(C.mro())     #打印类的层次结构
c.say()         #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

执行结果：

[main.C'>, main.B'>, main.A'>, ] say BBB!

三、super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。

super()代表父类的定义，不是父类对象。

❤️想调用父类的构造方法：

super(子类名称,self).__init__(参数列表)

class A:
  def __init__(self):
    print("A的构造方法")
​
  def say(self):
    print("A: ",self)
    print("say AAA")
​
class B(A):
  def __init__(self):
    super(B,self).__init__() #调用父类的构造方法
    print("B的构造方法")
  def say(self):
    #A.say(self)   调用父类的say方法
    super().say()  #通过super()调用父类的方法
    print("say BBB")
​
b = B()
b.say()

 运行结果：

A: <__main__.B object at 0x007A5690>
say AAA
say BBB

四、多态

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。

比如：现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

关于多态要注意以下2点：

1. 多态是方法的多态，属性没有多态。
2. 多态的存在有2个必要条件：继承、方法重写

#多态
​
class Animal:
  def shout(self):
    print("动物叫了一声")
​
class Dog(Animal):
  def shout(self):
    print("小狗，汪汪汪")
​
class Cat(Animal):
​
  def shout(self):
    print("小猫，喵喵喵")
​
def animalShout(a):
  a.shout()  #传入的对象不同，shout方法对应的实际行为也不同。
​
animalShout(Dog())
animalShout(Cat())

五、特殊方法和运算符重载

Python的运算符实际上是通过调用对象的特殊方法实现的。

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

 运算结果：

c= 50
d= 50

常见的特殊方法统计如下：

方法	说明	例子
__init__	构造方法	对象创建和初始化：p = Person()
__del__	析构方法	对象回收
__repr__,__str__	打印，转换	print(a)
__call__	函数调用	a()
__getattr__	点号运算	a.xxx
__setattr__	属性赋值	a.xxx = value
__getitem__	索引运算	a[key]
__setitem__	索引赋值	a[key]=value
__len__	长度	len(a)

每个运算符实际上都对应了相应的方法，统计如下：

运算符	特殊方法	说明
+	__add__	加法
-	__sub__	减法
< <= ==	__lt__ __le__ __eq__	比较运算符
> >= !=	__gt__ __ge__ __ne__	比较运算符
| ^ &	__or__ __xor__ __and__	或、异或、与
<< >>	__lshift__ __rshift__	左移、右移
* / % //	__mul__ __truediv__ __mod__ __floordiv__	乘、浮点除、模运算（取余）、整数除
**	__pow__	指数运算

我们可以重写上面的特殊方法，即实现了“运算符的重载”。

#测试运算符的重载
​
class Person:
  def __init__(self,name):
    self.name = name
​
  def __add__(self, other):
    if isinstance(other,Person):
      return "{0}--{1}".format(self.name,other.name)
    else:
      return "不是同类对象，不能相加"
​
  def __mul__(self, other):
    if isinstance(other,int):
      return self.name*other
    else:
      return "不是同类对象，不能相乘"
​
p1 = Person("高淇")
p2 = Person("高希希")
​
x = p1 + p2
print(x)
print(p1*3)

运算结果：

高淇--高希希
高淇高淇高淇