python从入门到精通（七）：封装、继承、多态
python数据分析和可视化基础
- 第二十六章：python面向对象编程
-
- （七）继承
-
-
- 7.1 面向对象三大特性
- 7.2 单继承
- 7.3 继承的语法
-
- 7.3.1 专业术语
- 7.3.2 继承的传递性
- 7.3.3 继承传递中的注意事项
- 7.4 方法的重写
-
- 7.4.1 覆盖父类的方法
- 7.4.2 对父类方法进行扩展
- 7.4.3 Python2调用父类方法
- 7.5 父类的私有属性和私有方法
- 7.6 多继承
-
- 7.6.1 多继承概念
- 7.6.2 多继承的语法
- 7.6.3 多继承的使用注意事项
- 7.6.4 Python 中的 MRO --方法搜索顺序(知道)
- 7.6.5 新式类与旧式(经典)类
-
- （八）多态
-
-
- 8.1 多态案例的演练
-
- （九）类的结构
-
-
- 9.1 实例
- 9.2 类是一个特殊的对象
- 9.3 类属性和实例属性
- 9.4 属性获取机制
- 9.5 使用对象名访问类属性的问题
- 9.6 类方法和静态方法
- 9.7 静态方法
- 9.8 方法综合案例
- 9.10 内部类
-
- （十）单例
-
-
- 10.1 单例设计模式
- 10.12 __new__ 方法
- 10.3 python中的单例
- 10.4 只执行一次初始化工作
-
第二十六章：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>