python数据分析和可视化基础
第二十六章:python面向对象编程
(七)继承
目标
- 单继承
- 多继承
7.1 面向对象三大特性
-
- 封装 根据
职责
将属性
和方法
封装
到一个抽象的类
中
- 封装 根据
-
- 继承
实现代码的重用
,相同的代码不需要重复的编写
- 继承
-
- 多态
不同的对象
调用相同的方法,产生不同的执行结果,增加代码的灵活度
- 多态
7.2 单继承
继承的概念、语法和特点
继承的概念:子类
拥有 父类
的所有 方法
和 属性
不使用继承写出来的代码是这样的
class Animal(object):
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
class Dog():
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
def bark(self):
print("汪汪叫")
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()
7.3 继承的语法
class 子类(父类):
pass
class Dog(Animal):
pass
使用继承以后的代码结构
子类 继承自父类
,可以直接享受父类中已经封装好的方法
,不需要再次开发
子类中应该根据职责
,封装子类特有
的属性
和方法
class Animal(object):
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
#子类拥有父类的所有属性和方法
class Dog(Animal):
def bark(self):
print("汪汪叫")
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run(p)
wangcai.slee()
wangcai.bark()
吃
喝
跑
睡
汪汪叫
7.3.1 专业术语
- Dog 类是 Animal类的
子类
,Animal类是 Dog类的父类
,Dog 类从 Animal 类继承
- Dog 类是 Animal类的
派生类
,Animal 类是 Dog 类的基类
,Dog 类从 Animal 类派生
7.3.2 继承的传递性
C类从B类继承,B类又从A类继承。那么c类就具有 B类和 A 类的所有属性和方法
子类
拥有 父类
以及 父类的父类
中封装的所有
属性
和方法
xiaotianquan会继承dog类的所有属性和方法,dog类又继承了animal的所有方法和属性,所以xiaotianquan继承了dog和animal的全部方法和属性
class Animal(object):
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
class Dog(Animal):
def bark(self):
print("汪汪叫")
class XiaoTianQuan(Dog):
def fly(self):
print("我会飞")
xtq = XiaoTianQuan()
xtq.eat()
xtq.drink()
xtq.run()
xtq.sleep()
xtq.bark()
xtq.fly()
吃
喝
跑
睡
汪汪叫
我会飞
7.3.3 继承传递中的注意事项
在创建一个猫类,继承animal类,然后使用xtq去调用他,会报错,因为xtq没有继承猫类,所以没有猫类的属性
class Cat(Animal):
def catch(self):
print("我会抓老鼠")
xtq.catch()
7.4 方法的重写
。子类 拥有 父类
的所有 方法
和 属性
。子类 继承自 父类
,可以直接 享受
父类中已经封装好的方法,不需要再次开发
应用场景
当 父类
的方法实现不能满足
子类需求时,可以对方法进行 重写(override)
重写父类方法有两种情况:
覆盖
父类的方法- 对父类方法进行
扩展
7.4.1 覆盖父类的方法
如果在开发中,父类的方法实现 和 子类的方法实现完全不同
。就可以使用 覆盖
的方式,在子类中 重新编写
父类的方法实现 I
具体的实现方式,就相当于在 子类中
定义了一个 和父类同名的方法并且实现重写之后
在运行时,只会调用 子类中重写的方法
,而不再会调用 父类封装的方法
class Animal(object):
def eat(self):
print("吃")
def drink(self):
print("喝")
def run(self):
print("跑")
def sleep(self):
print("睡")
class Dog(Animal):
def bark(self):
print("汪汪叫")
class XiaoTianQuan(Dog):
def fly(self):
print("我会飞")
# 对父类dog的bark方法进行了重写
def bark(self):
print("叫的和神一样......")
xtq = XiaoTianQuan()
# 如果子类中,重写了父类的方法
# 在使用子类对象调用方法时,会调用子类中重写的方法
xtq.bark()
叫的和神一样......
7.4.2 对父类方法进行扩展
如果在开发中,子类的方法实现 中 包含
父类的方法实现,父类原本封装的方法实现 是
子类方法的一部分
就可以使用 扩展
的方式
1.在子类中 重写
父类的方法
2.在需要的位置使用 super().父类方法
来调用父类方法的执行
3.代码其他的位置针对子类的需求,编写 子类特有的代码实现
关于 super()
在Python中super是一个 特殊的类
super()就是使用 super 类创建出来的对象
最常 使用的场景就是在 重写父类方法时,调用
在父类中封装的方法实现,哮天犬不仅叫的和神一样,而且还可以像正常的狗一样叫,还能叫出一些奇怪的声音,这样我们可以扩展父类方法
class XiaoTianQuan(Dog):
def fly(self):
print("我会飞")
def bark(self):
# 1.针对子类特有的需求,编写代码
print("神一样的叫唤..")
# 2.使用 super().调用原本在父类中封装的方法
super().bark()
# 3.增加其他子类的代码
print("$%^$名^#%$号")
xtq = XiaoTianQuan()
xtq.bark()
神一样的叫唤..
汪汪叫
$%^$名^#%$号
7.4.3 Python2调用父类方法
调用父类方法的另外一种方式(知道)
在 Python 2.x时,如果需要调用父类的方法,还可以使用以下方式:
父类名.方法(self)
这种方式,目前在Python3.x还支持这种方式这种方法
不推荐使用,因为一旦 父类发生变化
,方法调用位置的 类名
同样需要修改
提示
在开发时,父类名和 super()两种方式不要混用
如果使用 当前子类名
调用方法,会形成递归调用,出现死循环
class XiaoTianQuan(Dog):
def fly(self):
print("我会飞")
def bark(self):
# 1.针对子类特有的需求,编写代码
print("神一样的叫唤..")
# 2.使用 super().调用原本在父类中封装的方法
super().bark()
#父类名.方法(self)
Dog.bark(self)
# 调用XiaoTianQuan的子类bark 会形成递归调用,出现死循环
XiaoTianQuan.baek(self)
# 3.增加其他子类的代码
print("$%^$名^#%$号")
xtq = XiaoTianQuan()
xtq.bark()
7.5 父类的私有属性和私有方法
1.子类对象 不能
在自己的方法内部 直接
访问 父类的 私有属性 或 私有方法
2.子类对象 可以通过 父类
的 公有方法 间接
访问到 私有属性 或 私有方法
- 私有属性、方法是对象的隐私,不对外公开,外界以及子类都不能直接访问
- 私有属性、方法通常用于做一些内部的事情
B的对象不能直接访问__num2 属性
B的对象不能在 demo方法内访问__num2属性
B的对象可以在 demo方法内,调用父类的test方法
父类的 test 方法内部,能够访问__num2属性和__test 方法
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 18
def test(self):
print("父类的test公有方法 %d" % self.__num2)
self.__test()
def __test(self):
print("父类的__test公有方法 %d %d " % (self.__num2, self.num1))
class B(A):
def demo(self):
# 1.在子类的对象方法中,不能访问父类的私有属性
# print("子类调用父类的私有属性:",self.__num2)
# 2.调用父类的私有方法
# print("子类调用父类的私有方法:",self.__test())
# 3.访问父类的公有属性
print("子类调用父类的公有属性:", self.num1)
# 4.调用父类的公有方法
self.test()
b = B()
b.demo()
# 在外界访问父类的公有属性/调用公有方法
print(b.num1)
b.test()
# 外界不能直接访问对象的私有属性/调用私有方法
# print(b.__num2)
# b.__test()
子类调用父类的公有属性: 100
父类的test公有方法 18
父类的__test公有方法 18 100
100
父类的test公有方法 18
父类的__test公有方法 18 100
7.6 多继承
7.6.1 多继承概念
子类 可以拥有 多个父类
,并且具有 所有父类
的 属性
和 方法
例如:孩子 会继承自己 父亲 和 母亲 的 特性
7.6.2 多继承的语法
class 子类名(父类名1,父类名2..)
pass
class A:
def test(self):
print("Hello World")
class B:
def demo(self):
print("Hello")
class C(A, B):
"""多继承可以让子类对象,同时具有多个父类的属性和方法"""
pass
c = C()
c.test()
c.demo()
7.6.3 多继承的使用注意事项
问题的提出
如果 不同的父类
中存在 同名的方法
,子类对象
在调用方法时,会调用 哪一个父类中的方法呢?
提示:开发时,应该尽量避免这种容易产生混淆的情况!
–如果父类之间 存在
同名的属性或者方法,应该尽量避免
使用多继承
class A:
def test(self):
print("A --- test 方法")
def demo(self):
print("A ---demo 方法")
class B:
def test(self):
print("B --- test 方法")
def demo(self):
print("B ---demo 方法")
# 改变参数的前后顺序就调用不同的对象方法 谁在前调用谁的方法
class C(A, B):
pass
c = C()
c.test()
c.demo()
7.6.4 Python 中的 MRO --方法搜索顺序(知道)
Python 中针对 类
提供了一个 内置属性__mro__可以查看 方法 搜索顺序
MRO是method resolution order 主要用于在多继承
时判断方法、属性
的调用 路径
,
print(c._mro_)
输出结果
(<class'__main_.c'>,<class'__main__.A'>,<class' __main__.B'>,<class 'object'>)
在搜索方法时,是按照__mro__的输出结果 从左至右
的顺序查找的
如果在当前类中 找到方法,就直接执行,不再搜索
如果 没有找到,就查找下一个类
中是否有对应的方法,如果找到,就直接执行,不再搜索
如果找到最后一个类,还没有找到方法,程序报错
# 确定C类对象调用方法的顺序
print(C.__mro__)
7.6.5 新式类与旧式(经典)类
object是 Python 为所有对象提供的 基类,提供有一些内置的属性和方法,可以使用dir() 函数查看
- 新式类:以 object为基类的类,推荐使用
- 经典类:不以 object为基类的类,不推荐使用
在 Python 3.x
中定义类时,如果没有指定父类,会默认使用
object 作为该类的 基类
–Python 3.x中定义的类都是 新式类
在 Python 2.x
中定义类时,如果没有指定父类,则不会
以object作为 基类
新式类 和 经典类 在多继承时–会影响到方法的搜索顺序
为了保证编写的代码能够同时在Python2.x和Python 3.x运行!
今后在定义类时,如果没有父类,建议统一继承自object
class 类名(object):
pass
python2内置的属性和方法只有两个
python3内置的属性和方法有很多
(八)多态
面向对象三大特性
1.封装 根据 职责
将 属性
和 方法
封装 到一个抽象的 类
中
- 定义类的准则
2.继承 实现代码的重用
,相同的代码不需要重复的编写
- 设计类的技巧
- 子类针对自己特有的需求,编写特定的代码
3.多态 不同的 子类对象
调用相同的 父类方法
,产生不同的执行结果
- 多态 可以
增加代码的灵活度
- 以
继承
和重写父类方法
为前提 - 是调用方法的技巧,
不会影响
到类的内部设计
8.1 多态案例的演练
需求
1.在 Dog类中封装方法 game
- 普通狗只是简单的玩耍
2.定义 XiaoTianDog继承自Dog,并且重写 game 方法
- 哮天犬需要在天上玩耍
3.定义 Person 类,并且封装一个 和狗玩
的方法
- 在方法内部,直接让
狗对象
调用game 方法
class Dog():
def __init__(self,name):
self.name = name
def game(self):
print("%s 奔奔跳跳的玩耍" % self.name)
class XiaoTianQuan(Dog):
def game(self):
print("%s 哮天犬飞到天上玩耍" % self.name)
class Person:
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print("%s和 %s 在玩游戏" % (self.name,dog.name))
dog.game()
#不同的 `子类对象` 调用相同的 `父类方法`,产生不同的执行结果
wangcai = Dog("wangcai")
# wangcai = XiaoTianQuan("wangcai")
xiaoming = Person("xiaoming")
xiaoming.game_with_dog(wangcai)
#不同的 `子类对象` 调用相同的 `父类方法`,产生不同的执行结果
xiaoming和 wangcai 在玩游戏
wangcai 奔奔跳跳的玩耍
#不同的 `子类对象` 调用相同的 `父类方法`,产生不同的执行结果
xiaoming和 wangcai 在玩游戏
wangcai 哮天犬飞到天上玩耍
案例小结
Person类中只需要让 狗对象
调用 game 方法,而不关心具体是 什么狗
game 方法是在Dog父类中定义的
在程序执行时,传入不同的 狗对象
实参,就会产生不同的执行效果
wangcai = Dog("wangcai")
wangcai = XiaoTianQuan("wangcai")
#传入不同的 `狗对象` 实参,这个对象是Dog也可以是XiaoTianQuan
xiaoming = Person("xiaoming")
# 产生不同的执行效果
xiaoming.game_with_dog(wangcai)
(九)类的结构
9.1 实例
1.使用面向对象开发,第1步是设计类
- 使用 类名() 创建对象 的动作有两步:
- 1)在内存中为对象 分配空间
- 2)调用初始化方法__init__为 对象初始化
- 3.对象创建后,内存 中就有了一个对象的 实实在在 的存在 –
实例
因此,通常也会把:
- 创建出来的
对象
叫做类
的实例
- 创建对象的
动作
叫做实例化
- 对象的
属性
叫做实例属性
- 对象调用的
方法
叫做实例方法
9.2 类是一个特殊的对象
Python 中一切皆对象
class AAA: #定义的类属于 类对象
pass
obj1 = AAA() #属于 实例对象
在程序运行时,类 同样 会被加载到内存
在Python 中,类是一个特殊的对象 – 类对象
在程序运行时,类对象
在内存中 只有一份
,使用 一个类
可以创建出 很多个对象实例
除了封装 实例
的 属性
和 方法
外,类对象
还可以拥有自己的 属性
和 方法
- 类属性
- 类方法
通过 类名.的方式可以 访问类的属性
或者 调用类的方法
9.3 类属性和实例属性
概念和使用
类属性
就是给类对象
中定义的- 属性通常用来记录
与这个类相关
的特征 - 类属性 不会用于记录
具体对象的特征
示例需求
- 定义一个 工具类
- 每件工具都有自己的 name
- 需求 --知道使用这个类,创建了多少个工具对象?
class Tool(object):
# 使用赋值语句定义类属性,记录所有工具对象的数量
count =0
def __init__(self,name):
self.name = name
# 让类属性的值+1
Tool.count += 1
#1.创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
#2.输出工具对象的总数
print(Tool.count)
9.4 属性获取机制
在 Python 中 属性的获取 存在一个 向上查找机制
# 对象的属性中只有name="XX" 没有count
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
#2.输出工具对象的总数 count只存在在类对象中 这就是`向上查找机制` 找到类中count此时已计数为3了
# print(Tool.count) # 类.属性
# 方法.属性
print('工具的总数是 %d' % Tool1.count) # 所以输出3
# 方法.属性
print('工具的总数是 %d' % Tool3.count) # 所以输出3
工具的总数是 3
工具的总数是 3
因此,要访问类属性有两种方式:
1.类名.类属性
2.对象.类属性:(不推荐)
注意:
如果使用 对象.类属性 = 值 赋值语句,只会 给对象添加一个属性
,而不会影响到 类属性的值
9.5 使用对象名访问类属性的问题
#1.创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
tool3.count = 99 # 赋值操作
print("工具对象的总数 %d" % tool3.count) #添加了对象的属性的值
#2.输出工具对象的总数
print(Tool.count)
9.6 类方法和静态方法
类方法
-
类属性 就是针对 类对象 定义的属性
- 使用 赋值语句 在 class 关键字下方可以定义 类属性。
- 类属性 用于记录 与这个类相关 的特征
-
类方法 就是针对 类对象 定义的方法
- 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
语法如下
@classmethod
def 类方法名(cls):
pass
-
类方法需要用
修饰器
@classmethod 来标识,告诉解释器这是一个类方法 -
类方法的 第一个参数 应该是 cls
- 由 哪一个类 调用的方法,方法内的 cls 就是 哪一个类的引用
- 这个参数和 实例方法 的第一个参数是 self 类似。
- 提示 使用其他名称也可以,不过习惯使用cls
-
通过 类名.调用 类方法,调用方法时,不需要传递 cls 参数
-
在方法内部:
- 可以通过 cls.访问类的属性
- 也可以通过 cls.调用其他的类方法
示例需求
。定义一个 工具类
。每件工具都有自己的 name
需求–在类封装一个 show_tool_count 的类方法,输出使用当前这个类,创建的对象个数
class Tool(object):
# 使用赋值语句定义类属性,记录所有工具对象的数量
count =0
# 定义一个类方法
@classmethod
def show_tool_count(cls): # cls类似于self
print("工具的总数为 %d " % cls.count)
def __init__(self,name):
self.name = name
# 让类属性的值+1
Tool.count += 1
#1.创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
#2.输出工具对象的总数
tool1.show_tool_count()
tool3.show_tool_count()
工具的总数为 3
工具的总数为 3
在类方法内部,可以直接使用cls访问 类属性 或者 调用类方法
9.7 静态方法
在开发时,如果需要在 类 中封装一个方法,这个方法:
。既 不需要 访问 实例属性 或者调用 实例方法
。也 不需要 访问 类属性 或者调用 类方法
。这个时候,可以把这个方法封装成一个 静态方法
语法如下
@staticmethod
def 静态方法名():
pass
静态方法 需要用 修饰器
@staticmethod 来标识,告诉解释器这是一个静态方法
通过 类名.调用 静态方法
class Dog(object):
@staticmethod
def run():
# 不访问实例属性/类属性
print("小狗要跑...")
# 通过类名,调用静态方法 - 不需要创建对象
Dog.run()
9.8 方法综合案例
需求
-
设计一个 Game 类
-
属性:
-
定义一个 类属性 top_score 记录游戏的 历史最高分
-
定义一个 实例属性 player_name 记录 当前游戏的玩家姓名
-
方法:
-
静态方法 show_help 显示游戏帮助信息
-
类方法 show_top_score 显示历史最高分
-
实例方法 start_game 开始当前玩家的游戏
4.主程序步骤
- 1)查看帮助信息
- 2)查看历史最高分
- 3)创建游戏对象,开始游戏
class Game(object):
#历史最高分
top_score =0
def __init__(self,player_name):
self.player_name = player_name
@staticmethod
def show_help():
print("帮助信息:让僵尸进入大门")
@classmethod
def show_top_score(cls):
print("历史记录 %d" % cls.top_score)
def start_game(self):
print("%s 开始游戏啦..." % self.player_name)
#1.查看游戏的帮助信息
Game.show_help()
#2.查看历史最高分
Game.show_top_score()
#3.创建游戏对象
game = Game("小明")
game.start_game()
案例小结-- 什么时候该定义什么方法和属性
1.实例方法 – 方法内部需要访问 实例属性
- 实例方法 内部可以使用 类名.访问类属性
2.类方法 --方法内部 只
需要访问 类属性
3.静态方法 --方法内部,不需要访问 实例属性
和 类属性
提问
如果方法内部 即需要访问 实例属性
,又需要访问 类属性
,应该定义成什么方法?
答案
应该定义 实例方法
因为,类只有一个,在 实例方法 内部可以使用 类名.访问类属性
9.10 内部类
内部类:类的内部定义的类,主要目的是为了更好抽象现实世界。
一般情况下不使用内部类,这样会使程序结构复杂,但是理解内部类有助于理解模块的调用。
下面例子中,People类中又定义了Father类和Mother类两个内部类。创建内部类的实例化对象,可以通过外部类的实例化对象调用内部类完成,如Lisi = Zhangsan.Father();也可以直接使用外部类名调用内部类,如Liming = People.Mother()。
class People():
code = 0
class Father():
code = 1
class Mother():
code = 2
zhangsan = People()
lisi = zhangsan.Father() # 第一种实例化方法
print(lisi.code) # 输出结果:1
liming = People.Mother() # 第二种实例化方法
print(liming.code) # 输出结果:2
(十)单例
目标
- 单例设计模式
- __new__方法
- Python 中的单例
10.1 单例设计模式
-
设计模式
- 设计模式 是前人工作的总结和提炼,通常被人们广泛流传的设计模式都是针对 某一特定问题 的成熟的解决方案
- 使用 设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性
-
单例设计模式
- 目的 – 让 类 创建的对象,在系统中 只有 唯一的一个实例。
- 每一次执行 类名()返回的对象,内存地址是相同的
-
单例设计模式的应用场景
- 音乐播放 对象
- 回收站 对象
- 打印机 对象
10.12 new 方法
使用 类名()创建对象时,Python 的解释器 首先 会 调用new_方法为对象 分配空间
__new__是一个 由 object 基类提供的 内置的静态方法,,主要作用有两个:
- 1)在内存中为对象分配空间
- 2)返回对象的引用
Python 的解释器获得对象的 引用 后,将引用作为 第一个参数,传递给__init__方法
重写new_方法 的代码非常固定!
重写new方法一定要return super().new(cls)
否则 Python 的解释器 得不到 分配了空间的 对象引用,就不会调用对象的初始化方法
注意:new 是一个静态方法,在调用时需要 主动传递cls 参数
class MusicPlayer(object):
def __new__(cls,*args,**kwargs):
# 1.创建对象时,new方法会被自动调用
print("创建对象,分配空间")
# 2.为对象分配空间 __new__是静态方法需要手动传参
instance =super().__new__(cls)
# 3.返回对象的引用
return instance
def __init__(self):
print("播放器初始化")
# 创建播放器对象
player = MusicPlayer()
print(player)
10.3 python中的单例
单例 --让 类
创建的对象,在系统中 只有
唯一的一个实例
1.定义一个 类属性,初始值是 None,用于记录 单例对象的引用
2.重写new_方法
3.如果 类属性 is None,调用父类方法分配空间,并在类属性中记录结果
4. 返回 类属性 中记录的 对象引用
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
def __new__(cls,*args,**kwargs):
# 1.判断类属性是否为空对象
if cls.instance is None:
#调用父类方法为第一个对象的分配空间
cls.instance = super().__new__(cls)
# 2.为对象分配空间 __new__是静态方法需要手动传参
# 3.返回类属性保存的对象引用
return cls.instance
# 创建播放器对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
<__main__.MusicPlayer object at 0x0000016849A54320>
<__main__.MusicPlayer object at 0x0000016849A54320>
10.4 只执行一次初始化工作
在每次使用 类名()创建对象时,Python 的解释器都会自动调用两个方法:
new 分配空间O
init_对象初始化O
。在上一小节对new方法改造之后,每次都会得到 第一次被创建对象的引用
。但是:初始化方法还会被再次调用
需求
。让 初始化动作 只被 执行一次
解决办法
1.定义一个类属性 init_flag 标记是否 执行过初始化动作,初始值为 False2.在init方法中,判断 init_flag,如果为 False 就执行初始化动作
3.然后将 init_flag 设置为 True
4.这样,再次 自动 调用init_方法时,初始化动作就不会被再次执行了
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
def __new__(cls, *args, **kwargs):
# 1.判断类属性是否为空对象
if cls.instance is None:
# 调用父类方法为第一个对象的分配空间
cls.instance = super().__new__(cls)
# 3.返回类属性保存的对象引用
return cls.instance
def __init__(self):
print("播放器初始化")
# 创建播放器对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
播放器初始化
<__main__.MusicPlayer object at 0x0000020D6F2244D0>
播放器初始化
<__main__.MusicPlayer object at 0x0000020D6F2244D0>
让 初始化动作 只被 执行一次
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
# 记录初始化执行状态
init_flag = False
def __new__(cls, *args, **kwargs):
# 1.判断类属性是否为空对象
if cls.instance is None:
# 调用父类方法为第一个对象的分配空间
cls.instance = super().__new__(cls)
# 3.返回类属性保存的对象引用
return cls.instance
def __init__(self):
# 1.判断是否执行过初始化动作
if MusicPlayer.init_flag:
return
# 2.如果没有执行过就执行初始化动作
print("播放器初始化")
# 3.修改初始化状态
MusicPlayer.init_flag = True
# 创建播放器对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
播放器初始化
<__main__.MusicPlayer object at 0x000001BB62364500>
<__main__.MusicPlayer object at 0x000001BB62364500>