跳至主要內容

14.2 回合制打怪游戏设计（文字版）

Ran原创2025/11/17...大约 44 分钟

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

目前完整代码：

更新日志

2025/11/17 05:56
查看所有更新日志
  • 106e2-Refactor code structure for improved readability and maintainability于
  • 39cab-feat: Implement turn-based monster fighting game in Python于
默认页脚
Copyright © 2025 Ran