Python全栈开发实战学习14

最新推荐文章于 2024-04-30 19:55:17 发布

Fly-U

最新推荐文章于 2024-04-30 19:55:17 发布

阅读量184

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/weixin_42324313/article/details/88054994

版权

Python 专栏收录该内容

37 篇文章 2 订阅

订阅专栏

继承与派生

初识继承

什么是继承？

继承是指类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题。
继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，新建的类称为派生类或子类。

python中类的继承分为：单继承和多继承

class ParentClass1: # 定义父类
    pass
class ParentClass2: # 定义父类
    pass
class SubClass1(ParentClass1): # 单继承，基类是ParentClass1，派生类是SubClass
    pass
class SubClass2(ParentClass1,ParentClass2): # python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承

print(SubClass1.__bases__)
print(SubClass2.__base__)   # __base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
print(SubClass2.__bases__

结果
(<class '__main__.ParentClass1'>,)
<class '__main__.ParentClass1'>
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

经典类与新式类(关于新式类与经典类的区别，稍后讨论)

1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.在python2中，没有显式地继承object类的类，以及该类的子类，都是经典类
3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
4.在python3中，无论是否继承object，都默认继承object，即python3中所有类均是新式类

提示：如果没有指定积累，那么python的类会默认继承object类，object是所有python类的基础，它提供了一些常见方法(如_str_)的实现

继承与抽象

抽象即抽取类似或者说比较像的部分
抽象分为两个层次:

将奥巴马和梅西这俩个对象比较像的部分抽取成类
将人、猪、狗这三个类比较像的部分抽取成父类

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）
在这里插入图片描述

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构

继承与重用性

在定义A类后，又想定义B类，并且B类大部分内容与A类相同时，我们可以通过继承的方式新建B类，让B类继承A，B会继承A的所有属性，实现代码重用。

class hero:
    def __init__(self,nickname,hp,aggr):
        self.nickname = nickname
        self.hp = hp
        self.aggr = aggr
    def attack(self,enemy):
        enemy.hp -= self.aggr
class Garen(hero):      # 继承了hero类
    pass
class Riven(hero):		# 继承了hero类
    pass

garen = Garen('噶文',1000,300)
riven = Riven('瑞文',1000,120)

print(garen.hp)      # 1000
riven.attack(garen)  # riven攻击garen
print(garen.hp)      # 880

再看属性查找

在上述代码中，像garen.hp之类的属性引用，会先从实例中找hp，然后从类中去找，然后再去父类中查找，直到最顶级的父类。那么如何解释下述的打印结果呢？

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

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

b = Bar()
b.f2()


打印结果
Foo.f2
Foo.f1

个人解释：我认为是b实例化时并未调用 f1，只是记录了地址，当b.f2() 调用时，现在实例中查找，此时b中只有f1，所以到Bar类中查找，仍未找到，然后到父类Foo中查找，找到f2，调用并打印“Foo.f2”，后面还有self.f1()，继续调用并打印“Foo.f1”

派生

子类可以添加自己新的属性或在自己这里重新定义这些属性，不会影响到父类，一旦重新定义了自己的属性且与父类重名，那么调用新增属性时就以自己为准了。

class hero:
    def __init__(self,nickname,hp,aggr):
        self.nickname = nickname
        self.hp = hp
        self.aggr = aggr
    def attack(self,enemy):
        enemy.hp -= self.aggr

class Riven(hero):
    camp = 'Noxus'
    def attack(self,enemy):# 在自己这里定义新的attack，不再使用父类的attack，且不会影响父类
        print("from riven")
    def fly(self): # 在自己这里新定义的属性
        print('%s is flying' % (self.nickname))

在子类中，新建的重名的函数属性，在编辑函数内功能的时候，有可能需要重用父类的那个函数功能，应该是调用普通函数的方式，即：类名.func()，此时就与调用普通函数无异了，因此便是self参数也要为其传值

class hero:
    def __init__(self,nickname,hp,aggr):
        self.nickname = nickname
        self.hp = hp
        self.aggr = aggr
    def attack(self,enemy):
        enemy.hp -= self.aggr
class Garen(hero):
    pass
class Riven(hero):
    camp = 'Noxus'
    def __init__(self,nickname,hp,aggr,skin):
        hero.__init__(self,nickname,hp,aggr)  # 调用父类功能
        self.skin = skin   #新定义的属性
    def attack(self,enemy):# 在自己这里定义新的attack，不再使用父类的attack，且不会影响父类
        hero.attack(self,enemy)
        print("from riven")
    def fly(self):
        print('%s is flying' % (self.nickname))
# garen = Garen('噶文',1000,300)
riven = Riven('瑞文',1000,120,'比基尼')

riven.fly()           # 瑞文 is flying
print(riven.skin)	  # 比基尼

继承的实现原理

python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序表，例如

print(hero.mro())     # [<class '__main__.hero'>, <class 'object'>]
print(Riven.mro())   # [<class '__main__.Riven'>, <class '__main__.hero'>, <class 'object'>]

MRO列表遵循三条准则：

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

示范代码

class A:
    def test(self):
        print('from A')
class B(A):
    def test(self):
        print('from B')
class C(A):
    def test(self):
        print('from C')
class D(B):
    def test(self):
        print('from D')
class E(C):
    def test(self):
        print('from E')
class F(D,E):
    def test(self):
        print('from F')
f1 = F()
f1.test()
print(F.mro())  # 只有在新式类中才有这个属性可以查看线性列表，经典类没有这个属性


*****
结果
from F
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
*****

# 新式类继承顺序：F->D->B->E->C->A
# 经典类继承顺序：F->D->B->A->E->C
# python3 中统一都是新式类
# python2 中才分新式类和经典类

在子类中调用父类的方法

方法一：指名道姓，即父类名.父类方法()

class hero:
    def __init__(self,nickname,hp,aggr):
        self.nickname = nickname
        self.hp = hp
        self.aggr = aggr
    def attack(self,enemy):
        enemy.hp -= self.aggr
class Garen(hero):
    pass
class Riven(hero):
    camp = 'Noxus'
    def __init__(self,nickname,hp,aggr,skin):
        hero.__init__(self,nickname,hp,aggr)  # 调用父类功能
        self.skin = skin   #新定义的属性

方法二：super()

class hero:
    def __init__(self,nickname,hp,aggr):
        self.nickname = nickname
        self.hp = hp
        self.aggr = aggr
    def attack(self,enemy):
        enemy.hp -= self.aggr
class Garen(hero):
    pass
class Riven(hero):
    camp = 'Noxus'
    def __init__(self,nickname,hp,aggr,skin):
    	# super(Riven,self)就相当于实例本身 ，在python3中super()等同于super(Riven,self)
        super().__init__(nickname,hp,aggr)  # 调用父类功能，注意没有self
        self.skin = skin   #新定义的属性

区别：方式一跟继承没有关系，方式二是依赖继承的，并且即使没有直接继承关系，super仍然会按照mro继续向后查找。

class A:
    def test(self):
        super().test()
class B:
    def test(self):
        print('from B')
class C(A,B):
    pass

c = C()   
c.test()   # from B
print(C.mro())   #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

Fly-U

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python全栈开发实战学习14

继承与派生初识继承什么是继承？继承是指类与类之间的关系，是一种什么“是”什么的关系，继承的功能之一就是用来解决代码重用问题。继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，父类又可以成为基类或超类，新建的类称为派生类或子类。python中类的继承分为：单继承和多继承class ParentClass1: # 定义父类 passclass Par...
复制链接

扫一扫

专栏目录