跳至主要內容

14. 类

Ran原创2025/7/31...大约 80 分钟

1. 面向对象

将程序任务涉及到的事物抽象为一个个的对象，以这些对象为中心来写程序。

1.1 什么是类？

类 和 实例

物以类聚，人以群分

  • 狗是一类动物，具有相同、相似属性。（类）
  • 两只狗，半斤和八两，出生后不会互相影响，彼此是独立的个体。（实例）
  • 当类改变的时候，实例也会受到影响；但实例改变时，不会影响其他实例或者整个类。

1.2 对象，你找到了吗？

  1. 下面是一段错误代码，dog_x 和 cat_x 分别是狗和猫的位置坐标，在检测到用户输入为 “move” 时，让猫和狗都前进 10 的长度。

原代码如下，请修改：

dog_x = 0
cat_x = 0

def dog_move():
    dog_x = dog_x + 10

def cat_move():
    cat_x = cat_x + 10

user_input = input()

if user_input == 'move':
    dog_move()
    cat_move()

个人修改如下：

复盘：

  • 为什么要加上 global？因为 dog_x 是全局变量，如果不加上 global，函数内的 dog_x 会被视为局部变量，无法修改全局变量的值。
  • return 可以不加，因为已经声明为全局变量了，后面输出可以直接使用。
  1. 下面是另一位同学的错误修改，请找出错误：

错误一：局部变量在函数外不能使用；

错误二：每次调用函数，dog_x 和 cat_x 都会被重置为 0，因此每次调用函数的时候，输出结果都是 10，一直在原地踏步。

  1. 现在，除了猫和狗，还要加一个大象，让它也像猫狗一样前进 10。注意：不要机械的写代码，要好好感受一下写代码的时候有什么情绪，这对后续对象的理解有帮助。

感受：类似的东西在重复添加。我们上面定义了三个相似的函数，功能一样，只是变量 名称不一样，没必要创造这么多函数。例如：程序注册新用户，需要用户名、手机号、密码，那是不是要为每一个用户都创建一个函数来储存呢？

2. 一个例子：面向对象的方法

2.1 面向对象代码框架

接下来，我们要使用面向对象的方法来实现前面动物听到用户输入指令 move 就往前跑的功能。

上述代码包含几个内容：

  • 类：一群有相似性的事物的集合，对应 Python 里的 class
  • 对象：集合中的一个事物，对应 class 里生成的一个 object，比如代码中的 dog 和 cat。（其实就是上文提到的实例）
  • 属性：对象的某个静态特征，是自身携带的，比如代码中的 x
  • 函数：对象（实例）的某个动态能力，比如上述代码中的 move() 函数。

2.2 _ _ init_ _(self) 函数

自动调用函数

class Animal():
    def __init__(self):                # 在一个对象生成时会被自动调用的函数
        self.x = 0

验证的代码如下：

class Animal():
    def __init__(self):
        print('init function called')
        
dog = Animal()

#-------output-------
init function called

上述代码中，没有调用 _ _init_ _() 这个函数，但是将 dog 定义在 Animal 这个类别里的时候自动运行了这个函数，即自动调用的函数。类似于一出生就自带的天赋技能。

例子一：创建游戏角色。

每个角色一出生就会自动拥有一些天赋技能，这些技能不是手动添加的，而是角色一出生系统就帮你准备好了。

class GameCharacter():
    def __init__(self):
        print('角色已创建，天赋技能已激活！')

hero = GameCharacter()

#-------output-------
角色已创建，天赋技能已激活！

例子二：

就像我们人类在一诞生的时候，没人教我们怎么呼吸、怎么让心脏跳动——这些能力是与生俱来的，是“出生那一刻就自动开始执行”的。Python 中的 init 方法（函数），就像“呼吸”和“心跳”一样。当我们创建一个新的对象（生命、实例化）时，它会自动执行，不需要我们手动去调用。

class Human():
    def __init__(self):
        print('一个新生命诞生了，正在自动启动呼吸和心跳系统。')

baby = Human()

#-------output-------
一个新生命诞生了，正在自动启动呼吸和心跳系统。

2.3 move(self) 函数

move(self) 函数就是和我们前面将的基本函数的意思、功能是一样的。

只不过这里面是属于类里面的功能函数。

2.4 类当中的 self

2.4.1 非正式讲解1

class Animal():
    def __init__(self):
        self.x = 0
        
    def move(self):
        self.x = self.x + 10

dog = Animal()

if user_input == 'move':
    dog.move()
print('Dog position:', dog.x)

self 指的是本身，在 Animal() 内部，指的就是 Animal() ，当把 Animal() 赋值给 dog 时，dog = Animal = self 。

因此：

  • self.x → Animal().x → dog.x ，这也就解释了 dog.x 可以作为一个变量输出。
  • 要调用 Animal() 里的函数，是 Animal().move() ，又因为上述的等价原因， Animal().move() = dog.move() 。
  • 类里面的每个函数都要加上 self ，代表都属于类的一员，如同家族的族徽，代表都属于家族的一员。
  • 有了 self 这个族徽，意味着家族的资源都可以互相使用。例如：家族的百万棋盘，所有家族成员都可以直接使用，如果不是同一家族的就得看情况了。所以当类里面存在变量，包括各个函数的变量，如果在变量的前面加上 self(self.x) ，则在类中，所有函数都可以随时调用变量 self.x ，在函数内外都可以访问。

注意：

  • 在常规函数中，每个函数都是独立的。函数和函数之间的变量，不能互相调用，除非使用全局变量 global 来解决。
  • 在类中的函数同理，也是独立的，函数与函数之间的变量依然不能直接共有，需要借助 self 来实现类里面的函数变量共用。

这里给出一个类中没有使用 self 创建变量，导致无法相互调用的例子：

class Demo():
    def function1(self):
        string = 'Hello World'
        print(string)
        
    def function2(self):
        print(string)

demo = Demo()
demo.function1()
demo.function2()     # 此处会报错 name 'string' is not defined

上述代码加上 self 就可以了：

2.4.2 非正式讲解2

**注意： **

在类里面的函数，第一个参数都必须写 self !

2.4.3 正式讲解：什么是 self ？

2.4.4 self 存在的意义

  • 原因一：代表自己
  • 原因二：资源共享，没有 self 不能实现资源共享。

以下代码可以看出，dog 和 self 实际为同一个变量：

class Animal():
    def __init__(self):
        self.x = 0
        print(f'self address: {self}')

dog = Animal()
print(f'dog address: {dog}')

#-------output-------
self address: <__main__.Animal object at 0x000001FB0AC48F40>
dog address: <__main__.Animal object at 0x000001FB0AC48F40>

2.5 _ _init_ _ 初始化参数

2.5.1背景

类似宝宝出生前想名字

_ _init_ _ 函数的所有参数，全部在类的实例化时传入。即上述代码中的 baby1 = Baby(name='棠棠') 。

2.5.2 为什么要写 self.XXX = XXX ？背后发生了什么？

问题一：为什么传进参数 name，还要把 name 赋值给 self.name

问题二：为什么不直接 name = name ，还要用 self

问题三：为什么“点”后面的变量名称和参数同名，不同名可以吗？

回答一：从外面引入一个参数，需要找到一个地方存放，所以需要使用 self.name = name 进行存放。

回答二：并且，这个函数需要在类内的函数间共用，因此需要一个地方来存放这个共用的函数，并且加上 self 使其能共用

回答三：叫其他变量名可以，但是本身变量名是“见名知意”，且指代的是同一个东西，因此不需要再想一个合适的变量名。示例如下：

class Baby():
    def __init__(self, name):

        self.name = name
        self.username = name
        print(f'init name: {self.name}, username: {self.username}')
    
baby1 = Baby('棠棠')

#-------output-------
init name: 棠棠, username: 棠棠

小结：

2.5.3 参数设定后必须传入

在初始化时，如果设定了参数，那么将类实例化时必须将该参数传入，否则会报错。

class Baby():
    def __init__(self, name):

        self.name = name
        self.username = name
        print(f'init name: {self.name}, username: {self.username}')

baby1 = Baby()

#-------output-------
TypeError: __init__() missing 1 required positional argument: 'name'

2.5.4 传入多个参数

2.5.5 设置默认值

class Baby():
    def __init__(self, name = '小悦', gender = '男'):
        print(f'大家好，我叫{name}, 我是一个{gender}宝宝。')

baby1 = Baby()

#-------output-------
大家好，我叫小悦, 我是一个男宝宝。

设置默认值的要求和函数一样，一旦设置了默认值，后面就必须都设置默认值，否则会报错。

默认值也可以设置为 None ，具体如何设置要看使用需求。

上述代码可以进一步优化：

2.6 类实例化时：指定传参和位置传参

类的传入的三种原则：

  1. 全部不指定参数

    baby1 = Baby('棠棠', '女')

  2. 全部指定参数

    baby1 = Baby(name = '棠棠', gender = '女')

  3. 部分指定参数，只能从前面不指定，一旦开始指定，后续参数都要指定，否则会报错。

    baby1 = Baby('棠棠', gender = '女')

    下述情况会报错：

    baby1 = Baby(name = '棠棠', '女')

  4. 参数也可以通过变量传递进去

    name = input("Enter your name: ")
gender = input("Enter your gender: ")
age = input("Enter your age: ")
weight = input("Enter your weight: ")
baby1 = Baby(name, gender, age, weight)
baby2 = Baby(name=name, gender=gender, age=age, weight=weight)

    baby2 里面，= 左面是类内包含的变量名，= 右面是作为变量名，通过指定的方式传入到里面，两者长的一样，其实是不同的。

3. 小试牛刀

3.1 宠物管理系统

题目要求： 请你用面向对象的方式编写一个宠物管理系统的雏形，完成以下功能：

  1. 创建一个类 Pet
    • 属性：
      • name（宠物名字，字符串）
      • age（宠物年龄，整数）
      • species（宠物种类，字符串，比如“狗”、“猫”）
    • 方法：
      • show_info()：打印宠物的基本信息（格式自定义）。
      • birthday()：宠物过生日，年龄加 1，并打印“xxx 过生日啦，现在 xxx 岁了！”
  2. 编写主程序
    • 创建 2 个不同的宠物对象（属性不同）
    • 分别调用 show_info() 方法展示它们的基本信息
    • 给其中一个宠物调用一次 birthday() 方法，并再次展示它的信息

运行示例（仅供参考）：

小白 这只狗今年 2 岁。
小黑 这只猫今年 3 岁。
小白 过生日啦，现在 3 岁了！
小白 这只狗今年 3 岁。
小黑 这只猫今年 3 岁。

回答：

3.2 银行账户管理系统

题目要求： 请你使用面向对象的方式，设计一个简单的银行账户类，完成以下功能：

  1. 创建一个类 BankAccount
    • 属性：
      • owner（账户持有人姓名，字符串）
      • balance（账户余额，浮点数，默认 0）
    • 方法：
      • show_balance()：打印当前账户余额。
      • deposit(amount)：存钱到账户，金额必须大于 0，否则提示“存款金额必须大于 0”。
      • withdraw(amount)：取钱，金额必须大于 0 且不能超过当前余额，否则提示“余额不足或金额无效”。
  2. 主程序
    • 创建一个账户对象（姓名自定义，初始余额可以为 0）。
    • 进行一次存款操作（金额自定义）。
    • 进行一次取款操作（金额自定义）。
    • 最后显示账户余额。

运行示例（仅供参考）：

账户持有人：张三
当前余额：￥0.0
存入 ￥1000.0 成功！
当前余额：￥1000.0
取出 ￥500.0 成功！
当前余额：￥500.0

回答：

3.3 题目：交互式银行账户系统（扩展版）

题目要求： 在上一个 BankAccount 类的基础上，编写一个交互式控制台程序，让用户可以自己输入指令完成存款、取款、查看余额、退出系统等操作。

  1. 类 BankAccount（和之前基本一样）：

    • owner（账户持有人姓名）
    • balance（账户余额，默认 0）
    • show_balance()：显示余额
    • deposit(amount)：存款
    • withdraw(amount)：取款

  2. 主程序交互功能：

    • 用户输入账户持有人姓名（创建账户）

    • 进入循环菜单：

      请选择操作：
1. 存款
2. 取款
3. 查看余额
4. 退出

    • 根据用户输入的选项执行对应功能

    • 用户输入 4 时退出系统

  3. 运行示例（参考）：

回答：

版本一：

问题：存款后信息无法保留

原因：存款之后，因为是 while 循环，所以又回到了 line 26 那里重新创建账户，所以改动无法留存。

优化：将多个 if 连用改成 elif ，节省判断次数，因为多个 if 需要每个都判断一下，但是 elif 判断成立后，后面的就不会再执行了。

其他方法：

可以用 while True 和 break 搭配结束循环。

4. 类里面的函数传入参数

  1. 传入一个参数
class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self, times):
        print(f'{self.name}汪 ' * times)

my_dog = Dog('小黑')
my_dog.bark(3)

#-------output-------
小黑汪 小黑汪 小黑汪
  1. 传入多个参数

5. 通过实例化对象改属性值

修改前的信息：

修改：

通过直接变量赋值就可修改，如 person1.weight = 80 。

6. 类的私有属性

why 私有？例如手机密码，面部识别等，只有自己才能访问这些信息。同样，python 的类中，需要保护一些内部数据，不希望从外部就能轻易访问和修改，此时就会用到私有属性。

6.1 什么是私有属性？

在 Python 中，以双下划线（__ ）开头的属性为私有属性，保护类内部的重要数据。我们不是希望别人完全访问不到这些数据，而是希望别人通过类的方法来间接的访问或修改这些数据，这样就能在方法中进行额外的逻辑控制，比如检查输入是否正确、访问记录日志等。

6.2 现实举例：手机密码与解锁

代码提示：

# 创建一个手机对象，设置密码为：'123456'，私密数据为：我的秘密照片和聊天记录
my_phone = Phone("123456", "我的秘密照片和聊天记录")

# 我尝试直接访问数据，结果会失败（不能直接访问私有属性）
# print(my_phone.__data)  # 错误！无法访问，报错：AttributeError: 'Phone' object has no attribute '__data'

# 正确的访问方法：使用类提供的方法（函数）进行调用私有属性的值
data = my_phone.unlock("123456")  # 输入正确的密码
print("手机中的数据是：", data)

data = my_phone.unlock("wrong_password")  # 输入错误的密码
print("手机中的数据是：", data)

个人代码：

修改优化：

  • 代码中更适合用 return ，而非 print，print 只是把内容显示出来而已。

小贴士：

  1. 手机密码相当于类的私有属性，外人不能轻易查看，相对应的数据也是私有属性。
  2. 手机解锁的动作，相当于类规定的方法，通过这个方法可以访问未被公开的数据，这个方法也决定了哪些可以公开，哪些受到保护。

6.3 为何使用私有属性？

安全性：防止外人随意打开

隐私性：防止外人随意查看内容

保护性：防止里面的内容损毁

控制性：有钥匙或密码，能决定什么时候打开，什么时候关上

6.4 如何访问私有属性？

Python 的私有属性并非绝对私有，可以通过特殊方法访问（不建议）

# 通过特殊语法访问
print(my_phone._Phone__data)    # 输出为：我的秘密照片和聊天记录

还可以通过这种方法来修改属性值：

# 修改私有数据
my_phone._Phone__data = '新的数据'
print(my_phone._Phone__data)

#-------output-------
新的数据

在实际开发中，不建议这么做，这种特殊访问方式仅在调试或者特殊情况下使用。

7. 小试牛刀

Answer

8. 类内部的变量如何共用

在类中，需要定义一些固定不变的变量，比如常量。这些常量每个对象都会用到，是否需要每次创建对象时都构建一次呢？

不需要！

只要在类的内部合适的位置定义好，就能实现类内变量共用。

8.1 类中的常量（类变量）

类似社团有统一的口号，python 中也有统一的口号，我们成为类变量。只需要定义一次，所有对象可以共享。

8.2 函数之间的局部变量无法共用

现实生活中，人们的私有物品不能共用，函数也一样，只能在函数内部使用，无法被其他函数直接访问。

def function_a():
    a = 10 
    print(f'function_a 的变量 a 是：', a)
    
def function_b():
    print(a)   # 这里会报错，因为无法访问function_a 的局部变量 a

加上一个全局变量就能共用，例如：

BOOK_NAME = '跟AI悦创学习最前沿的编程思维和人工智能'      # 全局变量，任何函数都能造访

def function_a():
    print(f'function_a 正在读书：', BOOK_NAME)

def function_b():
    print('function_b 正在读书：', BOOK_NAME)   

function_a()
function_b()

8.3 类内部变量各个函数随意调用

示例如下：

使用全局变量的影响

不使用 self 而使用全局变量的问题：全局变量会被更改。

count = 0

def increment():
    global count
    count += 1
    
def get_count():
    return count

increment()
print(get_count())    # 输出为1，而不是0

小结与回顾

变量类型定义位置作用域举个生活中的例子
局部变量函数内部本函数内有效自己的私人用品，别人不能随意拿
全局变量函数外部所有函数都有效公共的物品，比如图书馆的书
类变量类的内部，方法之外类内所有对象都有效社团共有的口号
实例变量类的方法内，通过self定义单个对象内所有方法有效家庭内部共享的冰箱

8.4 类内部的函数互相调用

类内部的变量可以共享，那么类内部的函数也可以共享。

比如家里准备晚饭，有三个任务：

  • 妈妈准备食材
  • 爸爸烹饪
  • 孩子摆放餐桌

此时，爸爸的任务中需要调用到妈妈任务中准备的食材。

8.4.1 第一步：定义多个方法

class FamilyDinner:
    def prepare_ingredients(self):
        print('妈妈正在准备食材：洗菜、切菜、准备调料。')
    
    def cook_food(self):
        print('爸爸开始烹饪了！')
        self.prepare_ingredients()     # 调用准备食材的方法
        print('爸爸正在烹饪菜肴：炒菜、煮汤。')
        
    def set_table(self):
        print('孩子正在摆放餐桌。')

8.4.2 第二步：方法之间如何调用

dinner = FamilyDinner()

dinner.cook_food()
dinner.set_table()

#-------output-------
爸爸开始烹饪了！
妈妈正在准备食材：洗菜、切菜、准备调料。
爸爸正在烹饪菜肴：炒菜、煮汤。
孩子正在摆放餐桌。

调用时，在需要调用的内部函数前添加 self. 即可实现类内部的函数调用，因此只需要使用类中的2个函数就可实现3个函数的功能。

8.4.2 继承，是每个富二代的梦想「选学」

提示：接下来的继承内容，一时间看不懂学不会没有事的，完全不影响你入门 Python。

既然类是一群相似的对象的集合，那么可不可以是一群相似的类的集合呢？

接下来，我们来看第三个问题，既然类是一群相似的对象的集合，那么可不可以是一群相似的类的集合呢？

答案是，当然可以。只要抽象得好，类可以描述成任何事物的集合。当然你要小心、严谨地去定义它，不然一不小心就会引起第三次数学危机 XD（维基百科：https://en.wikipedia.org/wiki/Russell%27s_paradox。

类的继承，顾名思义，指的是一个类既拥有另一个类的特征，也拥有不同于另一个类的独特特征。在这里的第一个类叫做子类，另一个叫做父类，特征其实就是类的属性和函数。

我们同样结合代码来学习这些概念。在这段代码中，Document 和 Video 它们有相似的地方，都有相应的标题、作者和内容等属性。我们可以从中抽象出一个叫做 Entity 的类，来作为它俩的父类。

首先需要注意的是构造函数。每个类都有构造函数，继承类在生成对象的时候，是不会自动调用父类的构造函数的，因此你必须在 init() 函数中显式调用父类的构造函数。它们的执行顺序是 子类的构造函数 -> 父类的构造函数。

其次需要注意父类 get_context_length() 函数。如果使用 Entity 直接生成对象，调用 get_context_length() 函数，就会 raise error 中断程序的执行。这其实是一种很好的写法，叫做函数重写，可以使子类必须重新写一遍 get_context_length() 函数，来覆盖掉原有函数。

最后需要注意到 print_title() 函数，这个函数定义在父类中，但是子类的对象可以毫无阻力地使用它来打印 title，这也就体现了继承的优势：减少重复的代码，降低系统的熵值（即复杂度）。

到这里，你对继承就有了比较详细的了解了，面向对象编程也可以说已经入门了。当然，如果你想达到更高的层次，大量练习编程，学习更多的细节知识，都是必不可少的。

9. 练习

9.1 个人回答

9.2 老师思路

优化：

  • 玩家和敌人都可以当做是对象，因此初始化时可以把敌人也当做是类似对象的实例。
import random

class Creature():
    def attack(self):
        attack_value = random.randint(1, 50)
        return attack_value
    
player = Creature()
enemy = Creature()

此处需要考虑类究竟如何使用，玩家和敌人都是类似的对象，因此可以通过类将其实例化出来。

  • 游戏继续的条件是玩家和敌人都还活着，因此可以建立一个 while 函数，条件就是 player.not_dead() and enemy.not_dead() ，此处又存在共性，所以可以在类中建立一个函数看玩家和敌人是否都存活。
  • 当需要编写 not-dead 函数时，我们发现判断是否死亡的标准是血量，但是目前还没有血量这个参数，因此，可以在实例化的时候将血量当做参数传进去，就需要了 init 函数，此时再编写 init 函数，并加入需要的参数。
  • 有了 hp 就可以编写 not_dead 这个函数了，即血量＞0 为 True。
    def not_dead(self):
        if self.hp > 0:
            return True
        else:
            return False

继续优化：

上述代码是为了当符合某种条件时，返回我们指定的结果，从比较运算符处可知，运行的结果是布尔类型 ，恰好和我们本身希望返回的结果是一致的，因此可以优化成直接返回比较的结果，即 return self.hp > 0 。

  • 疑问点：是否需要写 defence？感觉逻辑复杂不通。

自己继续上述思路补充的后续代码如下：

以上代码暂时保留，继续老师思路：

  • 有hp 值，下一步可以继续实现交互
 if user_input == 'A':
        player_attack_value = player.attack()
        enemy_attack_value = enemy.attack()

上述代码有了，我们想到，无论敌人或玩家，都有收到攻击的情节，因此可以继续写一个函 能够实现player.being_attack(enemy_attack_value) 。

   def being_attack(self, attack_value):
        self.hp -= attack_value

因此，主程序处进行攻击和防守就可写成：

    if user_input == 'A':
        player_attack_value = player.attack()
        enemy_attack_value = enemy.attack()

        enemy.being_attack(player_attack_value)
        player.being_attack(enemy_attack_value)

    elif user_input == 'D':
        enemy_attack_value = enemy.attack()
        player.being_attack(enemy_attack_value * 0.1)      # 因为不同软件对除法的处理略有不同，更倾向使用乘法而不是除法
  • 运行代码后，发现没有血量、不知道游戏进程、不知道游戏何时结束。首先补充血量显示：

显示血量在什么位置呢？A or B or C or D

选择显示血量的代码位置时，首先需要判断在循环内外，由于血量需要实时更新，因此需要在循环内。

其次，在操作前要根据血量判断执行什么操作，因此放在 user_input 之前。

while player.not_dead() and enemy.not_dead():
    # 此处添加血量显示
    print()
    user_input = input('Attack or Defence (A/D): ')          # 操作
    if user_input == 'A':
        player_attack_value = player.attack()
        enemy_attack_value = enemy.attack()

        enemy.being_attack(player_attack_value)
        player.being_attack(enemy_attack_value)

    elif user_input == 'D':
        enemy_attack_value = enemy.attack()
        player.being_attack(enemy_attack_value * 0.1)      # 因为不同软件对除法的处理略有不同，更倾向使用乘法而不是除法
  • 可以把显示血量写成一个函数
    def show_status(self):
        print(f'HP: {self.hp}')

主程序调用

while player.not_dead() and enemy.not_dead():
    player.show_status()
    enemy.show_status()
    user_input = input('Attack or Defence (A/D): ')          # 操作
  • 显示血量的时候发现不知道哪个是哪个的血量，如何解决？

需要名字这个变量，那就初始化的时候传进去：

    def __init__(self, name, hp):
        self.name = name
        self.hp = hp
        
    def show_status(self):
        print(f"{self.name}'s HP: {self.hp}")
player = Creature('Ran',100)
enemy = Creature('Monster',80)
  • 添加判断游戏结果的代码，放在循环结束后：
if player.hp > 0:
    print(f"You win! Your HP: {player.hp}")
else:
    print(f"You lose!")

疑问：什么时候选择写成函数？

  1. 需要重复使用，存在共性的东西，比如玩家有多个，不需要写多个 print 来显示血量。
  2. 有封装需求，方便后期统一修改维护。
  3. 若写在主程序里，修改时可能需要捋前后代码逻辑，输出可能变动，若封装成函数，只要保证 return 不变，主函数的代码出错的概率将会大大减少。

9.3 对自己的代码进行修改

对自己写的代码进行修改：

  • 玩家姓名可以当做参数传入类中，在初始化步骤中完成，也可对敌人起名。
class Creature():
    # 初始化姓名、HP
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp

因此，后续程序中，可以添加 Creature(player_name, 100) 和 Creature(Enemy, 80) 创建玩家和敌人。

player_name = input('请输入玩家姓名：')
player = Creature(player_name, 100)             # 创建玩家并完成初始化
enemy = Creature('Monster', 80)          # 创建敌人并初始化

个人代码修改如下：

优化：

  • 函数命名尽量不要用大写，修改如下
def show_hp(self):                                     # 显示血量
        print(f"{self.name}'s HP: {self.hp}")
  • 函数的注释可以直接在函数内第一行加三个双引号，如下：
    def being_attack(self, harm, action):
        """
        被攻击时的血量变化
        :param harm: 伤害值
        :param action: "A" 表示攻击；"D" 表示防守
        """
        if action == "D":
            self.defence(harm)
        else:
            self.hp -= harm

其中，:param 是形参，可以对传入的参数进行注释。

9.4 功能扩展

9.4.1 优化血量的显示效果

    def show_status(self):
        print(f"{self.name}'s HP → {self.hp}")

9.4.2 血量问题：会出现负数的情况

如何验证血量负数情况？

两个方向：扩大减血的范围，将0.1改掉；在输掉的时候显示血量。

You lose! Your HP: -1.800000000000023

同理，也可以在结果出输出敌人血量：

You win! Enemy HP: -1

此外，也可以修改 while 的条件，只保留玩家不死的条件，玩家一直攻击，敌人很快血量变复数，但是此时循环还未结束，显示血量 show_status() 阶段，会出现负数的敌人血量。

Ran's HP → 100
Monster's HP → 80
Attack or Defence (A/D): A
Ran's HP → 70
Monster's HP → 36
Attack or Defence (A/D): A
Ran's HP → 64
Monster's HP → -6
Attack or Defence (A/D): A
Ran's HP → 36
Monster's HP → -32

如何修改血量是负数的情况？

思路：什么时候会出现负数？减血量的时候。

方法一：判断伤害值和剩余血量，伤害值高，血量归零，伤害值低，正常减：

    def being_attack(self, attack_value):
        if attack_value >= self.hp:
            self.hp = 0
        else:
            self.hp -= attack_value

方法二：先进行减血，若减出负数，则进行归零处理：

    def being_attack(self, attack_value):
        self.hp -= attack_value
        if self.hp <= 0:
            self.hp = 0

方法三：使用 max() 函数

int(self.hp-attack_value) 此处可能是负数，也可能是正数，但是 max() 做到了从两个元素中取最大值，因此该值是负数的时候，总会取到最大值 0 ，因此也可以实现血量的控制。

    def being_attack(self, attack_value):
        """受到伤害（向下取整避免血量显示为浮点数，并且保证了血量不会出现负数"""
        self.hp = max(0, int(self.hp-attack_value))

9.4.3 用户输入控制

要对用户输入可能出现的空格和小写控制，并且当输入错误时，可以实现重新输入：

user_input = input('Attack or Defence (A/D): ').strip().upper()
    while user_input not in ('A', 'D'):
        user_input = input('输入无效，请重新输入 A 或 D').strip().upper()

9.4.4 敌人状态随意

敌人是随机状态，有可能是攻击，有可能是防守。如果敌人是防守状态，受到玩家伤害减半。

  1. 初步实现
enemy_status = random.choice(['A', 'D'])
        if enemy_status == 'D':
            enemy.being_attack(0.5 * player_attack_value)
  1. 在玩家的操作中实现

玩家攻击时实现如下：

    if user_input == 'A':
        enemy_status = random.choice(['A', 'D'])
        if enemy_status == 'D':
            print(f'{enemy.name} chose to defend!')
            player_attack_value = 0.5*player.attack()
        else:
            print(f'{enemy.name} chose to attack!')
            player_attack_value = player.attack()
            enemy_attack_value = enemy.attack()
            player.being_attack(enemy_attack_value)
            
        enemy.being_attack(player_attack_value)

当玩家防守时，应该如何实现？

目前完整代码：

9.4.5 改良实现

  • 可优化点一：玩家进行攻击操作时，无论敌人什么状态（攻击or防守），玩家都要攻击，敌人一定会减血。

    优化前
        if user_input == 'A':
        enemy_status = random.choice(['A', 'D'])
        if enemy_status == 'D':
            print(f'{enemy.name} chose to defend!')
            player_attack_value = 0.5*player.attack()
        else:
            print(f'{enemy.name} chose to attack!')
            player_attack_value = player.attack()
            enemy_attack_value = enemy.attack()
            player.being_attack(enemy_attack_value)

        enemy.being_attack(player_attack_value)

  • 可优化点二：玩家选择攻击后要判断敌人状态，玩家选择防守时也同样要判断敌人状态，都需要生成一个表示敌人状态的变量。

    优化前

当我们优化后，发现第一个优化其实意义不大，但是在实际开发中就是如此，你更新了一个新的功能或代码，客户、用户觉得没必要，但是我们也懒得改回去。

目前完整代码：

9.4.6 游戏策略升级

当前游戏策略并不完备。

因为玩家防守时，敌人必须要攻击，不能两个人都防守。

因此优化为：玩家防守，敌人必攻击！

玩家防守情况中的代码可以还原为前面的版本，里面不再包含判断敌人状态的步骤。

    elif user_input == 'D':
            print(f'{enemy.name} chose to attack!')
            enemy_attack_value = 0.1*enemy.attack()
            player.being_attack(enemy_attack_value)

发现：可能最开始的是最好的。

目前完整代码：

9.4.7 玩家回血技能

当玩家血量低于50%时，提示玩家可以输入“H”来使用治疗技能，直接回血 100% （满血）。

要求：

  1. 只能使用一次！
  2. 无法随时使用回血技能，只有在提示出现时才能够使用。
  3. 血量低于一般按照初始化传入的参数决定，随其变化。

第一步：增加初始血量值

个人方法
player = Creature('Ran',100)
enemy = Creature('Monster',80)
player_initial_hp = player.hp         # 这里是一个值，成立，若是字典/列表则需要考虑深浅拷贝问题

第二步：类里增加一个函数

    def heal_full(self):
        """直接回到初始满血"""
        self.hp = self.max_hp

第三步：显示血量的函数随之可以优化，显示当前血量/原始血量。

    def show_status(self):
        print(f"{self.name}'s HP → {self.hp/self.max_hp}")

第四步：因为只能提示一次，所以增加一个变量 heal_used 判断是否显示过了。个人修改时纠结的问题在于，在循环内设置了这个变量，那么循环时会被覆盖，重新初始化，解决的方法就是把这个变量放到循环外面。

player = Creature('Ran',100)
enemy = Creature('Monster',80)
heal_used = False

后面具体实现过程如下：

个人代码
    if (player.hp < player.max_hp*0.5) and (not heal_used):    # 原本包含2个if ，可以通过 and 的使用进行合并
        recover = input('血量低于 50% ，可以输入 H 使用治疗技能，直接恢复满血状态：').strip().upper()
        if recover == 'H':
            player.heal_full()
        heal_used = True

目前完整代码：

个人完整代码

但是上述老师的代码也有个小问题，如果没有选择回血的话，就会一直提示可以使用回血。如果我们希望这个提示和回血的选择只出现一次，就是过这村没这店的情况，就可以将 heal_used = True 从玩家选择 H 的判断中提出来，可以放在提示出现后。

此外，在将回血功能加入时，需要考虑用户输入 H 的情况，那么可以在用户输入的提示语上进行修改，代码如下：

9.4.8 回血技能代价

回血是有代价的，如果玩家使用了回血技能，后续敌人一定会攻击，并且攻击将翻倍。

可以在敌人攻击时，判断回血技能是否使用，如果使用了，那么攻击 乘2。

下述代码是在 heal_used = True 放在输入是 H 下的判断中的情况：

如果我们想要指定“过这村没这店”的情况，那么像我们上面提到过的 heal_used = True 被提到外面，就需要将“提示过”和“使用回血”区分开，因此需要引入一个新变量 heal_penalty_active ，具体代码如下：

目前完整代码如下：

其他优化：警告只显示一次如何处理？

解决方法：将警告移到 H 里面即可：

    if user_input == 'H':
        # 只有在 can_heal_now 为 True 时才会进入这里
        print('你使用了治疗技能，血量已经回满。')
        player.heal_full()
        heal_penalty_active = True             # 触发治疗代价
        print('【警告】治疗代价生效中，敌人对你的伤害 ×2 ！')

9.4.9 血量进度条

老师示例

  • 完整代码：

  • 注释：

补充知识：

Python 保留指定位数的小数

四舍五入的取整 round()

个人代码：

只对 show_status 这个函数进行修改。

    def show_status(self):
        max_hp_bar = round(self.max_hp/10)
        now_hp_bar = round((self.hp / self.max_hp) * max_hp_bar)
        hp_bar = (now_hp_bar * '█')+((max_hp_bar-now_hp_bar) * '░')
        print(f"{self.name}'s HP → {hp_bar} {self.hp}/{self.max_hp}")

老师代码：

精简代码

下面把这个无色进度条实现逐行、逐个设计点讲清楚。先放原函数，后面按行解释与举例：

def hp_bar(cur: int, maxv: int, width: int = 20) -> str:
    """返回形如：[##########----------] 50%  50/100 的进度条文本"""
    if maxv <= 0:
        maxv = 1
    cur = max(0, min(cur, maxv))
    ratio = cur / maxv
    filled = int(ratio * width + 0.5)  # 四舍五入
    bar = "#" * filled + "-" * (width - filled)
    return f"[{bar}] {int(ratio * 100):3d}%  {cur}/{maxv}"

  • 逐行说明：

    1. def hp_bar(cur: int, maxv: int, width: int = 20) -> str:

      • cur：当前血量（current HP）；

      • maxv：最大血量（最大/满血）；

      • width：进度条宽度（字符格数），默认 20 格；

      • 纯 ASCII，不含颜色和特殊字符，Mac/Windows 任何终端都能显示。

    2. 代码：

      if maxv <= 0:
    maxv = 1

      • 防御式编程：避免出现 maxv == 0 导致后面 cur / maxv 除零错误。

      • 设置为 1 的意义：即便出现异常的“最大血量 ≤ 0”，也能安全渲染一个最小尺度的进度条。

    3. cur = max(0, min(cur, maxv))

      • 钳制（clamp）当前值到合法范围 [0, maxv]：
        • 过量伤害导致的负值 → 拉回 0；
        • 加成/溢出治疗导致的超上限 → 拉回 maxv。
      • 这样可保证后续计算的比例和绘制不会越界。

    4. ratio = cur / maxv

      • 计算当前血量占比（0.0 ~ 1.0）。
      • 由于上一步已钳制，ratio 一定在合法区间内。

    5. filled = int(ratio * width + 0.5) # 四舍五入

      • 计算应该填充多少格（# 的数量）。
      • ratio * width 给出“理想填充格数”的小数值；我们希望四舍五入到最近的整数。
      • 用 int(x + 0.5) 而不是 round(x) 的原因：
        • Python 的 round 是银行家舍入（.5 向最近的偶数靠拢），例如 round(8.5) == 8；
        • int(x + 0.5) 是更直觉的 “.5 及以上进一”：
          • 例：8.5 → int(9.0) = 9。
        • 因为 ratio * width 永不为负，此写法简单稳定。

    6. bar = "#" * filled + "-" * (width - filled)

      • 构造条形：左边 # 表示当前血量，右边 - 表示未填充部分。
      • 字符串乘法快速生成重复字符，O(width) 时间复杂度，足够轻量。

    7. return f"[{bar}] {int(ratio * 100):3d}% {cur}/{maxv}"

      • 最终文本包含三部分：
        1. 方括号包裹的条形：[##########----------]
        2. 百分比：{int(ratio * 100):3d}%
          • 这里用 int() 而不是四舍五入：显示上更“保守”（例如 99.6% 显示 99%）。
          • :3d 保证宽度 3 —— “ 5% / 50% / 100%”对齐更整齐。
        3. 数值形式：cur/maxv（例：50/100），便于精确查看。

    14.21.3 小例子（心算即可）

    以 width = 20 为例：

    • cur=0, maxv=100
      • ratio=0；filled=int(0*20+0.5)=0
      • 条：[--------------------] 0% 0/100
    • cur=73, maxv=100
      • ratio=0.73；filled=int(0.73*20+0.5)=int(14.6+0.5)=15
      • 条：[###############-----] 73% 73/100（15 个 #，5 个 -）
    • cur=99, maxv=100
      • ratio=0.99；filled=int(19.8+0.5)=20 → 条会满格
      • 百分比 int(99)=99% → 可能出现“条已满但显示 99%”的轻微不一致（可接受）
    • cur=100, maxv=100
      • ratio=1.0；filled=int(20+0.5)=20
      • 条：[####################]100% 100/100
    • 越界情况：cur=-5 → 钳成 0；cur=120 → 钳成 100。

为什么它“跨平台稳”

  • 只用 ASCII（#、-、[]），不依赖颜色、宽字符或终端转义序列；
  • 不需要检测终端是否支持 ANSI 颜色，CMD / PowerShell / macOS 终端都能正常显示；
  • 横向对齐通过固定 width 和百分比字段宽度 :3d 达成。

可按需的小改动（可选）

  1. 让百分比与条形一致地“四舍五入”（而非取整）：

    pct = int(ratio * 100 + 0.5)
return f"[{bar}] {pct:3d}%  {cur}/{maxv}"

    这样 99.6% 会显示为 100%。

  2. 依据条形反推百分比（绝对一致）：

    pct = int((filled / width) * 100 + 0.5)

    这样条满一定显示 100%。

    此处考虑玩家更依赖 50/100 的血量显示，因此条形和百分比的作用类似，且重要程度相当，所以可以保持一致。

    条形反推百分比
    pct = int((filled / width) * 100 + 0.5)

    其实在做一件很朴素的事：先看条形图实际“点亮了几格”（filled），再把它换算成百分比，最后做一个四舍五入。

    1. 一句话版

    进度条是“离散”的（比如一共 20 格，只能亮 0,1,2,…,20 格）。

    既然条形显示是按“亮了几格”来的，那百分比也用亮格数去算，保证两者完全一致。

    2. 为什么要“依据条形反推百分比”？

    如果用真实比例算百分比，比如：

    ratio = cur / maxv
pct = int(ratio * 100)   # 或 round(ratio * 100)

    而条形格数却是：

    filled = int(ratio * width + 0.5)   # 四舍五入到最近的格子

    这两处独立四舍五入，就可能出现不一致：

    • 例子1（width=20）：
      cur=49, maxv=100 → ratio=0.49

      • 条形格数：filled = int(0.49*20 + 0.5) = int(9.8 + 0.5) = 10（亮 10/20 格 = 50% 的“视觉”）

      • 百分比（真实比例取整）：int(0.49*100) = 49%

        ⇒ 条形看起来是 50%，数字却写 49% —— 违和。

    • 例子2（width=20）：
      cur=99, maxv=100 → ratio=0.99

      • 条形格数：filled = int(0.99*20 + 0.5) = 20（满格）

      • 百分比（真实比例取整）：int(99) = 99%

        ⇒ 满格但写 99% —— 又违和。

    所以，用条形→百分比就不会有这种分裂： filled/width 是条形真正表达的占比，乘以 100 就是“条形所代表的百分比”。

    3. 这行代码逐词解释

    pct = int((filled / width) * 100 + 0.5)

    • filled / width：条形实际的占比（比如 10/20 = 0.5）。

    • * 100：把占比变成百分数（0.5 → 50）。

    • + 0.5 再 int(...)：对非负数实现“四舍五入”。

      （因为 int(x+0.5) 等价于把 x 四舍五入到最近整数。）

    这样得到的 pct，一定和你当前显示的格数对应的百分比一致。

    例如 filled = 10, width = 20 → pct = 50；filled = 20 → pct = 100。

    4. 何时该用这种写法？

    • 你**希望数字和进度条外观“绝对一致”**时，用它！
    • 这也意味着百分比只能是 0, 100/width, 2*100/width, ... 100 这几档（比如 width=20 就是每 5% 一档）——和你的条形“档位”完全同步。

    5. 放回函数里（示例）

    def hp_bar(cur: int, maxv: int, width: int = 20) -> str:
    if maxv <= 0:
        maxv = 1
    cur = max(0, min(cur, maxv))
    ratio = cur / maxv
    filled = int(ratio * width + 0.5)          # 先决定亮几格（条形外观）
    pct = int((filled / width) * 100 + 0.5)    # 再用“亮格比例”算百分比，确保一致
    bar = "#" * filled + "-" * (width - filled)
    return f"[{bar}] {pct:3d}%  {cur}/{maxv}"

    这样，无论 cur/maxv 是多少，小数怎么抖动，条形显示和数字都会说同一个“真相”。

  3. 调整分辨率：

    • 提高 width（如 30、40）→ 条形更“细腻”；
    • 降低 width（如 10）→ 更紧凑。

一句话总结

  • 钳制保证范围合法；
  • 比例决定填充；
  • 用 int(x+0.5) 四舍五入避免银行家舍入；
  • 拼接 ASCII 构成稳定的跨平台进度条；
  • 对齐格式让多次打印读起来更整齐。
银行家舍入

银行家舍入（Banker’s Rounding，也叫“四舍六入五留双 / 五成双”、“round half to even”）是一种在恰好落在中点时（小数部分正好是 0.5，或保留位后全是 0）把数值舍入到最接近的偶数的规则。它常用于金融与会计，目的是在大量数据汇总时消除系统性偏差（避免总是向上或总是向下）。

1. 规则一眼看懂

  • 小于 0.5 → 舍（向下）
  • 大于 0.5 → 入（向上）
  • 等于 0.5 → 向最近的“偶数”舍入（关键！）

2. 快速例子（取整）

  • 1.5 → 2（2 是偶数）
  • 2.5 → 2（2 是偶数）
  • 3.5 → 4（4 是偶数）
  • 4.5 → 4（4 是偶数）

负数也一样按“就近偶数”：

  • -1.5 → -2（-2 是偶数）
  • -2.5 → -2（-2 是偶数）

3. 保留到指定位（看保留位后一位）

以保留两位小数为例（看“第三位”）：

  • 2.345 → 第三位是 5，第二位是 4（偶） → 2.34
  • 2.355 → 第三位是 5，第二位是 5（奇） → 2.36
  • 12.1250 → 第三位是 5，第二位是 2（偶） → 12.12

4. 为什么这么做？

  • 在大规模求和/统计中，传统“四舍五入（0.5 一律进位）”会产生系统性偏大；
  • “五留双（中点向偶数）”让上、下的机会更均衡，长期误差更小，因此银行、保险、审计等常用。

5. 在编程语言里的表现

  • Python 3：round() 对“正好在中点”的情况使用银行家舍入

    round(1.5)  # 2
round(2.5)  # 2
round(-1.5) # -2

    注意浮点表示误差：

    round(2.675, 2)  # 2.67（不是 2.68）

    因为 2.675 在二进制浮点中并不精确等于 2.675。要严格十进制舍入可用 decimal：

    from decimal import Decimal, ROUND_HALF_EVEN
Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_EVEN)  # Decimal('2.68')

  • Excel 的 ROUND 默认是“0.5 远离 0 方向”而不是银行家舍入：
    ROUND(2.5, 0) = 3, ROUND(-2.5, 0) = -3。

  • .NET：Math.Round(x) 默认也是“ToEven”（银行家舍入）。

6. 和代码里的关系

在进度条里我用了：

filled = int(ratio * width + 0.5)  # 四舍五入

这是一种**“0.5 一律进位”**的直觉四舍五入（且只针对非负数）。之所以不用 round()，是避免出现：

round(8.5) == 8   # 银行家舍入：到偶数 8

对进度条视觉不符合期望（你会希望 8.5 更像 9 格）。

如果你想用银行家舍入来保证数学一致性，可改成：

filled = round(ratio * width)  # Python 3 的 round 是“到偶数”

7. 一句话记忆

“五留双”= 中点就近偶数。它让大量舍入后的总和更公平、更接近真实值。

9.4.10 使用 Faker 库随机生成敌人姓名

每轮游戏的敌人都应该是不同的，我们就做到名称不同即可~

Python Faker 是一个非常好用的库，可以快速生成各种“假数据”（名字、地址、电话、邮箱、公司、银行卡号。。。），在写测试、做原型、模拟数据库时特别方便。

传播问卷调查数据不够？自己生成假数据！

9.4.10.1 Faker 的基础使用
1. 安装
pip install faker
7. 固定随机种子（保证可复现）

有时需要生成“固定不变”的假数据：

from faker import Faker

Faker.seed(1234)      # 全局种子，数字随便设置
fake = Faker('zh_CN')

print(fake.name())
print(fake.name())

每次运行都会输出一样的结果。

9.4.10.2 敌人姓名随机生成

在生成玩家和敌人时增加 Faker ，Faker 也需要先进行“实例化”，代码修改如下：

from faker import Faker

#---snip---

player = Creature(100, "AI悦创")
enemy_fake = Faker('zh_CN')
enemy = Creature(80, enemy_fake.name())

9.5 大模型接入对战！

目的： 使我们纯python项目，可以融合其他功能。学会利用现有的 Python 基础，扩展新的功能。对于自己来说，要掌握快速上手新技术的能力。

核心点：

  • 代码实现 🌟

  • 原理探索探究 🌟🌟

  • 实现思想 🌟🌟🌟

    要知道如何向大模型接力，如何跟大模型交互、对话。这些无关代码、原理。作为“各个厂家大模型的调用者”要怎么去安排工作流程、分配任务等。

核心实现思维： 把对战信息存储下来，发送给大模型，让大模型基于当前的血量、游戏进展给出合理的指令（攻击 or 防守）

9.5.1 API 对接实战实现（DeepSeek)

1. DeepSeek API 基础调用
1. DeepSeek API 注册

这一步主要实现 DeepSeek API 平台账号注册，API 官网链接：https://api-docs.deepseek.com/

官网界面右上角 DeepSeek Platform 进行注册、实名、充值、创建 API Key 。

9.5.2 本地大模型对接（Ollama、LM Studio）

1. 安装 Ollama、LM Studio

更新日志

2025/9/29 04:13
查看所有更新日志
  • d194d-Refactor code structure for improved readability and maintainability于
  • 3baab-Refactor code structure for improved readability and maintainability于
  • 5138f-Implement code changes to enhance functionality and improve performance于
  • 4ee73-Add Faker library usage examples for generating random enemy names and data于
  • 25c6a-Refactor markdown formatting for clarity; enhance code examples and explanations in 14-class.md于
  • ef95f-Add image-20250916142821074.png to the 14-class.assets directory于
  • 59fb6-Add healing functionality and adjust enemy attack mechanics in combat system于
  • 3d9d8-Implement player attack and defense mechanics with enemy response; add healing functionality for low HP scenarios.于
  • 01e1f-Refactor code structure for improved readability and maintainability于
  • 88b83-Refactor game logic to enhance readability and functionality; optimize health check and action handling于
  • 62365-Refactor code structure for improved readability and maintainability于
  • 8ac6a-Implement code changes to enhance functionality and improve performance于
  • dfd3b-Refactor class definitions to use parentheses for consistency and improve clarity于
  • ec4e8-Refactor code structure for improved readability and maintainability于
  • 9cda3-Add chapter on classes in Python, covering object-oriented programming concepts, class and instance definitions, and practical examples for animal movement simulation.于
默认页脚
Copyright © 2025 Ran