python面向对象-继承

在Python中，所有类默认继承object类，object类是*类或基类；其他子类叫做派生类。

单继承

# 父类
class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')
# 子类
class tudi(shi):
    pass

# 创建对象
xiaoer=tudi()
print(xiaoer.n)
xiaoer.a()

结果

多继承

# 父类
class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类
class tudi1(shi,dashen):
    pass

# 创建对象
xiaoer=tudi1()
print(xiaoer.n)
xiaoer.a()

class tudi2(dashen,shi):
    pass

xuesheng=tudi2()
print(xuesheng.n)
xuesheng.a()




# 当⼀个类有多个父类的时候，默认使⽤用第⼀个父类的同名属性和方法。

结果

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

class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')
xuesheng=tudi2()
print(xuesheng.n)
xuesheng.a()
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

结果

查看继承关系

class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类
# class tudi1(shi,dashen):
#     pass
#
# # 创建对象
# xiaoer=tudi1()
# print(xiaoer.n)
# xiaoer.a()

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')
xuesheng=tudi2()
print(xuesheng.n)
xuesheng.a()
# 查找继承关系
print(tudi2.__mro__)

结果

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

class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类
# class tudi1(shi,dashen):
#     pass
#
# # 创建对象
# xiaoer=tudi1()
# print(xiaoer.n)
# xiaoer.a()

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
    def a(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，属性值是上一次调用的init内的属性值
        self.__init__()
        print(f'武功要想天下第一就得炼{self.n}')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def dashendewugong(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        dashen.__init__(self)
        dashen.a(self)
    def shifudewugong(self):
        shi.__init__(self)
        shi.a(self)

xuesheng=tudi2()
xuesheng.a()
xuesheng.shifudewugong()
xuesheng.a()
# 查找继承关系
#print(tudi2.__mro__)
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

结果

多层继承

class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
    def a(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，属性值是上一次调用的init内的属性值
        self.__init__()
        print(f'武功要想天下第一就得炼{self.n}')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def dashendewugong(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        dashen.__init__(self)
        dashen.a(self)
    def shifudewugong(self):
        shi.__init__(self)
        shi.a(self)

# 徒孙类，多层继承，当有一天徒弟也老了，需要把武功传给孙子了
class tusun(tudi2):
    pass

# 创建对象
dianfengshike=tusun()

dianfengshike.shifudewugong()
dianfengshike.a()
dianfengshike.dashendewugong()
# 查找继承关系
#print(tudi2.__mro__)
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

super()调用父类方法

# 父类
class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
    def a(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，属性值是上一次调用的init内的属性值
        self.__init__()
        print(f'武功要想天下第一就得炼{self.n}')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def dashendewugong(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        dashen.__init__(self)
        dashen.a(self)
    def shifudewugong(self):
        shi.__init__(self)
        shi.a(self)

    # 需求：一次性调用父类dashen shi的方法
    def ronghe(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # dashen.__init__(self)
        # dashen.a(self)
        # shi.__init__(self)
        # shi.a(self)


        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(tudi2, self).__init__()
        # super(tudi2, self).a()
        # 2.2 无参数super
        super().__init__()
        super().a()


# 徒孙类，多层继承，当有一天徒弟也老了，需要把武功传给孙子了
class tusun(tudi2):
    pass

# 创建对象
dianfengshike=tusun()


dianfengshike.ronghe()
# 查找继承关系
# print(tudi2.__mro__)
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

注意：使用super() 可以自动查找父类。调用顺序遵循 mro 类属性的顺序。比较适合单继承 使用。

定义私有属性和私有方法

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

# 父类
class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
        # 定义私有属性
        self.__money=100000000
    def a(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，属性值是上一次调用的init内的属性值
        self.__init__()
        print(f'武功要想天下第一就得炼{self.n}')


    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def dashendewugong(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        dashen.__init__(self)
        dashen.a(self)
    def shifudewugong(self):
        shi.__init__(self)
        shi.a(self)

    # 需求：一次性调用父类dashen shi的方法
    def ronghe(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # dashen.__init__(self)
        # dashen.a(self)
        # shi.__init__(self)
        # shi.a(self)


        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(tudi2, self).__init__()
        # super(tudi2, self).a()
        # 2.2 无参数super
        super().__init__()
        super().a()


# 徒孙类，多层继承，当有一天徒弟也老了，需要把武功传给孙子了
class tusun(tudi2):
    pass

# 创建对象
dianfengshike=tusun()


# dianfengshike.__money
dianfengshike.__info_print()


# 查找继承关系
# print(tudi2.__mro__)
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

获取和修改私有属性值

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

# 父类
class shi():
    def __init__(self):
        self.n='葵花宝典'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')

class dashen():
    def __init__(self):
        self.n='降龙十八掌'
    def a(self):
        print(f'武功要想天下第一就得炼{self.n}')


# 子类

class tudi2(dashen,shi):
    def __init__(self):
        self.n='吸星大法'
        # 定义私有属性
        self.__money=100000000

    # 定义函数：获取私有属性值 get_xx
    def get_money(self):
        return self.__money

    # 定义函数：修改私有属性值 set_xx
    def set_money(self):
        self.__money=20


    def a(self):
        # 加自己的初始化的原因：如果不加这个自己的初始化，属性值是上一次调用的init内的属性值
        self.__init__()
        print(f'武功要想天下第一就得炼{self.n}')


    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def dashendewugong(self):
        # 父类类名.函数()
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
        dashen.__init__(self)
        dashen.a(self)
    def shifudewugong(self):
        shi.__init__(self)
        shi.a(self)

    # 需求：一次性调用父类dashen shi的方法
    def ronghe(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # dashen.__init__(self)
        # dashen.a(self)
        # shi.__init__(self)
        # shi.a(self)


        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(tudi2, self).__init__()
        # super(tudi2, self).a()
        # 2.2 无参数super
        super().__init__()
        super().a()


# 徒孙类，多层继承，当有一天徒弟也老了，需要把武功传给孙子了
class tusun(tudi2):
    pass

# 创建对象
dianfengshike=tusun()


print(dianfengshike.get_money())
dianfengshike.set_money()


print(dianfengshike.get_money())




# 查找继承关系
# print(tudi2.__mro__)
# 结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

本文地址：https://blog.csdn.net/lijiaming_99/article/details/107638976