Python学习笔记——面向对象

本学习笔记基于 Bilibili视频网站up主—黑马程序员的Python视频教程
链接：https://www.bilibili.com/video/av14184325

面向对象

相比较函数，面向对象 是更大的 封装 ，根据职责在一个对象中 封装 多个方法

1. 在完成某一个需求前，首先确定职责——要做的事情（方法）
2. 根据 职责 确定不同的 对象，在 对象 内部封装不同的方法
3. 最后完成的代码，就是顺序地让 不同的对象 调用 不同的方法
   ** 面向对象编程的特点:**
4. 注重 对象和职责，不同的对象承担不同的职责
5. 更加适合应对负责的需求变化，是专门应对复杂项目开发提供的固定套路
6. 需要在面向过程基础上，再学习一些面向对象的语法

1 类 和 对象

• 类 是对一群具有相同特征 或者 行为的事物的统称，是抽象的，不能直接使用

  • 特征 被称为 属性
  • 行为 被称为 方法

• 类 就相当于制造飞机时的图纸，是一个 模板，是 负责创建对象 的

• 对象 是由 类 创建出来的一个具体存在，可以直接使用

• 由 哪一个类 创建出来的 对象，就拥有在 哪一个类 中定义的：属性 方法

• 对象 就相当于用图纸制造的飞机

1. 类 和 对象 的关系

• 类是模板，对象是根据 类 这个模板创建出来的，应该 先有类，后有对象
• 类 只有一个，而对象可以有很多个
  • 不同的对象之间 属性 可能会各不相同
• 类 中定义了什么 属性和方法，对象中就有什么属性和方法，不会多也不会少

2. 类的设计

设计一个 类， 通常需要满足以下三个要素:

1. 类名：这类事物的名字，满足大驼峰命名法
2. 属性：这类事物具有什么样的特征
3. 方法：这类事物具有什么样的行为

①：类名的确定
名词提炼法 分析 整个业务流程，出现的名词通常就是找到的类

②：属性和方法的确定
对 对象的特征描述，可以定义为 属性
对象具有的行为（动词），可以定义为方法

2 面向对象基础语法

1.dir内置函数

在python中 对象是几乎无处不在的，变量、数据 、函数都是对象
方法名为：__方法__格式的方法是 Python提供的 内置方法/属性

2.定义简单的类

①：定义只包含方法的类：

class 类名:
	def 方法1(self, 参数列表):
		pass
		
	def 方法2(self, 参数列表):
	pass

②：创建对象

对象变量 = 类名()

第一个面向对象程序：

class Cat:

    def eat(self):
        print('小猫爱吃鱼')

    def drink(self):
        print('小猫要喝水')

# 创建猫 对象
tom = Cat()

tom.eat()
tom.drink()

引用概念的强调
在面向对象开发中，引用的概念是同样适用的！

在 Python 中使用类 创建对象之后，tom 变量中 仍然记录的是 对象在内存中的地址,也就是 tom 变量 引用 了 新建的猫对象
使用 print 输出 对象变量，默认情况下，是能够输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）

3.方法中的self参数

给对象增加属性：
在 Python 中，要 给对象设置属性，下列这个方法非常的容易，但是不推荐使用。因为：对象属性的封装应该封装在类的内部
方法：只需要在 类的外部的代码 中直接通过 . 设置一个属性即可

# 可以使用 .属性名 利用赋值语句就可以
tom.name = 'Tom'

使用self在方法内部输出：

由 哪一个对象 调用的方法，方法内的 self 就是 哪一个对象的引用

• 在类封装的方法内部，self 就表示** 当前调用方法的对象自己**
• 调用方法时，程序员不需要传递 self 参数
• 在方法内部
  • 可以通过 self. 访问对象的属性
  • 也可以通过 self. 调用其他的对象方法

class Cat:

    def eat(self):
        # 哪一个对象调用的方法， self就是哪一个对象的引用
        print('%s 爱吃鱼' % self.name)

    def drink(self):
        print('%s 要喝水' % self.name)

# 创建猫 对象
tom = Cat()

# 可以使用 .属性名 利用赋值语句就可以
tom.name = 'Tom'

tom.eat()
tom.drink()

4.初始化方法

当使用 类名() 创建对象时，会 自动 执行以下操作：

1. 为对象在内存中 分配空间 —— 创建对象
2. 为对象的属性 设置初始值 —— 初始化方法 (init)
   这个 初始化方法 就是 __init__ 方法，__init__ 是对象的内置方法,专门用来定义一个类 具有哪些属性

在初始化方法内部定义属性

• 在 __init__ 方法内部使用 self.属性名 = 属性的初始值 就可以定义属性
• 定义属性之后，再使用 该类创建的对象，都会拥有该属性

class Cat:

    def __init__(self):

        print('这是一个初始化方法')
        # self.属性名= 属性的初始值
        self.name = 'Tom'

# 创建猫 对象
tom = Cat()

print(tom.name)

初始化方法的改造——初始化的同时设置初始值

在开发中，如果希望在 创建对象的同时，就设置对象的属性，可以对__init__ 方法进行改造

1. 把希望设置的属性值，定义成 __init__ 方法的参数
2. 在方法内部使用 self.属性 = 形参 接收外部传递的参数
3. 在创建对象时，使用 类名(属性1, 属性2...) 调用

class Cat:
	# 将希望设定的属性初始值作为参数
    def __init__(self, new_name):

        print('这是一个初始化方法')
        # self.属性名= 属性的初始值
        self.name = new_name

    def eat(self):
        print('%s 爱吃鱼' % self.name)

# 创建 猫 对象
tom = Cat('Tom')

print(tom.name)

lazy_cat = Cat('懒猫')
lazy_cat.eat()

5.内置方法和属性

__del__()方法：对象在从内存中被销毁前，会 自动 调用该方法

• 在Python中的自动调用:

  • 当使用 类名() 创建对象时，为对象 分配完空间后，自动 调用__init__方法
  • 当一个 对象被从内存中销毁 前，会 自动 调用__del__方法

• 生命周期：

  • 一个对象从调用 类名() 创建，生命周期开始
  • 一个对象的 __del__ 方法一旦被调用，生命周期结束
  • 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

class Cat:
    def __init__(self, new_name):

        self.name = new_name

        print('%s 来了' % self.name)

    def __del__(self):

        print('%s 我走了' % self.name)


tom = Cat('Tom')
print(tom.name)

这段代码的执行结果：

# 程序执行完毕前，会释放全局变量 tom 的内存，结束生命周期
Tom 来了
Tom
Tom 我走了

__str__()方法：可以让使用print输出 对象变量 时，能够打印 自定义的内容
在 Python 中，使用print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）
如： <__main__.Cat object at 0x0000021716CE69B0>

使用范例：

    def __str__(self):

        # 必须返回一个字符串
        return '我是小猫'

3 面向对象封装案例

封装

1. 封装 是面向对象编程的一大特点
2. 面向对象编程的 第一步 —— 将 属性 和 方法 封装 到一个抽象的 类 中
3. 外界 使用 类 创建 对象，然后 让对象调用方法
4. 对象方法的细节 都被 封装 在 类的内部

一个对象的 属性 可以是 另外一个类创建的对象

案例一：小明爱跑步

需求:

1. 小明 体重 75.0 公斤
2. 小美 体重 45.0 公斤
3. 小明每次 跑步 会减肥 0.5 公斤
4. 小明每次 吃东西 体重增加 1 公斤

class Person:
    def __init__(self, name, weight):

        # self.属性 = 形参
        self.name = name
        self.weight = weight

    def __str__(self):

        return '我的名字叫 %s ，体重是 %.2f 公斤' % (self.name, self.weight)

    def run(self):
        print("%s 跑步" % self.name)
        self.weight -= 0.5
    def eat(self):
        print("%s 吃饭" % self.name)
        self.weight += 1

xiaoming = Person('小明', 75.0)
xiaomei = Person('小美', 45.0)
xiaoming.run()
xiaoming.eat()
xiaomei.run()
xiaomei.eat()

print(xiaoming)
print(xiaomei)

输出结果：

小明 跑步
小明 吃饭
小美 跑步
小美 吃饭
我的名字叫 小明 ，体重是 75.50 公斤
我的名字叫 小美 ，体重是 45.50 公斤

案例二：摆放家具

需求:
1.房子 (House) 有 户型、总面积 和 家具名称列表

• 新房子没有任何的家具

2.家具 (HouseItem) 有 名字 和 占地面积，其中

• 席梦思 (bed) 占地 4 平米
• 衣柜 (chest) 占地 2 平米
• 餐桌 (table) 占地 1.5 平米

3.将以上三件 家具 添加 到 房子 中
4.打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

class HouseItem:

    def __init__(self, name, area):

        self.name = name
        self.area = area

    def __str__(self):
        return '[%s] 占地 %.2f' % (self.name, self.area)

class House:
    def __init__(self, house_type, area):

        self.house_type = house_type
        self.area = area

        self.free_area = area

        self.item_list = []

    def __str__(self):

        return ('户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s'
                % (self.house_type, self.area,
                   self.free_area, self.item_list))

    def add_item(self,item):

        print('要添加 %s' % item)
        # 1. 判断家具的面积
        if item.area > self.free_area:
            print('%s 的面积太大，无法添加' % item.name)
            return
        # 2. 将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 3. 计算剩余面积
        self.free_area -= item.area

# 1. 创建家具
bed = HouseItem('席梦思', 4)
chest = HouseItem('衣柜', 2)
table = HouseItem('餐桌', 1.5)

print(bed)
print(chest)
print(table)

# 2. 创建房子
my_home = House('两室一厅', 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

案例三：士兵突击

需求:

1. 士兵 许三多 有一把 AK47
2. 士兵 可以 开火
3. 枪 能够 发射 子弹
4. 枪 装填 装填子弹 —— 增加子弹数量

class Gun:

    def __init__(self,model):

        # 1. 枪的型号
        self.model = model

        # 2. 子弹的数量
        self.bullet_count = 0

    def add_bullet(self,count):

        self.bullet_count += count

    def shoot(self):

        # 1. 判断子弹数量
        if self.bullet_count <= 0:
            print('[%s] 没有子弹了...' % self.model)
        # 2. 发射子弹
        self.bullet_count -= 1
        # 3. 提示发射信息
        print('[%s] 发射子弹... [%d]' % (self.model, self.bullet_count))

class Soldier:
    def __init__(self, name):

        # 1. 姓名
        self.name = name
        # 2. 枪 - 新兵没有枪
        self.gun = None

    def fire(self):

        # 1. 判断士兵是否有枪
        if self.gun is None:
            print('[%s] 还没有枪' % self.name)
            return

        # 2. 让枪装填子弹
        self.gun.add_bullet(50)

        # 3. 让枪发射子弹
        self.gun.shoot()

# 1. 创建枪对象
ak47 = Gun('Ak47')

# 2. 创建士兵
xusanduo = Soldier('许三多')
xusanduo.gun = ak47
xusanduo.fire()

4 案例中的知识点

None和身份运算符

定义没有初始值的属性：

在定义属性时，如果 不知道设置什么初始值，可以设置为 None

• None 关键字 表示 什么都没有
• 表示一个 空对象，没有方法和属性，是一个特殊的常量
• 可以将 None 赋值给任何一个变量

身份运算符：
身份运算符用于 比较 两个对象的 内存地址 是否一致 —— 是否是对同一个对象的引用

在 Python 中针对 None 比较时，建议使用 is 判断

运算符	描述	实例
is	is 是判断两个标识符是不是引用同一个对象	x is y，类似 id (x) == id (y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y，类似 id (a) != id (b)

is 与 == 的区别：

• is 用于判断 两个变量 引用对象是否为同一个（内存地址是否相同）
• == 用于判断 引用变量的值 是否相等

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> id(a)
2925512141256
>>> id(b)
2925512141192
>>> a is b
False
>>> a == b
True

5 私有属性和私有方法

应用场景

• 在实际开发中，对象 的 某些属性或方法 可能只希望 在对象的内部被使用，而 不希望在外部被访问到
• 私有属性 就是 对象 不希望公开的 属性
• 私有方法 就是 对象 不希望公开的 方法

定义方法:在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法

class Women:
    def __init__(self, name):

        self.name = name
        self.__age = 18

    # 定义一个私有方法
    def __secret(self):
        # 在对象的方法内部，可以访问对象的私有属性
        print('%s 的年龄是 %d' % (self.name, self.__age))

xiaofang = Women('小芳')
# 私有属性在外界不能被直接访问
# print(xiaofang.__age)
# 私有方法在外界不能被直接访问
# xiaofang.__secret()

伪私有属性和私有方法：
Python中，并没有 真正意义 的 私有
我们可以通过一种处理方式访问到私有属性和方法：
_类名 => _类名__名称

# 伪私有属性
print(xiaofang._Women__age)
# 伪私有方法
xiaofang._Women__secret()

6 继承

面向对象三大特性

1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
2. 继承 实现代码的重用，相同的代码不需要重复的编写
3. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

1.单继承

继承的概念：子类 拥有 父类 的所有** 方法 和 属性**
继承的语法：

class 类名(父类名)：

	pass

• 子类 继承自 父类，可以直接 享受 父类中已经封装好的方法，不需要再次开发
• 子类 中应该根据 职责，封装 子类特有的 属性和方法

继承的传递性：

• C 类从 B 类继承，B 类又从 A 类继承
• 那么 C 类就具有 B 类和 A 类的所有属性和方法
• 子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

2.方法的重写

当 父类 的方法实现不能满足子类需求时，可以对方法进行 重写 (override)

重写 父类方法有两种情况：

1. 覆盖 父类的方法
2. 对父类方法进行 扩展

1) 覆盖父类的方法

• 如果在开发中，父类的方法实现 和 子类的方法实现，完全不同
• 就可以使用 覆盖 的方式，在子类中 重新编写 父类的方法实现

具体的实现方式，就相当于在 子类中 定义了一个 和父类同名的方法并且实现
重写之后，在运行时，只会调用 子类中重写的方法，而不再会调用 父类封装的方法

2) 对父类方法进行 扩展

• 如果在开发中，子类的方法实现 中 包含 父类的方法实现
  • 父类原本封装的方法实现 是 子类方法的一部分
• 就可以使用 扩展 的方式
  • 在子类中 重写 父类的方法
  • 在需要的位置使用super().父类方法 来调用父类方法的执行
  • 代码其他的位置针对子类的需求，编写 子类特有的代码实现

关于 super

• 在 Python 中 super 是一个 特殊的类
• super() 就是使用 super 类创建出来的对象
• 最常 使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现

# 父类
class Dog():
    def bark(self):
        print("汪汪叫")

# 子类，在括号中填入父类的名字
class XiaoTianQuan(Dog):

    def fly(self):
        print('我会飞')

    # 扩展父类的方法
    def bark(self):

        # 1. 针对子类特有的需求，编写代码
        print('神一样的叫唤')

        # 2. 使用 super(). 调用原本在父类中封装的方法
		super().bark()
		# 还有一种老方法： 父类名.方法(self)
		# Dog.bark(self)

        # 3. 增加其他子类的代码
        print('#%$#$%#')

xiaotianquan = XiaoTianQuan()
xiaotianquan.fly()
xiaotianquan.bark()

3. 父类的 私有属性 和 私有方法

1. 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私****有方法
2. 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有****方法

class A:

    def __init__(self):

        self.num1 = 100
        self.__num2 = 200

    def __test(self):
        print("私有方法 %d %d" % (self.num1, self.__num2))

    # 在公有方法中调用自己的私有属性/方法
    def gongyou(self):
        print('父类的共有方法 %d' % self.__num2)

        self.__test()
class B(A):

    def demo(self):
        # 1. 在子类中不能访问父类的私有属性
        #  print("访问父类的私有属性 %d" % self.__num2)
        # 2. 在子类中也不能调用父类的私有方法
        # self.__test()
        # 子类对象 通过 父类 的公有方法 间接 的访问到 私有属性/方法
        self.gongyou()

# 创建一个子类对象
b = B()
b.demo()

4.多继承

概念

• 子类 可以拥有 多个父类，并且具有 所有父类 的 属性 和 方法
• 例如：孩子 会继承自己 父亲 和 母亲 的 特性

class A:

    def test(self):
        print('A -- test 方法')

    def demo(self):
        print('A -- demo 方法')

class B:

    def demo(self):
        print('B -- demo 方法')

    def test(self):
        print('B -- test 方法')

class C(A, B):

    pass

# 创建子类对象
c = C()

# 默认执行A类的方法。因为在clss C(A,B)中 括号内先写的A
c.test()
c.demo()

# 确定C类对象调用方法的顺序
print(C.__mro__)

Python 中的 MRO —— 方法搜索顺序

Python 中针对 类 提供了一个 内置属性 __mro__ 可以查看 方法 搜索顺序
MRO 是 method resolution order，主要用于 在多继承时判断 方法、属性 的调用 路径

print(C.__mro__)

输出结果：

(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

• 在搜索方法时，是按照 __mro__ 的输出结果 从左至右 的顺序查找的
• 如果在当前类中 找到方法，就直接执行，不再搜索
• 如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
• 如果找到最后一个类，还没有找到方法，程序报错

7 多态

面向对象三大特性
↓ ↓ ↓
1.封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中

• 定义类的准则

2.继承 实现代码的重用，相同的代码不需要重复的编写

• 设计类的技巧
• 子类针对自己特有的需求，编写特定的代码

3.多态 不同的 子类对象 调用相同的 父类方法，产生不同的执行结果

• 多态 可以 增加代码的灵活度
• 以 继承 和 重写父类方法 为前提
• 是调用方法的技巧，不会影响到类的内部设计

class Dog():

   def __init__(self,name):
       self.name = name

   def game(self):
       print("%s 蹦蹦跳跳的玩耍...." % self.name)

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

       # 让狗玩耍
   	# 在方法内部直接让 狗对象 去调用 game方法
       dog.game()

# 1. 创建一个 狗 对象
wangcai = Dog("旺财")
xiaotianquan = XiaoTianDog("哮天犬")
# 2. 创建一个 小明 对象
xiaoming = Person("小明")
# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)
xiaoming.game_with_dog(xiaotianquan)

输出结果：

小明 和 旺财 快乐的玩耍...
旺财 蹦蹦跳跳的玩耍....
小明 和 哮天犬 快乐的玩耍...
哮天犬 飞到天上去玩耍...

8 类属性

1. 类的结构

1. 使用面向对象开发，第一步是 设计 类
2. 使用 类名()创建对象，创建对象的动作有两步：
   3. 在内存中为对象 分配空间
   4. 调用初始化方法__init__ 为 对象初始化
3. 对象创建后，内存 中就有了一个对象的 实实在在 的存在——实例

术语表示：

• 创建出来的 对象 叫做 类 的 实例
• 创建对象的 动作 叫做 实例化
• 对象的属性 叫做 实例属性
• 对象调用的方法 叫做 实例方法

结论

每一个对象 都有自己 独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用 传递到方法内部

2. 类是一个特殊的对象

Python 中 一切皆对象：

• class AAA: 定义的类属于 类对象

• obj1 = AAA() 属于 实例对象

• 在程序运行时，类 同样 会被加载到内存

• 在 Python 中，类 是一个特殊的对象 —— 类对象

• 在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例

• 除了封装 实例 的 属性 和 方法 外，类对象 还可以拥有自己的 属性 和 方法

  • 类属性
  • 类方法

• 通过 类名. 的方式可以 访问类的属性 或者 调用类的方法

3. 类属性和实例属性

概念和使用

• 类属性 就是 类对象 中定义的 属性
• 通常用来记录 与这个类相关 的特征
• 类属性 不会用于记录 具体对象的特征

示例需求：

• 定义一个 工具类
• 每件工具都有自己的 name
• 需求 —— 知道使用这个类，创建了多少个工具对象？

class Tool():

    # 使用赋值语句定义 类属性 ，记录所有工具对象的数量
    count = 0

    def __init__(self,name):
        self.name = name

        # 让类属性的值 +1
        Tool.count += 1

# 1. 创建工具对象
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('水桶')

# 2. 输出工具对象的总数
print(Tool.count)

4. 类方法和静态方法

• 类方法 就是针对 类对象 定义的方法
• 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法

定义类方法的语法：

@classmethod
def 类方法名(cls):
    pass

• 类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
• 类方法的 第一个参数 应该是 cls
  • 由 哪一个类 调用的方法，方法内的 cls 就是 哪一个类的引用
  • 这个参数和 实例方法 的第一个参数是 self 类似
  • 提示 使用其他名称也可以，不过习惯使用 cls

1.通过 类名.调用 类方法，调用时不需要传递 cls 参数
2.在方法内部

• 可以通过 cls. 访问类的属性
• 也可以通过 cls. 调用其他的类方法

class Tool():

    # 使用赋值语句定义 类属性 ，记录所有工具对象的数量
    count = 0

    @classmethod
    def show_tool_count(cls):

        print('工具对象的数量 %d' % cls.count)

    def __init__(self,name):
        self.name = name

        # 让类属性的值 +1
        Tool.count += 1

# 创建工具对象
tool1 = Tool('斧头')

# 调用类方法
Tool.show_tool_count()

静态方法：
在开发时，如果需要在 类 中封装一个方法，这个方法：

• 既 不需要 访问 实例属性 或者调用 实例方法
• 也 不需要 访问 类属性 或者调用 类方法
  这个时候，可以把这个方法封装成一个 静态方法

定义静态方法的语法：

@staticmethod
def 静态方法名():
    pass

class Dog():
    # 定义静态方法不需要指定第一个参数（如self、cls）
    @staticmethod
    def run():
        print("小狗要跑...")

# 通过类名，调用静态方法，不需要创建对象
Dog.run()

方法实例：
需求

1.设计一个 Game 类

2.属性：

• 定义一个 类属性 top_score 记录游戏的 历史最高分
• 定义一个 实例属性 player_name 记录 当前游戏的玩家姓名

3.方法：

• 静态方法 show_help 显示游戏帮助信息
• 类方法 show_top_score 显示历史最高分
• 实例方法 start_game 开始当前玩家的游戏

4.主程序步骤

• 1. 查看帮助信息
• 2. 查看历史最高分
• 3. 创建游戏对象，开始游戏

class Game():

    # 类属性：历史最高分
    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()

知识总结：
三种方法的应用场景：

• 实例方法 —— 方法内部需要访问 实例属性，也可以使用 类名. 访问类属性
• 类方法 —— 方法内部 只 需要访问 类属性
• 静态方法 —— 方法内部，不需要访问 实例属性 和 类属性

9 单例

单例设计模式

• 设计模式
  • 设计模式 是 前人工作的总结和提炼，通常，被人们广泛流传的设计模式都是针对 某一特定问题 的成熟的解决方案
  • 使用 设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性
• 单例设计模式
  • 目的 —— 让 类 创建的对象，在系统中 只有 唯一的一个实例
  • 每一次执行 类名() 返回的对象，内存地址是相同的

__new__方法

• 使用 类名 () 创建对象时，Python 的解释器 首先 会 调用 __new__ 方法为对象 分配空间
• __new__ 是一个 由 object 基类提供的 内置的静态方法，主要作用有两个：
  • 1. 在内存中为对象 分配空间
  • 2. 返回 对象的引用
• Python 的解释器获得对象的 引用 后，将引用作为 第一个参数，传递给 __init__ 方法

注意：
重写 __new__方法 一定要 return super().__new__(cls)，否则 Python 的解释器 得不到 分配了空间的 对象引用，就不会调用对象的初始化方法
注意：__new__是一个静态方法，在调用时需要 主动传递 cls 参数

class MusicPlayer():

    def __new__(cls, *args, **kwargs):

        # 1. 创建对象时，__nuw__方法会自动被调用
        print("创建对象，分配空间")

        # 2. 为对象分配空间（new方法是 静态 方法，要传入 cls ）
        instance = super().__new__(cls)

        # 3. 返回对象的引用
        return instance

    def __init__(self):
        print("播放器初始化")

# 创建播放器对象
player = MusicPlayer()
print(player)

单例 的创建
单例 —— 让 类 创建的对象，在系统中 只有 唯一的一个实例

1. 定义一个 类属性，初始值是 None，用于记录 单例对象的引用
2. 重写 __new__ 方法
3. 如果 类属性 is None，调用父类方法分配空间，并在类属性中记录结果
4. 返回 类属性 中记录的 对象引用

# 创建 单例：多个对象只有唯一的实例
# 只执行一次初始化工作
class MusicPlayer():

    # 定义一个类属性，记录第一个被创建对象的引用
    instance = None

    # 再定义一个类属性，记录是否执行过初始化动作
    init_flag = False
    def __new__(cls, *args, **kwargs):

        # 1. 判断类属性是否是空对象
        if cls.instance is None:
            # 2. 调用父类的new方法，为第一个对象分配空间
            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 0x00000194E66179B0>
<__main__.MusicPlayer object at 0x00000194E66179B0>