面向对象编程

最新推荐文章于 2024-07-08 00:01:13 发布
最新推荐文章于 2024-07-08 00:01:13 发布
阅读量312 收藏 2
点赞数 2
分类专栏： # Python基础语法 文章标签： python 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W_chuanqi/article/details/125753356
版权

📋 个人简介
💖 作者简介：大家好，我是W_chuanqi，一个编程爱好者
📙 个人主页：W_chaunqi
😀 支持我：点赞👍+收藏⭐️+留言📝
💬 愿你我共勉：“若身在泥潭，心也在泥潭，则满眼望去均是泥潭；若身在泥潭，而心系鲲鹏，则能见九万里天地。”✨✨✨

在这里插入图片描述

文章目录

一、面向对象基础

1.理解面向对象

​ Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

  • 面向过程： 分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了。

  • 面向对象： 把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。

​ 面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象映射现实中的事物，使用对象的关系描述事物之间的联系，这种思想就是面向对象。

2.面向对象具有三大特性

2.1 封装性

​ 封装是面向对象的核心思想，它有两层含义，一是指把对象的属性和行为看成是一个密不可分的整体，将这两者“封装”在一起（即封装在对象中）；另外一层含义指“信息隐藏”，将不想让外界知道的信息隐藏起来。例如，驾校的学员学开车，只需要知道如何操作汽车，无需知道汽车内部是如何工作的。

2.2 继承性

​ 继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。例如，有一个汽车类，该类描述了汽车的普通特性和功能。进一步再产生轿车类，而轿车类中不仅应该包含汽车的特性和功能，还应该增加轿车特有的功能，这时，可以让轿车类继承汽车类，在轿车类中单独添加轿车特性和方法就可以了。继承不仅增强了代码的复用性、提高开发效率，还降低了程序产生错误的可能性，为程序的维护以及扩展提供了便利。

2.3 多态性

​ 多态性指的是在一个类中定义的属性和方法被其它类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut” 这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是不一样的。多态的特性使程序更抽象、便捷，有助于开发人员设计程序时分组协同开发。

​ 在面向对象中，为了做到让程序对事物的描述与事物在现实中的形态保持一致，面向对象思想中提出了两个概念，即类和对象。

3.类和对象

​ 在⾯向对象编程过程中，有两个重要组成部分：类 和 对象。类和对象的关系：⽤类去创建⼀个对象。

3.1理解类和对象

3.1.1类

​ 类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。

  • 特征即是属性
  • ⾏为即是⽅法

类⽐如是制造洗⾐机时要⽤到的图纸，也就是说类是⽤来创建对象。

image-20220704181526556

3.1.2对象

对象是类创建出来的真实存在的事物，例如：洗⾐机。

注意：开发中，先有类，再有对象。

image-20220704183641602

3.2 ⾯向对象实现⽅法

3.2.1定义类

✳语法

class 类名():
 代码
 ......

注意：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。

✳体验

class Washer():
	def wash(self):
 		print('我会洗⾐服')
3.2.2 创建对象

对象⼜名实例。

✳语法

对象名 = 类名()

✳体验

# 创建对象
haier1 = Washer()
# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
# haier对象调⽤实例⽅法
haier1.wash()

注意：创建对象的过程也叫实例化对象。

3.2.3 self

self指的是调⽤该函数的对象。

# 1. 定义类
class Washer():
	def wash(self):
		print('我会洗⾐服')
		# <__main__.Washer object at 0x0000024BA2B34240>
		print(self)

# 2. 创建对象
haier1 = Washer()
# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
# haier1对象调⽤实例⽅法
haier1.wash()
haier2 = Washer()
# <__main__.Washer object at 0x0000022005857EF0>
print(haier2)

注意：打印对象和self得到的结果是⼀致的，都是当前对象的内存中存储地址。

4.添加和获取对象属性

​ 属性即是特征，⽐如：洗⾐机的宽度、⾼度、重量…

​ 对象属性既可以在类外⾯添加和获取，也能在类⾥⾯添加和获取。

4.1 类外⾯添加对象属性

✳语法

对象名.属性名 = 值

✳体验

haier1.width = 500
haier1.height = 800

4.2 类外⾯获取对象属性

✳语法

对象名.属性名

✳实例

print(f'haier1洗⾐机的宽度是{haier1.width}')
print(f'haier1洗⾐机的⾼度是{haier1.height}')

4.3类里面获取对象属性

✳语法

self.属性名

✳实例

# 定义类
class Washer():
 	def print_info(self):
 	# 类⾥⾯获取实例属性
 	print(f'haier1洗⾐机的宽度是{self.width}')
 	print(f'haier1洗⾐机的⾼度是{self.height}')
    
# 创建对象
haier1 = Washer()
# 添加实例属性
haier1.width = 500
haier1.height = 800
haier1.print_info()

5.类属性和实例属性

5.1 类属性

5.1.1设置和访问类属性
  • 类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
  • 类属性可以使⽤ 类对象 或 实例对象 访问。
class Dog(object):
	tooth = 10

wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth) # 10
print(wangcai.tooth) # 10
print(xiaohei.tooth) # 10

类属性的优点

  • 类的实例 记录的某项数据 始终保持⼀致时，则定义类属性。
  • 实例属性 要求 每个对象 为其 单独开辟⼀份内存空间 来记录数据，⽽ 类属性 为全类所共有，仅占⽤⼀份内存，更加节省内存空间。
5.1.2 修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了⼀个实例属性。

class Dog(object):
	tooth = 10

wangcai = Dog()
xiaohei = Dog()

# 修改类属性
Dog.tooth = 12
print(Dog.tooth) # 12
print(wangcai.tooth) # 12
print(xiaohei.tooth) # 12

# 不能通过对象修改属性，如果这样操作，实则是创建了⼀个实例属性
wangcai.tooth = 20
print(Dog.tooth) # 12
print(wangcai.tooth) # 20
print(xiaohei.tooth) # 12

5.2 实例属性

class Dog(object):

    def __init__(self):
        self.age = 5

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


wangcai = Dog()
print(wangcai.age)  # 5
# print(Dog.age) # 报错：实例属性不能通过类访问
wangcai.info_print()  # 5

6.类⽅法和静态⽅法

6.1 类⽅法

6.1.1 类⽅法特点
  • 第⼀个形参是类对象的⽅法
  • 需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以cls 作为第⼀个参数。
6.1.2 类⽅法使⽤场景
  • 当⽅法中 需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法
  • 类⽅法⼀般和类属性配合使⽤
class Dog(object):
	__tooth = 10

	@classmethod
	def get_tooth(cls):
		return cls.__tooth

wangcai = Dog()
result = wangcai.get_tooth()
print(result) # 10

6.2 静态⽅法

6.2.1 静态⽅法特点
  • 需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
  • 静态⽅法 也能够通过 实例对象 和 类对象 去访问。
6.2.2 静态⽅法使⽤场景
  • 当⽅法中 既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法
  • 取消不需要的参数传递，有利于 减少不必要的内存占⽤和性能消耗
class Dog(object):
	@staticmethod
	def info_print():
		print('这是⼀个狗类，⽤于创建狗实例....')
        
wangcai = Dog()
# 静态⽅法既可以使⽤对象访问⼜可以使⽤类访问
wangcai.info_print()
Dog.info_print()

7.魔法⽅法

在Python中， _xx_() 的函数叫做魔法⽅法，指的是具有特殊功能的函数。

方法作用
_init_构造函数，在生成对象时调用
_del_析构函数，释放对象时使用
_repr_打印，转换
_setitem_按照索引赋值
_getitem_按照索引获取值
_len_获得长度
_cmp_比较运算
_call_函数调用
_add_加运算
_sub_减运算
_mul_乘运算
_truediv_除运算
_mod_求余运算
_pow_乘方

7.1_init_()

7.1.1体验 _init_()

_init_() ⽅法的作⽤：初始化对象。

class Washer():

 	# 定义初始化功能的函数
 	def __init__(self):
 		# 添加实例属性
 		self.width = 500
 		self.height = 800

	def print_info(self):
 		# 类⾥⾯调⽤实例属性
		print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}')
     
haier1 = Washer()
haier1.print_info()

注意：

_init_() ⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤

_init_(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引⽤传递过去。

7.1.2 带参数的_init_()
class Washer():

	def __init__(self, width, height):
		self.width = width
		self.height = height

	def print_info(self):
		print(f'洗⾐机的宽度是{self.width}')
		print(f'洗⾐机的⾼度是{self.height}')

haier1 = Washer(10, 20)
haier1.print_info()
haier2 = Washer(30, 40)
haier2.print_info()

7.2__str__()

当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从在这个⽅法中 return 的数据。

class Washer():

	def __init__(self, width, height):
 		self.width = width
 		self.height = height

 	def __str__(self):
 		return '这是海尔洗⾐机的说明书'

haier1 = Washer(10, 20)
# 这是海尔洗⾐机的说明书
print(haier1)

7.3_del_()

当删除对象时，python解释器也会默认调⽤ del() ⽅法。

class Washer():

	def __init__(self, width, height):
		self.width = width
		self.height = height

	def __del__(self):
		print(f'{self}对象已经被删除')

haier1 = Washer(10, 20)
# <__main__.Washer object at 0x0000026118223278>对象已经被删除
del haier1

8.综合运用

8.1 烤地⽠

8.1.1需求

需求主线：

  1. 被烤的时间和对应的地⽠状态：
  • 0-3分钟：⽣的
  • 3-5分钟：半⽣不熟
  • 5-8分钟：熟的
  • 超过8分钟：烤糊了
  1. 添加的调料：⽤户可以按⾃⼰的意愿添加调料
8.1.2步骤分析

需求涉及⼀个事物： 地⽠，故案例涉及⼀个类：地⽠类。

1.定义类

  • 地⽠的属性
    • 被烤的时间
    • 地⽠的状态
    • 添加的调料
  • 地⽠的⽅法
    • 被烤
      • ⽤户根据意愿设定每次烤地⽠的时间
      • 判断地⽠被烤的总时间是在哪个区间，修改地⽠状态
    • 添加调料
      • ⽤户根据意愿设定添加的调料
      • 将⽤户添加的调料存储
  • 显示对象信息

2.创建对象，调⽤相关实例

8.1.3代码实现
# 定义类
class SweetPotato():

	def __init__(self):
 		# 被烤的时间
 		self.cook_time = 0
		# 地⽠的状态
 		self.cook_static = '⽣的'
 		# 调料列表
		self.condiments = []

	def cook(self, time):
 	"""烤地⽠的⽅法"""
    	self.cook_time += time
		if 0 <= self.cook_time < 3:
			self.cook_static = '⽣的'
		elif 3 <= self.cook_time < 5:
			self.cook_static = '半⽣不熟'
		elif 5 <= self.cook_time < 8:
			self.cook_static = '熟了'
		elif self.cook_time >= 8:
			self.cook_static = '烤糊了'
 
	def add_condiments(self, condiment):
	"""添加调料"""
		self.condiments.append(condiment)

	def __str__(self):
    	return f'这个地⽠烤了{self.cook_time}分钟, 状态是{self.cook_static}, 添加的调料有{self.condiments}'
    
digua1 = SweetPotato()
print(digua1)

digua1.cook(2)
digua1.add_condiments('酱油')
print(digua1)

digua1.cook(2)
digua1.add_condiments('辣椒⾯⼉')
print(digua1)

digua1.cook(2)
print(digua1)

digua1.cook(2)
print(digua1)

8.2 搬家具

8.2.1需求

将⼩于房⼦剩余⾯积的家具摆放到房⼦中

8.2.2步骤分析

需求涉及两个事物：房⼦ 和 家具，故被案例涉及两个类：房⼦类 和 家具类。

1.定义类

  • 房⼦类
    • 实例属性
      • 房⼦地理位置
      • 房⼦占地⾯积
      • 房⼦剩余⾯积
      • 房⼦内家具列表
    • 实例⽅法
      • 容纳家具
      • 显示房屋信息
  • 家具类
    • 家具名称
    • 家具占地⾯积

2.创建对象并调⽤相关⽅法

8.2.3代码实现
#家具类
class Furniture():

	def __init__(self, name, area):
		# 家具名字
		self.name = name
		# 家具占地⾯积
		self.area = area

#房子类
class Home():
	def __init__(self, address, area):
		# 地理位置
		self.address = address
		# 房屋⾯积
		self.area = area
		# 剩余⾯积
		self.free_area = area
		# 家具列表
        self.furniture = []
 
	def __str__(self):
		return f'房⼦坐落于{self.address}, 占地⾯积{self.area}, 剩余⾯积{self.free_area}, 家具有{self.furniture}'
 
	def add_furniture(self, item):
	"""容纳家具"""
		if self.free_area >= item.area:
			self.furniture.append(item.name)
			# 家具搬⼊后，房屋剩余⾯积 = 之前剩余⾯积 - 该家具⾯积
			self.free_area -= item.area
		else:
			print('家具太⼤，剩余⾯积不⾜，⽆法容纳')

bed = Furniture('双⼈床', 6)
jia1 = Home('北京', 1200)
print(jia1)

jia1.add_furniture(bed)
print(jia1)

sofa = Furniture('沙发', 10)
jia1.add_furniture(sofa)
print(jia1)

ball = Furniture('篮球场', 1500)
jia1.add_furniture(ball)
print(jia1)

二、继承

1.继承的概念

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

image-20220711214749091

# ⽗类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类是顶级类或基类；其他⼦类叫做派⽣类。

2.单继承

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

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

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

3.多继承

故事推进：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()

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

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

故事：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__)

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

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):
 		# 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
 		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()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

6.多层继承

故事：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()

7.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}制作煎饼果⼦')
        # ⽅法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()

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

8.私有权限

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获取和修改私有属性值

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

三、其他概念

1.多态

多态指的是⼀类事物有多种形态，（⼀个抽象类有多个⼦类，因⽽多态的概念依赖于继承）。

  • 定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果
  • 好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！
  • 实现步骤：
    • 定义⽗类，并提供公共⽅法
    • 定义⼦类，并重写⽗类⽅法
    • 传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同
class Dog(object):

    def work(self):  # ⽗类提供统⼀的⽅法，哪怕是空⽅法
        print('指哪打哪...')


class ArmyDog(Dog):  # 继承Dog类
    def work(self):  # ⼦类重写⽗类同名⽅法
        print('追击敌⼈...')


class DrugDog(Dog):
    def work(self):
        print('追查毒品...')


class Person(object):
    def work_with_dog(self, dog):  # 传⼊不同的对象，执⾏不同的代码，即不同的work函数
        dog.work()


ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

2.运算符重载

​ Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：

#!/usr/bin/python3
 
class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

以上代码执行结果如下所示:

image-20220630124758919

3.抽象类

3.1 抽象类概念

  • 抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化，需要借助python模块实现；
  • 抽象类是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性；
  • 抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。

3.2 python中的abc模块

​ python中需要利用abc模块实现抽象类


import abc #利用abc模块实现抽象类

class shuiguo(metaclass=abc.ABCMeta):
    
    all_type='sg'

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def name(self):
        pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def func(self):
        pass


class Apple(shuiguo): #子类继承抽象类，可是必须定义read和write方法
    def name(self):
        print('我是苹果')

    def func(self):
        print('好吃')

class Pear(shuiguo): #子类继承抽象类，可是必须定义read和write方法
    def name(self):
        print('我是梨子')

    def func(self):
        print('yunfeizhike')


apple =Apple()

pear=Pear()

apple.func()
pear.name()

print(pear.all_type)
print(apple.all_type)

注意：

  • 抽象类的本质仍是类，指的是一组类的类似性，包括数据属性（如all_type）和函数属性；
  • 抽象类是一个介于类和接口之间的一个概念，同时具有类和接口的部分特性

4.获取对象的信息

  • python中有几个内置方法，可以用来检查或是访问对象的属性。这些方法可以用于任意对象；
  • dir([obj])：调用这个方法将返回包含obj大多数属性名的列表（会有一些特殊的属性不包含在内）。obj的默认值是当前的模块对象。
  • hasattr(obj, attr)：这个方法用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
  • getattr(obj, attr)：调用这个方法将返回obj中名为attr值的属性的值，
  • setattr(obj, attr, val)：调用这个方法将给obj的名为attr的值的属性赋值为val。
  • type(obj)：判断对象类型，使用type()函数
class Pear(): 
    def name(self):
        print('我是梨子')

    def func(self):
        print('yunfeizhike')

import types
p = Pear()

print(dir(p))
print(type(p))
W_chuanqi
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
python面向对象程序设计实验_实验七 面向对象程序设计
weixin_39715290的博客
11-29 3304
实验七 面向对象程序设计一、实验目的与要求1、了解面向对象编程思想，掌握类和对象的定义和使用。2、熟悉self的使用技巧，掌握构造方法的使用。3、了解如何使用封装保护属性，掌握单继承和多继承的使用。4、掌握类属性和实例属性的使用，熟悉类方法和静态方法的使用技巧。二、实验原理在程序中使用对象来映射现实中的事物，使用对象间的关系来描述事物之间的联系，这种思想就是面向对象。面向对象编程有两个非常重要的概...
面向对象程序设计概念
kangjialong_的博客
11-02 2316
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
C++面向对象程序设计 面向对象编程
热门推荐
qq_19656669的博客
09-12 1万+
1.1 面向过程的编程风格与面向对象的编程风格 C语言是面向过程语言，也称为命令型语言，面向过程通常采用自顶向下设计，问题复杂时不断运用自顶向下设计（即函数分解法）直到容易处理。自顶向下设计优点是直观有条理，缺点是难于进行软件维护，包括软件系统的测试、调试和升级等，牵一发而动全身。 模块化的组织方式：将整个系统分解为若干模块，模块之间通过接口传递信息，模块划分应尽可能高内聚，低耦合。 ...
C++ 面向对象程序设计
2201_75772333的博客
05-03 3517
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
Python 面向对象编程详解
CSDN
08-04 6462
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
什么是面向对象编程（Java）
DICA的SEOer专栏
03-17 964
Java中的多态是通过方法重载和方法重写来实现的，方法重载是指在一个类中定义多个同名方法，但参数列表不同，方法重写是指在子类中重写父类的方法，从而实现不同的行为。在Java面向对象编程中，类是创建对象的模板，它定义了对象的属性和行为。Java面向对象编程是一种编程范式，它的核心思想是将程序中的数据和操作数据的方法组织成一个相互依存的对象集合，并通过对象间的交互来实现程序的功能。在Java面向对象编程中，对象是程序的基本单元，每个对象由数据和操作数据的方法组成，数据表示对象的状态，方法表示对象的行为。
java面向对象程序设计 论文_基于JAVA面向对象程序设计
weixin_28687251的博客
02-13 1390
内容介绍原文档由会员 xiaowei 发布基于JAVA面向对象程序设计------------科学养兔项目分析2.3万字 31页摘要 本文报道了对面向对象程序设计思想的基本阐述，就科学养兔项目的开发以及开发过程中所遇到的关于JAVA面向对象程序设计的问题作出详细的报道。一个系统作为一个对象来进行分析，由多个部分组成，作好系统分析工作再进一步确定各个对象的功能以及各个对象之间的关系，利用...
python之面向对象编程
qq_43428929的博客
08-23 1419
面向对象程序设计面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。从维基百科的定义可以看出，面向对象编程的对象。
《面向对象程序设计》教学资源汇总（2024/2023）
教学 & 技术专栏
03-06 2012
面向对象程序设计》教学资源汇总（2023）
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是基于C++的面向对象程序设计实现，旨在教授学生如何运用面向对象编程思想来构建实际的应用程序。** **一、面向对象编程基础** 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想...
Labview面向对象编程
10-31
Labview面向对象编程是NI...通过学习和掌握Labview面向对象编程，开发者可以构建出更复杂、更易于维护的应用程序，适应不断变化的需求，并利用Labview的强大功能进行数据分析、控制工程、测试测量等领域的项目开发。
java面向对象编程pdf
04-16
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在Java中，对象是指具有某些特征和行为的实体，例如人、学生、大象、冰箱...
Labview面向对象编程快速入门.pdf
05-11
Labview面向对象编程快速入门
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
Java基础:爬虫
weixin_65752158的博客
07-04 932
Pattern:表示正则表达式Matcher:文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。在大串中去找符合匹配规则的子串。通过Pattern p = Pattern.compile("正则表达式");获得 通过Matcher m = p.matcher(str);获得 (m要在str中找符合p规则的小串)其中, m为Matcher对象, p为正则表达式规则, str为要验证的字符串. boolean b = m.find(); 表示拿着文本匹配器从头开始读取，寻找是否有
pandas，dataframe使用笔记
分享计算机视觉，C++，嵌入式等知识。
07-05 405
dataframe属于pandas。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
最新发布
小明的Java问道之路
07-08 776
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
Django学习第四天
qq_43580271的博客
07-04 449
UserEditModelForm类继承了BootStrapModelForm类的方法，BootStrapModelForm继承了forms.ModelForm的方法所以使用继承能够更好封装代码功能。ModelForm引入时间样式（自动生成了id为id_create_time)django自动帮我们把session功能定义好了，使用只需要这样一个语句。封装每部分的功能，拆分到每个模块中去。在html中增加属性的方法1。在html中增加属性的方法2。在html中增加属性的方法3。在用户列表页面使用分页功能。
c++面向对象程序设计完整ppt课件.ppt
11-16
结构化程序设计强调将复杂问题分解为小模块，而面向对象编程则更注重数据和操作数据的方法作为整体——对象的抽象。 C++编程基础包括了对程序、数据类型、表达式和语句控制的理解。程序由数据和操作这些数据的指令...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

W_chuanqi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值