python语法学习之super(),继承与派生

目录

• 1 什么是继承？
• 2 继承的规则
• 3 继承原理
• 4 多继承属性查询顺序
• 5 查找流程
• 属性查找
• 6 继承概念的实现
• 7 私有属性私有方法在继承中的表现
• 8 派生类
• 9 属性的覆盖（派生属性）
• 10 父类属性（方法）的重用
• 11 继承派生机制的作用
• 12 Super()

1 什么是继承？

继承是一种创建新类的方式；

在Python中，新建的类可以继承一个或多个父类，新建的类可称为子类或派生类，父类又可称为基类或超类。

继承可以用来解决类与类之间的代码重用性问题；

class ParentClass1: #定义父类
    pass
class ParentClass2: #定义父类
    pass
class SubClass1(ParentClass1): #单继承
    pass
class SubClass2(ParentClass1,ParentClass2): #多继承
    pass

注意：

在python中一个子类可以继承多个父类，在其他语言中，一个子类只能继承一个父类；

python中的继承分为单继承和多继承；

通过类的内置属性__bases__可以查看类继承的所有父类

>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

在Python3中只有新式类，即使没有显式地继承object，也会默认继承该类。

2 继承的规则

子类继承父类的成员变量和成员方法：

• 子类不继承父类的构造方法，能够继承父类的析构方法
• 子类不能删除父类的成员，但可以重定义父类成员
• 子类可以增加自己的成员

示例：

# python中子类继承父类成员变量之间的取值逻辑
class Person():
    def __init__(self, name, age, sex):
        self.name = "jasn"
        self.age = '18'
        self.sex = sex
    def talk(self):
        print("i want to speak something to yo!!")
class Chinese(Person):
    def __init__(self, name, age, sex, language):
        Person.__init__(self, name, age, sex)  # 用父类的name,age，sex 覆盖掉子类的属性
        self.age = age  # 覆盖掉了父类的age,取值为子类实例中传入age参数
        self.language = "chinese"
    def talk(self):
        print("我说的是普通话！！")
        Person.talk(self)
obj = Chinese("nancy",'18','male',"普通话")
print(obj.name)  # 对应场景A
print(obj.age)  # 对应场景B
print(obj.language)  # 对应场景C
obj.talk()  # 对应场景D
# 总结：
# A:若父类中初始化了成员变量，子类调用父类构造方法未覆盖属性（self.name），则调用子类属性时取值为父类中初始化的成员变量；
# B:若父类中初始化了成员变量，若子类调用父类构造方法覆盖属性（self.age）则取值为子类实例中传入参数
# C:若父类未初始化该成员变量，则无论子类中有无进行对父类构造方法进行属性的覆盖，均取子类实例中传入的参数
# D:对于方法,如果子类有这个方法则直接调用，如果子类没有则去父类查找。父类没有则报错

3 继承原理

对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表。

>>> D.mro() # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置方法
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

python会在MRO列表上从左到右开始查找基类，直到找到第一个匹配这个属性的类为止，而这个MRO列表的构造是通过一个C3线性化算法来实现的。

实际上就是合并所有父类的MRO列表并遵循如下三条准则：

• 子类会先于父类被检查
• 多个父类会根据它们在列表中的顺序被检查
• 如果对下一个类存在两个合法的选择,选择第一个父

Python 中的 MRO —— 方法搜索顺序

Python中针对类提供了一个内置属性 mro 可以查看方法搜索顺序

MRO 是 method resolution order，主要用于在多继承时判断方法、属性 的调用路径。

print(C.__mro__)  #C是多继承后的类名

输出结果：

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

在搜索方法时，是按照 mro 的输出结果 从左至右 的顺序查找的；

如果在当前类中找到方法，就直接执行，不再搜索；如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索。

如果找到最后一个类，还没有找到方法，程序报错。

4 多继承属性查询顺序

（1）多继承结构为菱形结构

如果继承关系为菱形结构，那么经典类与新式类会有不同MRO。

箭头表示搜索顺序

（2）多继承结构为非菱形结构

会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性。

5 查找流程

① 由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去。

② 由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去。

主要知识点：类的__mro__ 属性的用法；

属性查找

有了继承关系，对象在查找属性时，先从对象自己的__dict__中找，如果没有则去子类中找，然后再去父类中找…..

class Foo:
    def f1(self):
        print('Foo.f1')
    def f2(self):
        print('Foo.f2')
        self.f1() 

class Bar(Foo):
    def f1(self):
        print('Bar.f1')
b=Bar()
b.f2()
# 运行结果：
Foo.f2
Bar.f1
# 运行流程分析：
b.f2()会在父类Foo中找到f2，先打印Foo.f2,然后执行到self.f1(),即b.f1()，仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去，在类Bar中找到f1，因而打印结果为Bar.f1

父类如果不想让子类覆盖自己的方法，可以采用双下划线开头的方式将方法设置为私有的：

class Foo:
    def __f1(self): # 变形为_Foo__f1
        print('Foo.f1') 
    def f2(self):
        print('Foo.f2')
        self.__f1() # 变形为self._Foo__f1,然后回到Bar类中找，没有，再到Foo中找到了
class Bar(Foo):
    def __f1(self): # 变形为_Bar__f1
        print('Bar.f1')
b=Bar() # Bar类处于执行阶段，_Bar__f1变为__f1
b.f2() # 在父类中找到f2方法，进而调用b._Foo__f1()方法，是在父类中找到的f1方法

# 运行结果：
Foo.f2
Foo.f1

6 继承概念的实现

方式主要有2类：

• 实现继承
• 接口继承

① 实现继承是指使用基类的属性和方法而无需额外编码的能力。

② 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。

例如：Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类，但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

7 私有属性私有方法在继承中的表现

父类中的私有方法和私有属性都是不能被子类继承下来的；

测试示例：父类中的私有属性和私有方法是否能被继承下来？

class Perpon:
    num = 20
    __num1 = 12
    def __test1(self):
        print('__test1....')
    def test2(self):
        print('test2...')
class Student(Perpon):
    def test(self):
        print('num...')
        print(self.num)
        # print(Student.__num1)
        self.test2()
        # self.__test1()
 
student = Student()
student.test()
student.test2()
# student.__test1() # 报错
'''
num...
20
test2...
test2...
'''

8 派生类

1）在父类的基础上产生子类，产生的子类就叫做派生类

2）父类里没有的方法，在子类中有了，这样的方法就叫做派生方法。

3）父类里有，子类也有的方法，就叫做方法的重写（就是把父类里的方法重写了)

class Hero:
    def __init__(self, nickname,aggressivity,life_value):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value
    def attack(self, enemy):
        print('Hero attack')
class Garen(Hero):
    camp = 'Demacia'
    def attack(self, enemy): #self=g1,enemy=r1
        # self.attack(enemy) #g1.attack(r1)，这里相当于无限递归
        Hero.attack(self,enemy)  # 引用 父类的 attack，对象会去跑 父类的 attack
        print('from garen attack')  # 再回来这里
    def fire(self):
        print('%s is firing' % self.nickname)
class Riven(Hero):
    camp = 'Noxus'
g1 = Garen('garen', 18, 200)
r1 = Riven('rivren', 18, 200)
g1.attack(r1)
# print(g1.camp)
# print(r1.camp)
# g1.fire()

9 属性的覆盖（派生属性）

子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类）；

需要注意的是：一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了(属性的覆盖)。

示例：

# 派生属性: 子类中自己添加的新属性
# 属性的覆盖: 子类和父类有相同属性,调用自己的
class Perpon:
    num = 20
    def __init__(self, name):
        print('person...')
class Student(Perpon):
    num = 10  # 把父类中的20覆盖
    def __init__(self, name, age):  # age 为派生属性
        super().__init__(name)
        self.name = name
        self.age = age
        print('student...')
    def study(self):
        print(super().num)
        pass
student = Student('赵四', 23)
print(student.name) # person...
print(student.age)
print(student.num)
student.study()
'''
person...
student...
赵四
23
10
20
'''

10 父类属性（方法）的重用

指名道姓的重用

class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        A.__init__(self)
class C(A):
    def __init__(self):
        print('C的构造方法')
        A.__init__(self)
class D(B,C):
    def __init__(self):
        print('D的构造方法')
        B.__init__(self)  # 先找到B，B调用A，等这个线性任务处理完之后，在继续下一行代码
        C.__init__(self)  # 先找到C，C里面也调用A的方法
    pass
f1=D()  #A.__init__被重复调用
'''
D的构造方法
B的构造方法
A的构造方法
C的构造方法
A的构造方法
'''

Super()方法重用

class A:
    def __init__(self):
        print('A的构造方法')
class B(A):
    def __init__(self):
        print('B的构造方法')
        super(B,self).__init__()
class C(A):
    def __init__(self):
        print('C的构造方法')
        super(C,self).__init__()
class D(B,C):
    def __init__(self):
        print('D的构造方法')
        super().__init__()  # super(D,self).__init__()
f1=D() #super()会基于mro列表,往后找
'''
D的构造方法
B的构造方法
C的构造方法
A的构造方法
'''
# super() 语法
# super(type[, object-or-type])   type 当前类，object-or-type 为实例化对象，一般默认为self,不过该参数在python3中默认

super（）是一个特殊的类，调用super得到一个对象，该对象指向父类的名称空间。

派生与继承解决问题：子类重用父类的属性，并派生出新的属性。

注意：使用哪一种都可以，但不能两种方式混合使用！

11 继承派生机制的作用

可以将一些共用的功能加在基类中,实现代码的共享；

在不改变基类的基础上改变原有的功能；

练习：

list类里只有append向末尾加一个元素的方法,但没有向列表头部添加元素的方法，试想能否为列表在不改变原有功能的基础上添加一个inster_head(x)方法,此方法能在列表的前部添加元素？

class Mylist(list):
    def insert_head(self,x):
        # self.reverse()
        # self.append(x)
        # self.reverse()
        self.insert(0,x)  #直接在最开始插入x
myl = Mylist(range(3,6))
print(myl)      #[3.4.5]
myl.insert_head(2)
print(myl)      #[2,3,4,5]
myl.append(6)
print(myl)      #[2,3,4,5,6]

12 Super()

super(cls,obj)返回被绑定超类的实例(要求obj必须为cls类型的实例)

super() 返回被绑定超类的实例,等同于:super(class,实例方法的第一个参数,必须在方法内调用)

格式：

父类类名.方法名称(self) 或者 super().方法名称()或者super(本类类名,对象名)

作用：借助super()返回的实例间接调用父类的覆盖方法；

示例：

#此示例示意用super函数间接调用父类的
class A:
    def work(self):
        print('A.work被调用')
class B(A):
    '''B类继承子A类'''
    def work(self):
        print('B.work被调用')
    def super_work(self):
        #调用b类自己的work方法
        self.work()
        #调用父类的work
        super(B,self).work()
        super().work()  #此种调用方式只能在实例方法内调用
b = B()
# b.work()            #B.work被调用!!
# super(B,b).work()   #A.work被调用
b.super_work()
# super_work()   #出错

调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且继承顺序严格遵循mro继承序列；

示例：

class Father1:
    x =10
    pass
class Father2:
    x = 20
    pass
#多继承的情况下，从左到右
class Sub(Father1,Father2):
    def __init__(self):   #注意__int__不是__init__
        print(super().__delattr__)
print(Sub.mro())   # [<class '__main__.Sub'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class 'object'>]
obj = Sub()
print(object)   #<class 'object'>

mro()：会把当前类的继承关系列出来，严格按照mro列表的顺序往后查找

class A:        #默认继承object
    def test(self):
        print('from A.test')
        super().test()
class B:
    def test(self):
        print('from B.test')
class C(A, B):
    pass
c = C()
#检查super的继承顺序
#mro(): 会把当前类的继承关系列出来。
print(C.mro()) #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
c.test()    #from A.test
            #from B.test

使用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)
 
'''结果如下：
(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)
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方法，只需写一句话便执行了全部父类的方法。

这也是为何多继承需要全部传参的一个原因

练习一

子类调用自己的方法的时候同时调用父类的方法

class Dog(Animal):
    def sleep(self):
        # 方法一 父类.方法名(对象)
        # Animal.eat(self)
        # 方法二 super(子类,对象名).方法名()
        super(Dog,dog).sleep()
        print('去狗窝')
    def look_door(self):
        print('看门狗')
dog = Dog('哈巴狗',23)
dog.sleep() 
'''
睡觉
去狗窝
'''

练习二

在类的外部调用super()

# 类外部调用super()
dog = Dog('哈巴狗', 23)
super(Dog, dog).sleep() # super(子类,对象名).方法名()
dog.sleep()
'''
睡觉
去狗窝
'''