Python类的单继承、多继承与super的使用详解
Python类的单继承、多继承与super的使用详解
内容学习自网络：
1.单继承
2.多继承及super使用详解
一、Python类的单继承使用详解
继承性的好处：
①减少了代码的冗余，提供了代码的复用性
②提高了程序的扩展性
③（类与类之间产生了联系）为多态的使用提供了前提
二、类继承性的格式：单继承和多继承
#python2中无继承父类，称之为经典类，python3中，默认继承object类，称之为新式类
#注意：python3中，（object）可以显示出来，不写也不会报错。
python中继承的格式为：
class 子类A（父类1，父类2）：
子类体
#注意：区分单继承和多继承主要看子类继承类中的类个数，单个为单继承，多个为多继承。
三、子类继承父类后有哪些特性？（以单继承为例）
总结：
1.子类在继承父类时，默认继承了父类的 init()方法，如果子类没有重写__init__方法，则在创建对象时默认调用父类的该方法。但如果重写了__init__ 时，实例化子类时，就不会调用父类已经定义的 init
2.因为子类默认继承了父类的构造方法，所以子类可以不需要重写__init_()方法。如果子类重写了自己的__init__()方法，那么子类该方法的参数个数要大于等于父类的个数（要包含父类的参数）。否则，报错。因为python中一个类中只能有一个init方法，不支持构造方法的重载。
3.注意:可以用super().的形式调用父类的构造方法，但这个时候参数不用写self了，注意跟直接用父类名.形式调用的区别。
格式：
super（）.init(name,age) #此时不用添加self
Person.init(self,name) #此时需要添加self,切记这里Parent后不需要跟（）
4.子类继承了父类所有的属性，包扣私有属性，只是私有属性不能直接去调用，而是要通过get/set方法进行调用。
5.子类继承了父类的所有方法，同样 私有方法不能外部直接调用。
6.同样如果父类还有父类，那么子类也会继承父类的父类所有方法和属性（注意私有属性和 方法同样访问不了）
代码示例:
#父类Person
class Person(object):
country = "china"
__sex = "male"
def __init__(self,name ,age):
self.name = name
self.__age = age #父类的私有属性
#给私有属性提供get和set方法
def getSex(self):
return self.__sex
def setSex(self,sex ):
self.__sex = sex
def getAge(self):
return self.__age
def setAge(self,age):
self.__age = age
#父类的共有方法
def p(self):
print("这是父类的方法")
def p1(self):
print("这是父类的方法p1")
#父类的私有方法
def __p(self):
print("父类的私有方法")
#子类，Studnent
class Student(Person):
#1.子类默认继承了父类的构造方法__init__()，创建对象时默认调用.但是子类也可以有直接的构造方法__init()
#1.若子类有自己的init__()__方法,则该方法的参数个数要大于等于父类的个数，否则报错,因为会默认调用父类的。
def __init__(self, name, age, grade):#如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init_
Person.__init__(self, name, age) # 调用父类的构造方法,实现子类初始化，如果不调用要分别赋值
#super().__init__(name,age) #注意，也可以用super()调用父类的构造方法，但这个时候参数不用写self了。
self.grade = grade
#2.子类中，有一个和父类中相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法，也叫方法的重写（override）
def p(self):
print("这是子类的方法")
#--------创建对象--------------------------------------------------------------------
stu = Student("tom",11,88)
#3.子类继承了父类的所有属性，但是私有属性不能直接调用，要通过方法。况且私有属性连父类自己都不能直接调用
print(stu.country,stu.name,stu.grade)
#print(stu.age,stu.sex) #调用私有属性报错，可以用 get/set方法调用私有属性。
print(stu.getAge(),stu.getSex())
#4.子类继承了父类的所有方法，同样私有方法不能直接调用（父类自己都不能直接调用，何况子类。）。
stu.p() #如果父类中和子类有同名的方法，那么默认调用子类的,子类覆盖父类的方法了。
stu.p1() #直接调用父类中有，子类没有的方法。
=======执行结果============================================================================
china tom 88
11 male
这是子类的方法
这是父类的方法p1
多继承模块与super使用详解
0.问题的提出
如果不同的父类中存在 同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？
Python 中的 MRO —— 方法搜索顺序
Python 中针对 类 提供了一个内置属性 mro 可以查看方法搜索顺序
MRO 是 method resolution order，主要用于在多继承时判断 方法、属性 的调用 路径
在搜索方法时，是按照 mro 的输出结果 从左至右 的顺序查找的
如果在当前类中 找到方法，就直接执行，不再搜索
如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
如果找到最后一个类，还没有找到方法，程序报错
1.多继承的使用
总结：
1.需要注意圆括号中继承父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
2.支持多层父类继承，子类会继承父类所有的属性和方法，包括父类的父类的所有属性 和 方法。
2.多继承的使用注意事项
总结：子类从多个父类派生，而子类又没有自己的构造函数时，
（1）按顺序继承，哪个父类在最前面且它又有自己的构造函数，就继承它的构造函数；
（2）如果最前面第一个父类没有构造函数，则继承第2个的构造函数，第2个没有的话，再往后找，以此类推。
注意：当子类没有自己的构造函数时，如果多继承多个类，除了继承了的那个类的构造函数（属性）和方法可用，其他的类构造函数（属性）和方法不可用，否则报错!
3.多继承时使用super调用父类属性方法的注意事项
3.1不使用super调用父类方法，使用父类名.方法名的形式。
代码示例：
class Parent(object):
def __init__(self, name):
print('parent的init开始被调用')
self.name = name
print('parent的init结束被调用')
class Son1(Parent):
def __init__(self, name, age):
print('Son1的init开始被调用')
self.age = age
Parent.__init__(self, name) #直接使用父类名.方法名的方式调用父类的__init__方法
print('Son1的init结束被调用')
class Son2(Parent):
def __init__(self, name, gender):
print('Son2的init开始被调用')
self.gender = gender
Parent.__init__(self, name) #
print('Son2的init结束被调用')
class Grandson(Son1, Son2):
def __init__(self, name, age, gender):
print('Grandson的init开始被调用')
Son1.__init__(self, name, age) # 单独调用父类的初始化方法
Son2.__init__(self, name, gender)
print('Grandson的init结束被调用')
gs = Grandson('grandson', 12, '男')
print('姓名：', gs.name)
print('年龄：', gs.age)
print('性别：', gs.gender)
'''执行结果如下：
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 12
性别： 男
'''
注意：上面代码里当在子类中通过父类名调用时，parent被执行了2次
3.2 使用super调用父类中的方法，注意分析程序的执行顺序。
代码示例：`class Parent(object):
def init(self, name, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print(‘parent的init开始被调用’)
self.name = name
print(‘parent的init结束被调用’)
class Son1(Parent):
def init(self, name, age, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print(‘Son1的init开始被调用’)
self.age = age
super().init(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print(‘Son1的init结束被调用’)
class Son2(Parent):
def init(self, name, gender, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数
print(‘Son2的init开始被调用’)
self.gender = gender
super().init(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数
print(‘Son2的init结束被调用’)
class Grandson(Son1, Son2):
def init(self, name, age, gender):
print(‘Grandson的init开始被调用’)
# 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍
# 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
# super(Grandson, self).init(name, age, gender) 效果和下面的一样
super().init(name, age, gender)
print(‘Grandson的init结束被调用’)
print(Grandson.mro) #搜索顺序
gs = Grandson(‘grandson’, 12, ‘男’)
print(‘姓名：’, gs.name)
print(‘年龄：’, gs.age)
print(‘性别：’, gs.gender)
‘’'结果如下：
(
Grandson的init开始被调用
Son1的init开始被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Son1的init结束被调用
Grandson的init结束被调用
姓名： grandson
年龄： 12
性别： 男`
注意：在上面模块中，当在子类中通过super调用父类方法时，parent被执行了1次。
**super调用过程：**上面gs初始化时，先执行grandson中init方法, 其中的init有super调用，每执行到一次super时，都会从__mro__方法元组中顺序查找搜索。所以先调用son1的init方法，在son1中又有super调用，这个时候就就根据__mro__表去调用son2的init，然后在son2中又有super调用，这个就根据mro表又去调用parent中的init，直到调用object中的init. 所以上面的打印结果如此，要仔细分析执行过程。
尖叫提示：
1.super().__init__相对于类名.init，在单继承上用法基本无差
2.但在多继承上有区别，super方法能保证每个父类的方法只会执行一次，而使用类名的方法会导致方法被执行多次，具体看前面的输出结果
3.多继承时，使用super方法，对父类的传参数，应该是由于python中super的算法导致的原因，必须把参数全部传递，否则会报错
4.单继承时，使用super方法，则不能全部传递，只能传父类方法所需的参数，否则会报错
5.多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍, 而使用super方法，只需写一句话便执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
3.3单继承使用super调用父类方法