综合python案例，哪队能笑到最后？

wen python案例 2026-09-06 221

本文目录导读：

综合python案例，哪队能笑到最后？

场景设定
完整Python代码
运行结果预测（取决于随机数）
如何“调整”让另一队获胜？
总结：谁笑到最后？

这是一个非常开放且有趣的问题！要回答“哪队能笑到最后”，我们需要先定义一个具体的场景，因为没有指定是哪两支队伍（比如是足球、篮球、还是两个程序竞争？），我将为你构建一个经典的综合性Python案例,并给出最终判定逻辑。

我假设你想看一个模拟竞赛的Python程序，红队 vs 蓝队”进行资源争夺或生存模拟。

以下是一个综合性案例,它结合了：

面向对象（定义队伍类）
随机数（模拟不确定性）
策略（攻防逻辑）
数据分析（统计胜负条件）
文件操作（保存战斗日志）

场景设定

两支队伍在荒岛上进行“夺旗”模拟,每队有：

HP（血量）
攻击力（随机波动）
采集速度（获取资源）
策略（进攻型或防守型）

程序运行 10轮,每轮：

双方尝试采集资源。
如果血量低于阈值,则消耗资源回血。
发生战斗：攻击力 + 随机加成 vs 对方防御。
记录战报。

根据 存活血量 和 总资源积分 判定谁笑到最后。

完整Python代码

import random
import datetime
# --- 1. 定义队伍类 (面向对象核心) ---
class Team:
    def __init__(self, name, strategy="balanced"):
        self.name = name
        self.strategy = strategy  # "aggressive" 或 "defensive"
        self.max_hp = 100
        self.hp = 100
        self.resources = 50  # 初期资源
        self.base_attack = 15
        self.defense = 10
        self.kills = 0
        self.log = []
    def gather(self):
        """采集资源 (速度受策略影响)"""
        if self.strategy == "defensive":
            gain = random.randint(8, 15)  # 防守方采集多，养精蓄锐
        else:
            gain = random.randint(5, 10)  # 进攻方采集少，准备打架
        self.resources += gain
        return gain
    def repair(self):
        """消耗资源回血"""
        # 防守型更倾向回血
        if self.strategy == "defensive" and self.resources >= 20:
            heal = random.randint(15, 25)
            self.hp = min(self.max_hp, self.hp + heal)
            self.resources -= 20
            return heal
        elif self.strategy == "aggressive" and self.resources >= 30:
            heal = random.randint(10, 20)
            self.hp = min(self.max_hp, self.hp + heal)
            self.resources -= 30
            return heal
        return 0  # 没资源或不回
    def attack(self, enemy):
        """攻击对方"""
        # 攻击力波动
        if self.strategy == "aggressive":
            # 进攻方有20%暴击概率
            crit_mult = 1.5 if random.random() < 0.2 else 1.0
            damage = (self.base_attack + random.randint(-5, 10)) * crit_mult
        else:
            # 防守方稳定攻击
            damage = self.base_attack + random.randint(0, 5)
        # 敌方防御减伤
        final_damage = max(0, damage - enemy.defense * 0.5)
        enemy.hp -= final_damage
        if enemy.hp <= 0:
            enemy.hp = 0
            self.kills += 1
            return final_damage, True  # 击杀
        return final_damage, False
# --- 2. 模拟战斗系统 ---
def simulate_battle(team_a, team_b, rounds=10):
    print(f"{'='*40}")
    print(f"🎮 比赛开始: {team_a.name} VS {team_b.name}")
    print(f"{'='*40}")
    for round_num in range(1, rounds + 1):
        print(f"\n--- 第 {round_num} 轮 ---")
        # 先采集
        gain_a = team_a.gather()
        gain_b = team_b.gather()
        print(f"{team_a.name} 采到 {gain_a} 资源 (总: {team_a.resources})")
        print(f"{team_b.name} 采到 {gain_b} 资源 (总: {team_b.resources})")
        # 看是否需要回血
        heal_a = team_a.repair()
        heal_b = team_b.repair()
        if heal_a:
            print(f"🩹 {team_a.name} 回血 {heal_a}, 当前HP: {team_a.hp:.1f}/{team_a.max_hp}")
        if heal_b:
            print(f"🩹 {team_b.name} 回血 {heal_b}, 当前HP: {team_b.hp:.1f}/{team_b.max_hp}")
        # 战斗 (A攻击B，然后B反击A，如果存活)
        dmg_a, kill_b = team_a.attack(team_b)
        print(f"⚔️ {team_a.name} 对 {team_b.name} 造成 {dmg_a:.1f} 伤害, {team_b.name} HP: {team_b.hp:.1f}")
        if team_b.hp <= 0:
            break  # B死了，后续不用打了
        dmg_b, kill_a = team_b.attack(team_a)
        print(f"⚔️ {team_b.name} 对 {team_a.name} 造成 {dmg_b:.1f} 伤害, {team_a.name} HP: {team_a.hp:.1f}")
        if team_a.hp <= 0:
            break
        # 每轮结束后记录状态
        team_a.log.append((round_num, team_a.hp, team_a.resources))
        team_b.log.append((round_num, team_b.hp, team_b.resources))
    print(f"\n{'='*40}")
    print("🏁 比赛结束!")
    return team_a, team_b
# --- 3. 判定谁笑到最后 (综合评分) ---
def get_winner(team_a, team_b):
    print("\n📊 最终数据统计:")
    print(f"{team_a.name} | 剩余HP: {team_a.hp:.1f} | 资源: {team_a.resources} | 击杀: {team_a.kills}")
    print(f"{team_b.name} | 剩余HP: {team_b.hp:.1f} | 资源: {team_b.resources} | 击杀: {team_b.kills}")
    # 综合评分公式: 血量占比*60% + 资源占比*40% + 击杀奖励分
    total_score_a = (team_a.hp / team_a.max_hp) * 60 + min(team_a.resources / 100, 1) * 40 + team_a.kills * 50
    total_score_b = (team_b.hp / team_b.max_hp) * 60 + min(team_b.resources / 100, 1) * 40 + team_b.kills * 50
    print(f"\n综合评分 {team_a.name}: {total_score_a:.2f}")
    print(f"综合评分 {team_b.name}: {total_score_b:.2f}")
    # 如果一方被KO，则击杀方直接获胜
    if team_a.hp <= 0 or team_b.hp <= 0:
        winner_name = team_a.name if team_a.hp > team_b.hp else team_b.name
        print(f"\n{'':>5}🏆 直接击败对手，{winner_name} 队笑到最后！")
    elif total_score_a > total_score_b:
        print(f"\n{'':>5}🏆 综合评分更高，{team_a.name} 队笑到最后！")
    elif total_score_a < total_score_b:
        print(f"\n{'':>5}🏆 综合评分更高，{team_b.name} 队笑到最后！")
    else:
        print("\n🤝 双方势均力敌，打成平手，都笑了！")
# --- 4. 主程序入口 & 保存日志 ---
if __name__ == "__main__":
    random.seed(42)  # 固定随机种子让结果可复现
    # 创建两队：一键进攻型 vs 重剑防守型
    red_team = Team("红队 (进攻)", strategy="aggressive")
    blue_team = Team("蓝队 (防守)", strategy="defensive")
    # 提供两条路线，取消注释即可更换对手
    # red_team = Team("雄鹰队", strategy="aggressive")
    # blue_team = Team("坚盾队", strategy="defensive")
    # 模拟
    team_a_result, team_b_result = simulate_battle(red_team, blue_team, rounds=8)
    # 判定结果
    get_winner(team_a_result, team_b_result)
    # 保存战报日志
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"game_report_{timestamp}.txt"
    with open(filename, "w", encoding="utf-8") as f:
        f.write(f"模拟时间: {datetime.datetime.now()}\n")
        f.write(f"对战: {red_team.name} vs {blue_team.name}\n")
        f.write(f"胜者: 见上方控制台输出\n")
        # 简单记录每一轮
        f.write("\n--- 战报摘要 ---\n")
        for i in range(len(team_a_result.log)):
            f.write(f"Round {i+1}: {red_team.name} HP = {team_a_result.log[i][1]}, "
                    f"Res = {team_a_result.log[i][2]} | "
                    f"{blue_team.name} HP = {team_b_result.log[i][1]}, "
                    f"Res = {team_b_result.log[i][2]}\n")
    print(f"\n📄 详细战报已保存至: {filename}")

运行结果预测（取决于随机数）

由于使用了随机种子 random.seed(42)，每次运行结果会一样，在当前的设定下（进攻队vs防守队），通常防守型队伍更占优势，因为它的资源获取更快、回血更频繁。

实际运行输出大致会是这样：

🎮 比赛开始: 红队 (进攻) VS 蓝队 (防守)
================
...
蓝队 (防守) 的剩余HP比较高，且没有阵亡，蓝队笑到最后。

如何“调整”让另一队获胜？

如果你想看红队赢,可以修改策略：

将 blue_team = Team("蓝队 (防守)", strategy="defensive") 中的血量调低。
或者提升 Team.__init__ 中 base_attack 的值。
或者改变 random.seed 的值。

谁笑到最后？

核心取决于你程序的 初始化参数（哪个队伍数值更强）和运气（随机数）。

在代码世界里，谁的数据设计更合理、运气（随机数）更好，谁就能笑到最后！

如果你指的是现实中的某支特定队伍（比如现实中的足球赛），需要提供真实数据，我可以用上文中的模式帮你做胜率预测,你现在想尝试运行这段代码看看结果吗？

本文地址： https://www.bmjup.com/post/55745.html