python面向对象-继承用法详解

IT之一小佬

已于 2023-08-27 12:49:24 修改

阅读量1.8k

点赞数 3

分类专栏： python基础文章标签： python 面向对象编程继承

于 2021-01-31 00:01:12 首次发布

本文链接：https://blog.csdn.net/weixin_44799217/article/details/113448445

版权

python基础专栏收录该内容

54 篇文章 26 订阅

订阅专栏

⼀、继承的概念

⽣活中的继承，⼀般指的是⼦⼥继承⽗辈的财产。

拓展 1 ：经典类或旧式类

不由任意内置类型派⽣出的类，称之为经典类。

class 类名:
   代码
   ......

拓展 2 ：新式类

class 类名(object):
   代码

Python ⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法，具体如下：

# ⽗类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)


# ⼦类B
class B(A):
    pass


result = B()
result.info_print()  # 1

在 Python 中，所有类默认继承 object 类， object 类是顶级类或基类；其他⼦类叫做派⽣类。

⼆、单继承

故事主线：⼀个煎饼果⼦⽼师傅，在煎饼果⼦界摸爬滚打多年，研发了⼀套精湛的摊煎饼果⼦的技术。师⽗要把这套技术传授给他的唯⼀的最得意的徒弟。

分析：徒弟是不是要继承师⽗的所有技术？

# 1. 师⽗类
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 2. 徒弟类
class Prentice(Master):
    pass


# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu)
# 5. 对象调⽤实例⽅法
daqiu.make_cake()

三、多继承

故事推进： daqiu 是个爱学习的好孩⼦，想学习更多的煎饼果⼦技术，于是，在百度搜索到⿊⻢程序员，报班学习煎饼果⼦技术。

所谓多继承意思就是⼀个类同时继承了多个⽗类。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    pass


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

运行效果：

注意：当⼀个类有多个⽗类的时候，默认使⽤第⼀个⽗类的同名属性和⽅法。

四、子类重写父类同名方法和属性

故事： daqiu 掌握了师⽗和培训的技术后，⾃⼰潜⼼钻研出⾃⼰的独⻔配⽅的⼀套全新的煎饼果⼦技术。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


# 独创配⽅
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)  # 查看继承关系

运行效果：

注意：⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法。

五、子类调⽤父类的同名方法和属性

故事：很多顾客都希望也能吃到古法和⿊⻢的技术的煎饼果⼦。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        # 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
        self.__init__()  # 此处没有写self,前面有self
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    # 调⽤⽗类⽅法，但是为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化
    def make_master_cake(self):
        Master.__init__(self)  # 此行代码相当于Master中的属性重置
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)  # 写self，为了能接收对象
        School.make_cake(self)


daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

运行效果：

六、多层继承

故事： N 年后， daqiu ⽼了，想要把所有技术传承给⾃⼰的徒弟。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

运行效果：

七、super()调用父类方法

示例代码1：

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(Master):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')
        # ⽅法2.1
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # ⽅法2.2
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦技术]'

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    # ⼦类调⽤⽗类的同名⽅法和属性：把⽗类的同名属性和⽅法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
        # ⼀次性调⽤⽗类的同名属性和⽅法

    def make_old_cake(self):
        # ⽅法⼀：代码冗余；⽗类类名如果变化，这⾥代码需要频繁修改
        # Master.__init__(self)
        # Master.make_cake(self)
        # School.__init__(self)
        # School.make_cake(self)
        # ⽅法⼆: super()
        # ⽅法2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # ⽅法2.2 super().函数()
        super().__init__()
        super().make_cake()


daqiu = Prentice()
daqiu.make_old_cake()

运行效果：

示例代码2：

class BaseClass(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def run(self):
        print(f"x:{self.x},y:{self.y}")


class SubClass(BaseClass):
    def __init__(self, x, y, z):
        # super().__init__(x, y)  # 父类中有传参，这儿也必须要传参
        super().__init__(x + 1, y + 1)  # 父类中有传参，这儿也必须要传参
        self.z = z

    def func(self):
        return self.x + self.y + self.z


class SubClass2(BaseClass):
    def __int__(self, x, y):
        super(SubClass2, self).run()


obj = SubClass(1, 2, 5)
obj.run()
res = obj.func()
print(res)

obj2 = SubClass2(66, 88)
obj2.run()

运行结果：

注意：使⽤super() 可以⾃动查找⽗类。调⽤顺序遵循 __mro__ 类属性的顺序。⽐较适合单继承使⽤。

示例代码3：

"""
1.super函数的作用:调用‘父类’的方法
2.什么场景下使用super函数：在代码重用的场景下
3.super函数的运行过程:正确的理解不是简单的调用一个类的父类，而是根据一个类中的mro顺序进行查询并调用
"""


class A:
    def __init__(self):
        print("A")


class B(A):
    def __init__(self):
        print("B")  # B
        # 方式一
        A.__init__(self)  # A
        # 方式二
        super().__init__()  # A


b = B()
# B
# A
# A

# 需要创建一个类，让类具有多线程执行的特征
import threading


# 可以重用线程类中定义的属性
class MyThread(threading.Thread):
    def __init__(self, thread_name, user):
        self.user = user
        # self.thread_name = thread_name
        super().__init__(name=thread_name)


class X:
    def __init__(self):
        print('X')


class Y(X):
    def __init__(self):
        print('Y')
        super().__init__()


class Z(X):
    def __init__(self):
        print('Z')
        super().__init__()


class O(Y, Z):
    def __init__(self):
        print('O')
        super().__init__()


o = O()
# O
# Y
# Z
# X
print(O.__mro__)  # (<class '__main__.O'>, <class '__main__.Y'>, <class '__main__.Z'>, <class '__main__.X'>, <class 'object'>)

运行结果：

八、私有属性

8.1 定义私有属性和方法

在 Python 中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类。

故事： daqiu 把技术传承给徒弟的同时，不想把⾃⼰的钱 (2000000 个亿 ) 继承给徒弟，这个时候就要为钱这个实例属性设置私有权限。

设置私有权限的⽅法：在属性名和⽅法名前⾯加上两个下划线 __。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'
        # 定义私有属性
        self.__money = 2000000

    # 定义私有⽅法
    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


daqiu = Prentice()
# 对象不能访问私有属性和私有⽅法
# print(daqiu.__money)
# daqiu.__info_print()
xiaoqiu = Tusun()
# ⼦类⽆法继承⽗类的私有属性和私有⽅法
# print(xiaoqiu.__money) # ⽆法访问实例属性__money
# xiaoqiu.__info_print()

注意：私有属性和私有⽅法只能在类⾥⾯访问和修改。

8.2 获取和修改私有属性值

在 Python 中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'
        self.__money = 2000000

    # 获取私有属性
    def get_money(self):
        return self.__money

    # 修改私有属性
    def set_money(self):
        self.__money = 500

    def __info_print(self):
        print(self.kongfu)
        print(self.__money)

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


daqiu = Prentice()
xiaoqiu = Tusun()
# 调⽤get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调⽤set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

运行效果：

8.3 其它

示例代码：

class Person:
    def __init__(self, name, money):
        self.name = name
        self.__money = money  # 私有属性

    # 在类的内部可以直接访问私有属性
    def get_money(self):
        print(self.__money)


person = Person('dgw', 10000)
person.get_money()  # 10000

"""
私有属性无法在一个类的内部使用
"""

# 私有属性在创建时会对当前属性的名称进行处理：_clsname__attrname,但不建议下述使用
print(person._Person__money)  # 10000

运行结果：

九、混合继承

示例代码：

class Animal:
    def __init__(self, name):
        self.name = name


class RunMixin:
    def run(self):
        print(f"{self.name}正在跑。。。")


class SwimMixin:
    def swim(self):
        print(f"{self.name}正在游泳。。。")


class FlyMixin:
    def fly(self):
        print(f"{self.name}正在飞。。。")


class Duck(Animal, RunMixin, SwimMixin, FlyMixin):
    pass


duck = Duck('鸭子')
duck.run()
duck.swim()
duck.fly()
# 鸭子正在跑。。。
# 鸭子正在游泳。。。
# 鸭子正在飞。。。

"""
当前的继承方式是一种混合继承
1.mixin功能是单一的
2.mixin类不继承其他的类（除了object）

mixin因为功能简单，并且没有复杂的继承关系，特别好管理
我们在去使用mixin的时候尽量避免在子类中使用super

django-rest-framework中经常使用到混合继承
"""

运行结果：

十、属性继承顺序

示例代码：

class A:
    name = "cls_name"

    def __init__(self):
        self.name = 'obj_name'


# 类中的属性的查找是从下往上查找的
a = A()
print(a.name)  # obj_name


# 菱形继承
class D:
    name = 'cls_d'


class B(D):
    name = 'cls_b'


class C(D):
    name = 'cls_c'


class X(B, C):
    pass


x = X()
print(x.name)  # cls_b
# 查看继承顺序关系
print(X.__mro__)  # (<class '__main__.X'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)


# 树形继承
class U:
    name = "cls_u"


class V:
    name = 'cls_v'


class W(U):
    # name = 'cls_w'
    pass


class Y(V):
    name = 'cls_y'


class Z(W, Y):
    pass


z = Z()
print(z.name)  # cls_u
# 查看继承顺序关系
print(Z.__mro__)  # (<class '__main__.Z'>, <class '__main__.W'>, <class '__main__.U'>, <class '__main__.Y'>, <class '__main__.V'>, <class 'object'>)

"""
注意菱形继承和树形继承的区别
"""

运行结果：