继承的相关知识点和语法

已于 2022-06-22 20:04:28 修改
阅读量100 收藏
点赞数 1
文章标签： python 开发语言
于 2022-06-18 00:41:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cailirong123/article/details/125342245
版权

文章目录

292_了解继承

课程：面向对象 — 继承
目标

  • 继承的概念
  • 单继承
  • 子类重写父类的同名属性和方法
  • 子类调用父类的同名属性和方法
  • 多层继承
  • super()
  • 私有属性和私有方法
    一、继承的概念
    生活中的继承，一般指的是子女继承父辈的财产。

293_拓展经典类和新式类

  • 拓展1：经典类或旧式类
    不由任意内置类型派生出的类，称之为经典类。
class 类名：
	代码
	.....
  • 拓展2：新式类
class 类名（object）:
	代码

294_体验继承

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：

#父类
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

子类默认继承父类的所有属性和方法，代码实现如下所示：

#继承：子类默认继承父类的所有属性和方法
#1.定义父类
class A(object):
    def __init__(self):
        self.num = 1

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

#定义子类，继承父类
class B(A):
    pass

#3.创建对象，验证结论
result = B()
result.info_print()

子类默认继承父类的所有属性和方法
运行结果：
运行结果
总结：在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

295_单继承

二、单继承
故事主线：一个煎饼果子老师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师父要把这套技术传授给他的唯一的最得意的徒弟。
分析：徒弟是不是要继承师父的所有技术？

#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)

单继承方法的实现，代码显示如下所示：

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#2.定义徒弟类，继承师父类
class Prentice(Master):
    pass

#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

单继承方法的实现
运行结果：
运行结果

296_多继承

三、多继承
故事推进：daqiu是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，在百度搜素到黑马程序员，报班学习煎饼果子技术。
所谓多继承意思就是一个类同时继承了多个父类。

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类
class Prentice(School,Master):
    pass

#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法

多继承实例实现，代码展示情况
运行结果：
运行结果
总结：当一个类有多个父类时候，默认使用第一个父类的同名属性和方法。

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

四、子类重写父类同名方法和属性
故事：daqiu掌握了师父和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

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


#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

子类重写父类同名属性和方法，代码展示情况
运行结果：
运行结果

298_拓展_mro顺序

print(类名.mro):查看某个类的父类以及这个类的继承关系。

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

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


#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

查看某个类的父类以及这个类的继承关系，代码展示情况
运行结果：
运行结果

299_子类调用父类同名方法和属性之思路分析

五、子类调用父类的同名方法和属性
故事：很多顾客都希望也能吃到古法和黑马的技术的煎饼果子。

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)

	self make_School_cake(self):
		School.__init__(self)
		School.make_cake(self)

300_子类调用父类同名方法和属性之代码实现

子类调用父类同名方法和属性之代码实现,情况如下所示：

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)


#3.用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

daqiu.make_master_cake()
daqiu.make_school_cake()

daqiu.make_cake()
print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

子类调用父类同名方法和属性之代码实现
运行结果：
运行结果

301_多层继承

六、多层继承
故事：N年后，daqiu老了，象牙把所有技术传承给自己的徒弟。

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)


#3.用徒弟类创建对象，调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

#步骤：1.创建徒孙类Tusun，然后用这个类创建对象；2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
    pass

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

多层继承调用父类的属性和方法
运行结果：
运行结果

302_super()方法作用

七、super()调用父类方法

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(object):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School,Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用school类和master类两个父类的方法
    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要跟着修改，麻烦；代码量庞大，冗余。
        School.__init__(self)
        School.make_cake(self)
        Master.__init__(self)
        Master.make_cake(self)

daqiu = Prentice()
daqiu.make_old_cake()


#3.用徒弟类创建对象，调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

#步骤：1.创建徒孙类Tusun，然后用这个类创建对象；2.用这个对象调用父类的属性或方法看能否成功
# class Tusun(Prentice):
#     pass
#
# xiaoqiu = Tusun()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()

原始方法实现一次性调用两个父类的代码实现
运行结果：
运行结果

303_super方法写法

带参数的super()方法调用父类的方法，代码实现如下所示：

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

        #2.1 super()带参数写法
        super(School,self).__init__()
        super(School,self).make_cake()

#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用school类和master类两个父类的方法
    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要跟着修改，麻烦；代码量庞大，冗余。
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)

        #方法二：super()
        #2.1 super(当前类名，self).函数（）
        super(Prentice,self).__init__()
        super(Prentice,self).make_cake()

daqiu = Prentice()
daqiu.make_old_cake()

school类调用父类master()中的方法
prentice类调用父类school类中的属性和方法
运行结果：
运行结果
不带参数的super()方法调用父类的方法，代码实现如下所示：

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

        #2.1 super()带参数写法
        #super(School,self).__init__()
        #super(School,self).make_cake()

        #2.2 无参数的super()
        super().__init__()
        super().make_cake()


#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用school类和master类两个父类的方法
    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要跟着修改，麻烦；代码量庞大，冗余。
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.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()


#3.用徒弟类创建对象，调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

#步骤：1.创建徒孙类Tusun，然后用这个类创建对象；2.用这个对象调用父类的属性或方法看能否成功
# class Tusun(Prentice):
#     pass
#
# xiaoqiu = Tusun()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()

不带参数的super()方法调用父类的方法
运行结果：
运行结果
总结：使用super()可以自动查找父类。调用顺序遵循__mro__类属性的顺序。比较适合单继承使用。

304_定义私有属性和方法

八、私有权限
8.1 定义私有属性和方法
在python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。
故事：daqiu把技术传承给徒弟的同时，不想把自己的钱（20000个亿）继承给徒弟，这个时候就要为钱这个实例属性设置私有权限。
设置私有权限的方法：在属性名和方法名前面加上两个下划线__.

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

        #2.1 super()带参数写法
        #super(School,self).__init__()
        #super(School,self).make_cake()

        #2.2 无参数的super().函数()
        super().__init__()
        super().make_cake()


#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        #self.money = 200000
        #定义私有属性
        #self.__money = 2000000    #此处的money为私有属性

        #定义私有方法
    def __info_print(self):
            print('这是私有方法')#子类无法从父类那里继承的方法


    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用school类和master类两个父类的方法
    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要跟着修改，麻烦；代码量庞大，冗余。
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.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()


#3.用徒弟类创建对象，调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

#步骤：1.创建徒孙类Tusun，然后用这个类创建对象；2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
     pass
#
xiaoqiu = Tusun()
#print(xiaoqiu.money)
xiaoqiu.info_print()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()

定义私有属性和方法，子类无法继承
运行结果：
运行结果
注意：私有属性和私有方法只能在类里面访问和修改。

305_获取和修改私有属性值

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

#1.师父类，属性和方法
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

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

#为了验证多继承，添加school父类
class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

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

        #2.1 super()带参数写法
        #super(School,self).__init__()
        #super(School,self).make_cake()

        #2.2 无参数的super().函数()
        super().__init__()
        super().make_cake()


#2.定义徒弟类，继承师父类  和  学校类，添加和父类同名的属性和方法
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'
        #self.money = 200000
        #定义私有属性
        self.__money = 2000000    #此处的money为私有属性

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

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

        #定义私有方法
    def __info_print(self):
            print('这是私有方法')#子类无法从父类那里继承的方法


    def make_cake(self):
        #此处加自己初始化的原因是：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        #父类类名.函数（）
        #再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 父类类名.函数（）
        # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init进行初始化
        School.__init__(self)
        School.make_cake(self)

    #需求：一次性调用school类和master类两个父类的方法
    def make_old_cake(self):
        #方法一：如果定义的类名修改，这里也要跟着修改，麻烦；代码量庞大，冗余。
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.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()


#3.用徒弟类创建对象，调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论：如果一个类继承多个父类，优先继承第一个弗雷德同名属性和方法
#总结：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

#步骤：1.创建徒孙类Tusun，然后用这个类创建对象；2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
     pass
#
xiaoqiu = Tusun()
print(xiaoqiu.get_money())

xiaoqiu.set_money()
print(xiaoqiu.get_money())

#xiaoqiu.info_print()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()

类的里面获取和修改私有属性值，代码实现展示情况
运行结果：
运行结果

306_继承总结

九、总结

  • 继承的特点
    • 子类默认拥有父类的所有属性和方法
    • 子类重写父类同名方法和属性
    • 子类调用父类同名方法和属性
  • super()方法快速调用父类方法
  • 私有权限
    • 不能继承给子类的属性和方法需要添加私有权限
    • 语法
class 类名（）
	#私有属性
	__属性名 = 值

	#私有方法
	def __函数名（self）:
		代码
陌上花开，静待绽放！
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
常用的函数代码编写
weixin_42648229的博客
11-01 2718
#include<stdio.h> //将内存里面的数据进行移动 void move_buf(int *source, int *dest, int len) { //先判断源和目的地址是否有交集 if (source + len > dest) { while (len--) { dest[len] = source[len]; //则从后往前进行复制，...
代码函数调用关系图
热门推荐
V__KING__的专栏
09-08 1万+
代码函数调用关系 Graphviz + CodeViz http://www.linuxidc.com/Linux/2015-01/111501.htm Callgraph ：静态分析 C 程序函数调用关系图cflow+graphviz +tree2dotx http://www.tinylab.org/callgraph-draw-the-calltree-of-c-functions/
函数式编程
weixin_40544320的博客
05-25 162
Scala让你以面向对象的风格，函数式的风格，或两者混合的风格 来写代码。 函数式编程是一种编程风格，只用纯函数和不可变值来写程序。这是一个很大的话题，很难一下全部说清，下面的部分带你稍微看一下FP,并看看Scala是提供了怎样的工具给开发者来进行函数式编程。 纯函数 Scala提供的帮助你写函数式代码的第一个特性就是写纯函数的能力，有人定义纯函数是： 函数的输出只取决于它的输入值 它不会改变任何隐藏的状态 它没有任何“后门”：它不从外部世界（包括命令行，web服务器，数据库，文件等）读数据，或写数据带外
函数编程代码例子_使用函数式编程使代码更易于阅读
cumian8165的博客
07-21 490
函数编程代码例子Discover Functional JavaScript was named one of the best new Functional Programming books by BookAuthority! “发现功能JavaScript”被BookAuthority评为最佳新功能编程书籍之一 ！ Pure functions are easier to read and...
Python中的函数编写示例代码
昊虹AI笔记
06-23 458
Python中的函数编写示例代码。
java7钻石语法知识点总结
08-25
除了钻石语法，Java 7的Coin项目还包含其他改进，例如方法的多重继承（通过默认方法实现）以及静态导入等。这些改变旨在提升Java语言的简洁性和效率。然而，钻石语法可能是对日常编码影响最大的一项改进，因为它直接...
java相关知识点说明
05-28
线程同步机制包括synchronized关键字、wait()、notify()和notifyAll()方法，以及Lock接口和相关实现。 10. **网络编程**：Java提供了Socket和ServerSocket类进行网络通信，支持TCP/IP协议。还可以使用URL和...
python相关知识点说明
05-28
Python是一种高级编程语言，以其简洁明了的语法和强大的功能深受程序员喜爱。在这个"python相关知识点说明"中，我们将深入探讨Python的基础概念、语法特性、数据结构、控制流程、函数和模块，以及错误与异常处理等多...
CPP.rar_C 知识点
09-23
本文将深入探讨C++的重要知识点，这些知识点对于程序员的面试准备和实际工作都非常关键。 1. **基础语法**：C++的基础语法包括变量定义、数据类型（如int、char、float、double等）、运算符（如算术、比较、逻辑、...
java各个技术栈相关知识点
05-23
在Java各个技术栈中，涵盖了许多关键的知识点，包括基础语法、面向对象编程、集合框架、多线程、网络编程、I/O流、数据库操作、异常处理、反射机制、垃圾回收等。下面将对这些知识点进行详细阐述。 1. **基础语法**...
继承及其基本语法
QQ960054653的博客
03-08 627
一、类与类的关系 has-A，uses-A 和 is-A has-A    ：包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。 uses-A ： 一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友员或对象参数传递实现。 is-A      ： 机制称为“继承”。关系具有传递性,不具有对称性。 二、
皮尔逊相关系数及代码实现（C语言+MATLAB）
m0_64770246的博客
07-09 9823
皮尔逊相关系数，常用于度量两个变量X和Y之间的线性相关性。本文通过介绍其概念定义、数学公式，进而引出其适用场合，并基于MATLAB和C语言对皮尔逊相关系数分别进行了代码实现。
如何写好代码中的函数？
我的天空 我的梦
01-16 1378
谈谈如何写好函数
理解调用函数的代码
weixin_50438339的博客
09-26 495
#include "stdio.h" int max(int x,int y) { int t,max; if(x<y) {t=x;x=y;y=t;} max=x; printf("在调用函数中x,y的值为:x=%d,y=%d\n"x,y); return max; } main() { int x,y,mm; printf("请输入x,y的值:"); scanf("%d,%d",&x,&y); printf("调用函数前x,y的值为x=%d,y=%d\n"x,y); mm=max(x
用函数实现几个经典代码
weixin_34112208的博客
03-18 141
1.用一个函数实现，判断一个数是不是素数#include<stdio.h> #include<math.h> voidfun(intx) { inti; if(x<=2) printf("thenumberisprime\n"); else { for(i=2;i<sqrt(x);i+=2) { if(...
机器学习常用包numpy篇（零）前置知识·数值类型
2301_79144343的博客
08-14 382
本文仅介绍numpy中的数值类型
【Python】入门到放弃之第九章《字典》
最新发布
MP13537560060的博客
08-15 651
这是本系列的第九章节内容，《字典》。在Python中，字典（Dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，意味着你可以在创建字典后添加、删除或修改其中的元素。字典的键（key）必须是唯一的，并且是不可变的（即，它们必须是不可变数据类型，如字符串、数字或元组，但不能是列表或字典等可变类型）。字典的值（value）则可以是任何数据类型，包括列表、元组、字典等。以上，就是Python中字典的全部内容。
【python学习】深入解析 `jq` 库：JSON 处理的利器
m0_54007171的博客
08-13 420
jq库是 Python 对流行的命令行工具jq的封装。它允许你直接在 Python 中使用jq的查询语言来处理 JSON 数据。借助jq，你可以轻松地对 JSON 数据进行过滤、选择、转换、聚合等操作，极大地简化了代码复杂度。
c++类的继承考研常见知识点
07-11
了解多重继承的语法和使用方法。 4. 虚函数和纯虚函数：虚函数是在基类中使用virtual关键字声明的函数，它可以在派生类中被重写。纯虚函数是在基类中使用纯虚函数声明的函数，它没有函数体，必须在派生类中被实现。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陌上花开，静待绽放！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值