Python面向对象-继承

已于 2023-12-21 09:29:18 修改
阅读量978 收藏 23
点赞数 16
文章标签： python 开发语言 面向对象
于 2023-12-19 11:06:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aj_shang/article/details/135079851
版权

⽬标

  • 继承的概念

  • 单继承

  • 多继承

  • ⼦类重写⽗类的同名属性和⽅法

  • ⼦类调⽤⽗类的同名属性和⽅法

  • 多层继承

  • super()

  • 私有属性和私有⽅法

⼀. 继承的概念

⽣活中的继承，⼀般指的是子女继承父辈的财产。

  • 拓展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.formula = '[古法煎饼果⼦配⽅]'
     def make_cake(self):
     	print(f'运⽤{self.formula}制作煎饼果⼦')
 
# 2. 徒弟类
class Prentice(Master):
    pass

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

三. 多继承

故事推进：小明是个爱学习的好孩⼦，想学习更多的煎饼果⼦技术，于是，来到财税煎饼专业，学习煎饼果⼦技术。

  • 所谓多继承意思就是⼀个类同时继承了多个⽗类。
class Master(object):
    
    def __init__(self):
        self.formula = '[古法煎饼果⼦配⽅]'
        
    def make_cake(self):
        print(f'运⽤{self.formula}制作煎饼果⼦')

# 创建学校类
class School(object):
    
    def __init__(self):
        self.formula = '[财税煎饼果⼦配⽅]'
        
 	def make_cake(self):
		print(f'运⽤{self.formula}制作煎饼果⼦')

class Prentice(School, Master):
   	pass

xiaoming = Prentice()
print(xiaoming.formula)
xiaoming.make_cake()

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

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

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

技术。

class Master(object):
    def __init__(self):
        self.formula = '[古法煎饼果⼦配⽅]'
        
 	def make_cake(self):
		print(f'运⽤{self.formula}制作煎饼果⼦')
        
class School(object):
     def __init__(self):
     	self.formula = '[财税煎饼果⼦配⽅]'
     def make_cake(self):
    	print(f'运⽤{self.formula}制作煎饼果⼦')
        
# 独创配⽅
class Prentice(School, Master):
     def __init__(self):
     	self.formula = '[独创煎饼果⼦配⽅]'
        
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
xiaoming = Prentice()
print(xiaoming.formula)
xiaoming.make_cake()
#查看继承关系
print(Prentice.__mro__)

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

五. ⼦类调⽤⽗类的同名⽅法和属性

故事：很多顾客都希望也能吃到古法和财税学校里专业的技术的煎饼果⼦。

class Master(object):
 	def __init__(self):
 		self.formula = '[古法煎饼果⼦配⽅]'
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
class School(object):
 	def __init__(self):
 		self.formula = '[财税煎饼果⼦配⽅]'
 
	def make_cake(self):
		print(f'运⽤{self.formula}制作煎饼果⼦')
        
class Prentice(School, Master):
    
	def __init__(self):
 		self.formula = '[独创煎饼果⼦配⽅]'
        
 	def make_cake(self):
    	# 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
 		self.__init__()
 			print(f'运⽤{self.formula}制作煎饼果⼦')
    # 调⽤⽗类⽅法，但是为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
        
	def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)
        
xiaoming = Prentice()
xiaoming.make_cake()
xiaoming.make_master_cake()
xiaoming.make_school_cake()
xiaoming.make_cake()

六. 多层继承

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

class Master(object):
	def __init__(self):
 		self.formula = '[古法煎饼果⼦配⽅]'
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')

class School(object):
    def __init__(self):
        self.formula = '[财税煎饼果⼦配⽅]'
        
	def make_cake(self):
		print(f'运⽤{self.formula}制作煎饼果⼦')

class Prentice(School, Master):
 	def __init__(self):
 		self.formula = '[独创煎饼果⼦配⽅]'
 	def make_cake(self):
 		self.__init__()
			print(f'运⽤{self.formula}制作煎饼果⼦')
 	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()调⽤⽗类⽅法

class Master(object):
    
 	def __init__(self):
 		self.formula = '[古法煎饼果⼦配⽅]'
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
        
class School(Master):
 	def __init__(self):
		self.formula = '[财税煎饼果⼦配⽅]'
        
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
        # ⽅法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.formula = '[独创煎饼果⼦技术]'
 	def make_cake(self):
 		self.__init__()
 		print(f'运⽤{self.formula}制作煎饼果⼦')

 	# ⼦类调⽤⽗类的同名⽅法和属性：把⽗类的同名属性和⽅法再次封装
 	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()
        
xiaoming = Prentice()
xiaoming.make_old_cake()

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

⼋. 私有权限

8.1 定义私有属性和⽅法

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

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

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

class Master(object):
    def __init__(self):
        self.formula = '[古法煎饼果⼦配⽅]'
    def make_cake(self):
        print(f'运⽤{self.formula}制作煎饼果⼦')
        
class School(object):
 	def __init__(self):
 		self.formula = '[财税煎饼果⼦配⽅]'
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
class Prentice(School, Master):
 	def __init__(self):
 		self.formula = '[独创煎饼果⼦配⽅]'
 		# 定义私有属性
 		self.__money = 2000000
 		# 定义私有⽅法
 	def __info_print(self):
 		print(self.formula)
 		print(self.__money)
        
 	def make_cake(self):
 		self.__init__()
 		print(f'运⽤{self.formula}制作煎饼果⼦')
        
 	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

xiaoming = Prentice()
# 对象不能访问私有属性和私有⽅法
# print(xiaoming.__money)
# xiaoming.__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.formula = '[古法煎饼果⼦配⽅]'
     def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
class School(object):
	def __init__(self):
 		self.formula = '[财税煎饼果⼦配⽅]'
 	def make_cake(self):
 		print(f'运⽤{self.formula}制作煎饼果⼦')
class Prentice(School, Master):
 	def __init__(self):
 		self.formula = '[独创煎饼果⼦配⽅]'
 		self.__money = 2000000
 	# 获取私有属性
 	def get_money(self):
 		return self.__money
 	# 修改私有属性
 	def set_money(self):
 		self.__money = 500
 	def __info_print(self):
 		print(self.formula)
 		print(self.__money)
 	def make_cake(self):
 		self.__init__()
 		print(f'运⽤{self.formula}制作煎饼果⼦')
 	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

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

九. 总结

  • 继承的特点
    • ⼦类默认拥有⽗类的所有属性和⽅法
    • ⼦类重写⽗类同名⽅法和属性
    • ⼦类调⽤⽗类同名⽅法和属性
  • super()⽅法快速调⽤⽗类⽅法
  • 私有权限
    • 不能继承给⼦类的属性和⽅法需要添加私有权限
    • 语法
class 类名():
    # 私有属性
    __属性名 = 值
    # 私有⽅法
    def __函数名(self):
        代码
_woami
关注
  • 16
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python面向对象-继承用法详解
IT之一小佬的博客
01-31 1891
python面向对象-继承用法详解
python中面向对象-继承
qq_52262831的博客
11-15 1839
目标 继承的概念 单继承 多继承 子类重写父类的同名属性和方法 子类调用父类的同名属性和方法 多层继承 super() 私有属性和私有方法 一、继承的概念 拓展1：经典类或旧式类 不由任意内置类型派生出的类，称之为经典类。 class 类名: 代码 ...... 拓展2：新式类 class 类名(object): 代码 python面向对象的继承指的是多个类之...
【Python】面向对象 - 继承 ① ( 继承概念 | 继承语法 | 单继承与多继承 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
07-10 3328
一、继承简介 1、继承概念 2、继承语法 3、单继承与多继承 二、代码示例 1、代码示例 - 单继承 2、代码示例 - 多继承
Python面向对象--多继承的案例
那人独钓寒江雪
03-14 1094
class ShenXian: '''神仙类''' def fly(self): print("神仙会飞") def fight(self): print("神仙喜欢打架") class Monkey: '''灵长类''' def eat_banner(self): print("猴子喜欢吃香蕉") def fight(self): print("猴子喜欢打架") class Mon
Python面向对象之继承
ncu5509121083的博客
05-12 1596
Python面向对象之继承,单继承，多继承，super()，私有属性/方法
python面向对象--继承，重写，多态
GC
06-26 4927
1.继承 1.1继承的概念 继承描述的是一种类间关系，一个类A从另一个类B获取成员信息，称类A继承自类B。 提供成员信息的类称父类（基类），获取成员信息的类称子类（派生类）。 1.2继承的作用 子类可以使用父类的成员（成员变量，成员方法） 1.3继承语法格式 class 类名（父类名）： pass 1.4获取继承关系图谱 使用Python内置属性__mro__可以查看继承关系 语法格式：...
python练习|面向对象--继承
py_hope
01-20 1088
个人学习笔记
python 面向对象-继承
07-04 653
继承是面向对象的重要特征之一，继承是两个类或者多个类之间的父子关系， 子进程继承了父进程的所有公有实例变量和方法。继承实现了代码的重用。 重用已经存在的数据和行为，减少代码的重新编写，python在类名后用一对 圆括号表示继承关系， 括号中的类表示父类，如果父类定义了__init__方法， 则子类必须显示地调用父类的__init__方法，如果子类需要扩展父类的行为， 可以添加__init
Python进阶---面向对象 继承
木易巷的小博客
08-15 230
Python进阶---面向对象 继承
面向对象编程—-继承（Python版-案例详解）
01-21
本篇是面向对象编程第二章—–继承特性详解，欢迎阅读学习，一起进步 Python专栏请参考：人生苦短-我学python 文章目录一.继承介绍二.单继承：子类只继承一个父类三.多继承：子类继承多个父类四.子类重写父类的...
Python面向对象之继承和组合用法实例分析
09-20
本文将深入探讨Python面向对象编程中的继承和组合（Composition）。 **继承**是面向对象编程中的一个重要特性，它允许一个类（子类或派生类）从另一个类（父类或基类）继承属性和方法。在Python中，通过在子类定义...
Python面向对象编程之继承与多态详解
09-20
总结来说，Python的面向对象编程中的继承和多态是强大的工具，它们帮助开发者构建模块化的、可维护的代码。继承允许我们构建类的层次结构，通过共享和扩展基类的属性和方法，减少代码重复。多态则允许不同的对象以...
Python面向对象之继承和多态用法分析
09-19
主要介绍了Python面向对象之继承和多态用法,结合实例形式分析了Python面向对象程序设计中继承与多态的原理及相关操作技巧,需要的朋友可以参考下
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1206
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
Ansys Zemax｜场曲跟畸变图的前世今生
ueotek的博客
07-02 378
这里的y和z坐标和方向余弦是（Hx, Hy, Px, Py）=（X, X, 0 ,0）和（Hx, Hy, Px, Py）=（X, X, 0 ,0.001），在光线追迹像面的前一个平面的 z坐标和方向余弦。OpticStudio通过在X和Y方向（弧矢和子午方向）的傍轴光线追踪确定近轴图像平面的Z坐标，并测量该近轴焦平面与系统图像平面的Z坐标之间的距离。使用附件中的样本文件，近轴像面的全局Z坐标与视场0处的像面位置之差与场曲和畸变图中的的Tan Shift相同。近轴像面的定义是以下两个光线交点的全局Z坐标。
使用Python实现深度学习模型：序列建模与生成模型的博客教程
Echo_Wish的博客
07-02 1035
本文介绍了使用Python实现深度学习模型的序列建模和生成模型的步骤。我们详细说明了每个步骤，并提供了相应的代码示例。通过学习本文，您将能够使用Python构建和训练序列建模和生成模型，并生成新的序列数据。希望本文对您有所帮助！如果您有任何问题或建议，请随时提出。
【Python进阶】函数的扩展
最新发布
weixin_52854743的博客
07-06 511
python函数的补充，包括函数的嵌套调用、函数的变量作用域、多种参数、拆包和交换变量值、引用和匿名函数
Java高级重点知识点-19-Lambda
m0_72926194的博客
07-02 482
本文主要是讲解了如何使用lambda表达式来简介代码开发，同时讲解了函数式编程思想，该思想主要的是体现做什么，而不是怎么做。
Python面向对象之继承头歌
05-13
在Python中，面向对象编程的一个重要概念是继承。继承是一种方式，通过它可以创建新的类，从现有的类中继承属性和方法。这样可以使代码更加模块化和可重用，也可以节省开发时间。 Python中的类可以继承自另一个类，从而获得父类的属性和方法。子类可以添加额外的属性和方法，也可以覆盖或重写父类的属性和方法。 下面是一个简单的例子，演示了如何创建一个父类和一个子类，并继承父类的属性和方法： ```python # 定义一个父类 class Animal: def __init__(self, name): self.name = name def eat(self): print(f"{self.name} is eating...") # 定义一个子类，并继承父类的属性和方法 class Dog(Animal): def bark(self): print(f"{self.name} is barking...") # 创建一个Dog对象，并调用它的方法 my_dog = Dog("Buddy") my_dog.eat() # 输出：Buddy is eating... my_dog.bark() # 输出：Buddy is barking... ``` 在上面的例子中，我们首先定义了一个Animal类，它有一个构造函数和一个eat()方法。然后我们定义了一个Dog类，并通过继承Animal类来获得它的属性和方法。 最后，我们创建了一个Dog对象，并调用了它的eat()方法和bark()方法。由于Dog类继承了Animal类，因此它可以访问父类的属性和方法，并且还可以添加自己的属性和方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值