python--继承，多继承，魔术方法

在python开发中，常常会有大量的重复代码，这样就违背了python代码的简洁性。我们能不能把公共的属性放在一个类里面组成一个类呢。

继承

抽象除一个更抽象的类，存放公共代码，重用代码，方便代码的管理与修改。
看下例：

class Father():
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Son(Father):
    pass
son = Son('python',18)
print(son.name)
输出：python

从上例可以看出，子类继承了父类的属性。可以直接调用属性为己用。也就是说，父类由些什么，子类就有什么。那么父类没有的，子类可以有吗。

class Father():
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Son(Father):
    sex = 'man'
son = Son('python',18)
print(son.sex)
输出：man

可以看出，父类没有的子类是可以定义的。但是不能初始化。如果子类初始化了，那就意味着子类重写了初始化条件，类实例化的时候就只能传入子类的参数，传入父类参数会报错。
下面看一实例：

class Rectangle(): #定义一个矩形类
  def __init__(self,lenth,width):  #初始化矩形类
      self.lenth = lenth
      self.width = width
  def getarea_f(self):  #矩形类方法
      s = self.lenth*self.width
      return '矩形的面积是:{}'.format(s)
  
class Square(Rectangle):
  def getarea_s(self):
      if self.lenth = self.width:
          return '正方形面积为 ：{}'.format(self.lenth**2)
      return '四边形面积为 ：{}'.format(self.lenth*self.width)
squa = Square(4,6)
a = squa.getarea_f()
b = squa.getarea_s()
print(a)
print(b)
输出：矩形的面积是:24
     四边形的面积是:24

可以看出，子类可以有自己的方法，但同时有父类的方法。子类在继承中查找属性，先找自己的父类查找属性，如果找不到，会去父类的父类查找，依次类推，直到找到，或没有这个属性为止。顶级父类为 object。python中查找父类使用__ base__方法。

class Rectangle(): #定义一个矩形类
  def __init__(self,lenth,width):  #初始化矩形类
      self.lenth = lenth
      self.width = width
  def getarea_f(self):  #矩形类方法
      s = self.lenth*self.width
      return '矩形的面积是:{}'.format(s)
  
class Square(Rectangle):
  def getarea_s(self):
      if self.lenth = self.width:
          return '正方形面积为 ：{}'.format(self.lenth**2)
      return '四边形面积为 ：{}'.format(self.lenth*self.width)
print(Rectangle.__base__)
print(Square.__base__)
输出：
<class 'object'>
<class '__main__.Rectangle'>

多继承

上面讨论了一个类继承一个父类，那么一个类可以继承多个父类吗。

class Base():
    def play(self):
        print('this is base!!!')
class A(Base):
    def play(self):
        print('this is A')
class B(Base):
    def play(self):
        print('this is B')
class C(A,B):
    pass
c = C()
c.play()
this is A
#class C(B,A):
#c = C()
#c.play()
#this is B

上面可以看出，类多继承时候，对于相同的方法，位于前面的类是优先执行的。也就是说优先继承最先被继承的方法。
那么，如果上面的类中，不想继承其方法，怎么办呢，可以通过重写来覆盖父类的方法。

class Base():
    def play(self):
        print('this is base!!!')
class A(Base):
    def play(self):
        print('this is A')
class B(Base):
    def play(self):
        print('this is B')
class C(A,B):
    def play(self):
        print('I am C')
c = C()
c.play()
this is C

当子类重写父类方法后，子类如果想再次调用父类的方法，可以使用下面两种方法。

方法一
class C(A,B):
    def play(self):
        A.play(self)
        print('this is C')
方法二
class C(A,B):
    def play(self):
        super().play()
        print('this is C')

super()函数可以调用父类的方法。在父类中也可以使用super函数。可以调用__ mro__属性，或者mro方法来查看类的继承关系。

魔术方法

python的魔术方法就是提前已经写好的方法，可以直接调用。

class Rectangle():
    def __init__(self,lenth,width):
        self.lenth = lenth
        self.width = width
    def getarea(self):
        s = self.lenth*self.width
        return '四边形的面积是:{}'.format(s)
    def __add__(self,other):
        add_lenth = self.lenth + other.lenth
        add_width = self.width + other.width
        return add_lenth,add_width
    def __call__(self):
        if self.lenth != self.width:
            return '矩形的长 = {}，宽 = {}'.format(self.lenth,self.width)
        return '正方形边长 = {}'.format(self.lenth)
    def __repr__(self):
        return '矩形面积为:{}'.format(self.lenth*self.width)
a = Rectangle(3,4)
b = Rectangle(2,5)
print(a + b)
输出：(5, 9)
r = Rectangle(2,3)
print(r())
输出：矩形的长 = 2，宽 = 3
print(r.__repr__())
输出：矩形面积为:6

python 的魔术方法还有很多，我将专门放在以章节中总结。