python学习笔记-继承

最新推荐文章于 2024-10-08 13:30:51 发布
最新推荐文章于 2024-10-08 13:30:51 发布
阅读量321 收藏
点赞数
分类专栏： # Python基础 文章标签： 开发语言 分类 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44653420/article/details/121578268
版权
本文介绍了Python中的继承概念，包括经典类与新式类的区别，单继承、多继承以及重写父类方法的实现。通过实例展示了如何创建子类并调用父类方法，同时讲解了如何处理同名属性和方法。此外，还探讨了私有属性的使用以及通过getter和setter方法修改私有属性。文章最后提到了`super()`函数的使用，以及如何在子类中调用父类的方法。
摘要由CSDN通过智能技术生成

python学习笔记-继承

1. 经典类与新式类

经典类：

Class 类名：
	代码

新式类：

Class 类名（object）:
	代码

Object:所有类的顶级类 ，括号里面可以是其他的父类

2. 继承的写法

子类默认继承父类所有的方法以及属性 Object是顶级类

	class A(object):
	
	    def __init__(self):
	        self.num = 1
	
	    def info_print(self):
	        print(self.num)
	
	
	
	class B(A):
	    pass
	
	
	result = B()   #创建B的对象
	result.info_print()  #由于继承关系  所以B的对象可以调用A的方法

3. 单继承

	class Master(object):
	
	    def __init__(self):
	        self.kongfu = '[煎饼果子配方]'
	
	
	    def make_cake(self):
	        print(f'运用{self.kongfu}制作煎饼果子')
	
	
	class Prentice(Master):
	    pass
	
	
	tudi = Prentice()
	print(tudi.kongfu)  #打印属性
	tudi.make_cake()

4. 多继承

多继承：继承多个父类 默认使用第一个父类的属性以及方法

	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(Master,School):
	    pass
	
	
	daqiu = Prentice()
	print(daqiu.kongfu)
	daqiu.make_cake()

5. 重写

	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__)   #快速查看继承关系

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

Prentice重写了父类的属性以及方法， 子类的属性与方法和父类的属性以及方法都是相同的，所以当我调用make_cake方法时，肯定调用的是子类的方法，所以为了能够调用父类的方法，在子类中定义两个方法，分别为：make_master_cake以及make_school_cake方法，这两个方法用来调用父类的方法，但是为了保证调用的是父类的属性，必须在调用前进行父类的初始化，那么如果我要调用子类的Make_cake方法（事先已经调用了make_master_cake方法）会不会得到理想的结果，不会！因为父类属性会覆盖子类的属性，所以，必须在调用方法前进行初始化，

	#子类调用父类同名的方法和属性
	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)
	
	daqiu = Prentice()
	print(daqiu.kongfu)
	daqiu.make_cake()
	print(Prentice.__mro__)#快速查看继承关系
	
	
	daqiu.make_master_cake()

7. 多层继承

	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)
	
	daqiu = Prentice()
	print(daqiu.kongfu)
	daqiu.make_cake()
	print(Prentice.__mro__)#快速查看继承关系
	
	
	daqiu.make_master_cake()
	
	
	class tusun(Prentice):
	    pass
	
	s = tusun()
	s.make_cake()
	s.make_master_cake()
	s.make_school_cake()

8. super使用方法

  1. Super(当前类名，self).函数（）
	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}制作煎饼果子')
	
	        super(School,self).__init__()
	        super(School,self).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)
	
	    #这里需要用一次  并且他的父类 school也要用一次 make_cake
	    def make_old_cake(self):
	        super(Prentice,self).__init__()
	        super(Prentice,self).make_cake()
	
	
	s = Prentice()
	s.make_old_cake()
  1. 无参数的super方法
	
	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}制作煎饼果子')
	
	        # super(School,self).__init__()
	        # super(School,self).make_cake()
	
	        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)
	
	    #这里需要用一次  并且他的父类 school也要用一次 make_cake
	    def make_old_cake(self):
	        # super(Prentice,self).__init__()
	        # super(Prentice,self).make_cake()
	        super().__init__()
	        super().make_cake()
	
	
	s = Prentice()
	s.make_old_cake()

9. 私有属性

方法：在属性名和方法名前面添加两个下划线__ 保证该属性不会被子类进行直接调用

	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}制作煎饼果子')
	
	        # super(School,self).__init__()
	        # super(School,self).make_cake()
	
	        super().__init__()
	        super().make_cake()
	
	
	
	# 多继承    重写父类的重名方法 以及属性
	class Prentice(School):
	    def __init__(self):
	        self.kongfu = '[独创煎饼果子配方]'
	        self.__money = 200000  #私有属性
	
	    # 如果是先调用了父类的属性和方法  父类属性会覆盖子类属性   故在调用前  先调用自己子类的初始化
	    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)
	
	    #这里需要用一次  并且他的父类 school也要用一次 make_cake
	    def make_old_cake(self):
	        # super(Prentice,self).__init__()
	        # super(Prentice,self).make_cake()
	        super().__init__()
	        super().make_cake()
	
	
	class Q(Prentice):
	    pass

	s = Prentice()
	s.make_old_cake()
	
	
	q = Q()
	print(q.money)   #无法继承私有属性

修改私有属性： get set 方法

	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}制作煎饼果子')
	
	        # super(School,self).__init__()
	        # super(School,self).make_cake()
	
	        super().__init__()
	        super().make_cake()
	
	
	
	# 多继承    重写父类的重名方法 以及属性
	class Prentice(School):
	    def __init__(self):
	        self.kongfu = '[独创煎饼果子配方]'
	        self.__money = 200000  #私有属性
	
	    #获取私有属性和方法
	    def get_money(self):
	        return self.__money
	
	    def set_money(self):
	        self.__money  = 5000
	
	    # 如果是先调用了父类的属性和方法  父类属性会覆盖子类属性   故在调用前  先调用自己子类的初始化
	    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)
	
	    #这里需要用一次  并且他的父类 school也要用一次 make_cake
	    def make_old_cake(self):
	        # super(Prentice,self).__init__()
	        # super(Prentice,self).make_cake()
	        super().__init__()
	        super().make_cake()
	
	
	class Q(Prentice):
	    pass
	
	
	s = Prentice()
	s.make_old_cake()
	
	q = Q()
	print(q.get_money())   # 获取父类私有属性值
少写代码少看论文多多睡觉
关注
专栏目录
python学习笔记（八）——继承
别呀的博客
04-06 400
前沿 思考 问题一：两个中有大量重复的代码，是否能够只写一次 ？ 问题二： 继承的意义是什么 ？ 面向对象的编程带来的好处之一是代码的重用，实现这种重用方法之一是通过继承机制。 继承是两个类或多个类之间的父子关系，子类继承了基类的所有公有数据属性和方法，并且可以通过编写子类的代码扩充子类的功能。 开个玩笑地说，如果人类可以做到儿女继承了父母的所有才学并加以拓展，那么人类的发展至少是现在的数万倍。继承实现了数据属性和方法的重用，减少了代码的冗余度。 那么我们何时需要使用继承呢？如果我们需要的类中具有公共
Python 继承笔记
weixin_42389650的博客
12-24 139
继承 class RobotOne:#第一代机器人 def init(self,year,name): self.name=name self.year=year def walking_on_ground(self): print(self.name+"只能在平地上行走，有障碍物就会摔倒") def robot_info(self): print("{0}年产生的机器人{1}，...
Python-继承模式学习笔记
解决自己遇到的问题 分享认为有意义的知识 提供有一点点参考价值的灵感
11-24 210
Python继承模式 首先讲一下传统的 深度优先 与 广度优先 深度优先 从下到上 从左到右 (下上左右) 广度优先 从左到右 从下到上 (左右下上) Python2继承采用深度优先： Python3继承采用广度优先(简单理解，后面给例子剖析并不是简单的广度)： 上述图树说明了继承关系，并用数字表示继承优先级。 以上述图示的模型简单举例： # -*- coding:utf-8 -*- class A(): name = 'a' class B(A): xname = 'b' clas
python笔记(继承,钻石继承，漏斗继承...)
小小龙的博客
11-15 162
class A:pass #父类，基类，超类 class B:pass #父类，基类，超类 class A_son(A,B):pass#子类，派生类 print(A_son.__bases__) print(A.__bases__) 输出结果： (<class ‘main.A’>, <class ‘main.B’>) (<class
python类的继承学习笔记
zr1213159840的博客
08-31 185
继承是创建新类的方式，python中的继承，可以继承一个或继承多个，新建的类被称之为派生类或者子类，被继承的类是父类，可以称之为基类，超类。 1.单继承 class Car(object): def __init__(self,speed,brand): self.speed = speed self.brand = brand def run(self): print("{brand}在行驶".format(brand=se
Python学习笔记--皮大庆.pdf.zip
10-11
【Python学习笔记--皮大庆.pdf.zip】是一个针对初学者的Python编程教程，源自英文书籍《How to think like a computer scientist》。这本书以易懂的方式介绍了Python语言的基础知识，旨在帮助没有编程背景的人快速...
python学习笔记-王纯业
03-06
以下是一个Python学习笔记的大纲，涵盖了从基础到进阶的内容。你可以根据自己的学习进度和理解情况，逐步填充和完善这个大纲。 Python学习笔记大纲 一、Python基础 Python简介 Python的历史 Python的特点和应用...
python学习笔记 --基础篇
03-19
从print 到 继承 ，包含代码，运行结果和注释
python学习笔记-面向对象高级编程-20200324
12-21
文章目录面向对象高级编程使用__slots__使用__slots__使用@property练习多重继承Mixln小结定制类__str____iter____getitem____getattr____call__小结使用枚举类exercise小结使用元类type（）metaclass 面向对象高级...
马哥python课堂笔记-马哥教育PYTHON相关基础笔记.pdf
06-14
在马哥教育的PYTHON相关基础笔记中，我们看到几个关键知识点： 1. **推荐书籍**：学习Python时，有几本经典教材值得参考，包括《Python Cookbook》、《Learn Python the Hard Way》、《Google's Python Class》以及...
Python学习笔记之继承
Zhang_YingJie的博客
05-10 254
继承 代码的重用 1.单继承 –单继承： 父类放在子类的括号中 –初始化父类： （1）super().init() 注意括号中没有self,super()是个对象 （2）father.init() 注意这里father是类型 class father: def __init__(self): self.money=2000e8 def buy(...
(12)python讲义笔记----继承
小蜗Leon的博客
09-13 173
12 继承 面向对象三大特征：封装、继承、多态 1.继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”，所谓继承就是使现有的类无需编码便可以拥有原有类的方法和属性。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5saN3rWf-1599811497068)(继承.png)] 被继承的类可以称之为***父类、基类、超类***。继承的类可以称之为***子类、派生类***。派生和继承是一体两面，从父类向子类看就是派生，从子类向父类看就是继承。子类和父类的关系可以用“i
Python中类的继承与方法重写（学习笔记）
语汐的博客
08-09 739
1、继承 在编写类时，并不是每次都要从空白开始，那样太费资源了。当要编写的类和另一个已经存在的类之间存在一定的继承的关系时，就可以通过继承来达到代码重用的目的，提高开发效率。 继承是面向对象编程最重要的特性之一，它源于人们认识客观世界的过程，是自然界普遍存在的一种现象。比如我们每个人都从我们的父辈那里继承了一些体貌特征，但是我们每个人又都是不同于父辈的，有我们自己的特征。 通过继承不仅可以实...
Python语法基础之继承练习——由浅入深制作“煎饼果子”
初心的博客
08-14 854
体验继承
python面向对象（总结）
beishanyingluo的博客
03-02 859
一 基础 1.1 demo：定义一个Hero类 # class Hero: # 经典类（旧式类）定义形式 # class Hero(): class Hero(object): # 新式类定义形式 def info(self): print("英雄各有见，何必问出处。") 说明： 定义类时有2种形式：新式类和经典类，上面代码中的Hero为新式类，前两行注释部分则为...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2392
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
蘑菇分类检测数据集 21类蘑菇 8800张 带标注 voc yolo
阿利同学的博客
10-04 1214
蘑菇分类检测数据集 21类蘑菇 8800张 带标注 voc yolo
基于ResNet50模型的船型识别与分类系统研究
最新发布
深度学习实战训练营，一起交流探索深度学习
10-08 1086
使用加载预训练的 ResNet50 模型，并修改全连接层以匹配数据集的类别数量。实现训练函数，包括训练过程、验证过程和模型保存。在训练过程中，记录每个 epoch 的训练和验证损失、准确率。
task【XTuner微调个人小助手认知】
m0_53291740的博客
10-07 803
下面我们将根据项目的需求一步步的进行修改和调整吧！在 PART 1 的部分，由于我们不再需要在 HuggingFace 上自动下载模型，因此我们先要更换模型的路径以及数据集的路径为我们本地的路径。为了训练过程中能够实时观察到模型的变化情况，XTuner 贴心的推出了一个。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

少写代码少看论文多多睡觉

求打赏，求关注，求点赞

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

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

打赏作者

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

抵扣说明：

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

余额充值