2024.6.9 二

Python类的继承

class 子类(父类1,父类2,…)
子类继承父类的和方法,即如果什么都不改,就相当于父类改了个名字接着用

构造函数继承与改写
当在Python中出现继承的情况时，一定要注意初始化函数_init_的行为：

如果子类没有定义自己的初始化函数，父类的初始化函数会被默认调用；但是如果要实例化子类的对象，则只能传入父类的初始化函数对应的参数，否则会出错。

# 定义父类：Parent
class Parent(object):
    def __init__(self, name):
        self.name = name
# 定义子类Child ，继承父类Parent       
class Child(Parent):
    pass
c = Child("init Child") 

此时Child类实例化时，由于子类没有初始化，此时父类的初始化函数就会默认被调用且必须传入父类的参数 name,相当于父类的构造函数来到子类里补充了子类缺失的构造

如果子类定义了自己的初始化函数，而在子类中没有显示调用父类的初始化函数，则父类的属性不会被初始化

class Parent(object):
    def __init__(self, name):
        self.name = name
# 子类继承父类        
class Child(Parent):
    # 子类中没有显示调用父类的初始化函数
    def __init__(self,sex):
        self.sex=sex
# 将子类实例化  
c = Child('male')
print(c.name)

在子类中没有显示调用父类的初始化函数，则父类的属性不会被初始化，因而此时调用子类中name 属性不存在,调用name会报错,而调用sex会正常打印

如果子类定义了自己的初始化函数，在子类中显示调用父类，子类和父类的属性都会被初始化

class Parent(object):
    def __init__(self, name):
        self.name = name
class Child(Parent):
    def __init__(self,sex,name):
        self.sex=sex
        super(Child,self).__init__(name)
c = Child('male','jerry')
print(c.name)
print(c.sex)

现在c就有了Parent类的name和Child类的sex两个属性

方法的改写

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法

SUPER()函数详解
在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时，我们希望能同时实现父类的功能，这时，我们就需要调用父类的方法了。
比如下面这个例子:

class Bird:
    def __init__(self):
          self.hungry = True
    def eat(self):
          if self.hungry:
               print 'Ahahahah'
          else:
               print 'No thanks!'
class SongBird(Bird):
     def __init__(self):
          self.sound = 'Squawk'
     def sing(self):
          print self.song()
sb = SongBird()
sb.sing()    # 能正常输出
sb.eat()     # 报错，因为 songgird 中没有 hungry 特性

为了让我们可以在覆盖掉父类方法的同时使用父类的方法,我们就可以使用super()函数

class SongBird(Bird):
     def __init__(self):
          super(SongBird,self).__init__()
          self.sound = 'Squawk'
     def sing(self):
          print self.song()

使用时要注意,super()里面的参数是子类,super查找的是给出的参数的父类
上例里就不能super(Bird,self),这样写的话就找的是Bird的父类了

多态问题
即,一个子类同时继承自多个父类的多继承问题——class 子类(父类1,父类2,…)
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#类定义
class people:
    name = ''
    age = 0
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

然而,很多时候我们发现,这样容易导致父类的构造函数被多次调用,所以我们常使用super函数来搭配使用,而当我们在super里面写了多个父类时,我们需要注意,此时super遵顼MRO顺序(广度优先)

MRO顺序指,出现如:
—> B —
A –| |–> D
—> C —
的顺序时,不会从B(或C)直接到A,而是先把同一层的遍历完成后,再进入到下一层
能进入下一层时,先检查是否还有同层,只有同一层的走完后(广度)才会往下(深度)