亲宝软件园·资讯

展开

python 继承与派生

​ Python编程学习圈   ​ 人气:0

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。

所以上面的打印结果如此,要仔细分析执行过程。

重点提示:

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

练习一

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

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()
'''
睡觉
去狗窝
'''

加载全部内容

相关教程
猜你喜欢
用户评论