python案例统计地面对抗谁胜出？

本文目录导读：

1. 方案1：经典坦克对战模拟
2. 方案2：历史战役数据分析
3. 方案3：战略作战模拟
4. 使用建议

我来为您设计一个统计地面对抗胜负的Python案例,这里提供几个不同场景的实现方案：

方案1：经典坦克对战模拟

import random
from enum import Enum
class 作战单位类型(Enum):
    坦克 = "坦克"
    步兵 = "步兵"
    装甲车 = "装甲车"
    炮兵 = "炮兵"
class 作战单位:
    def __init__(self, 名称, 类型, 攻击力, 防御力, 生命值):
        self.名称 = 名称
        self.类型 = 类型
        self.攻击力 = 攻击力
        self.防御力 = 防御力
        self.生命值 = 生命值
        self.初始生命值 = 生命值
    def 攻击(self, 目标):
        """攻击目标，计算伤害"""
        # 伤害计算：攻击力 - 目标防御力的50% + 随机波动
        波动 = random.uniform(0.8, 1.2)
        伤害 = max(1, int((self.攻击力 - 目标.防御力 * 0.5) * 波动))
        目标.生命值 -= 伤害
        return 伤害
    def 是否存活(self):
        return self.生命值 > 0
    def 信息(self):
        return (f"{self.名称}[{self.类型.value}] "
                f"攻击:{self.攻击力} 防御:{self.防御力} "
                f"HP:{self.生命值}/{self.初始生命值}")
class 对战机:
    def __init__(self, 红方部队, 蓝方部队):
        self.红方部队 = 红方部队
        self.蓝方部队 = 蓝方部队
        self.回合记录 = []
    def 执行回合(self, 攻击方, 防御方):
        """执行一次攻击回合"""
        攻击单位 = random.choice([u for u in 攻击方 if u.是否存活()])
        防御单位 = random.choice([u for u in 防御方 if u.是否存活()])
        伤害 = 攻击单位.攻击(防御单位)
        记录 = (f"回合{len(self.回合记录)+1}: {攻击单位.名称} 攻击 {防御单位.名称}，"
               f"造成 {伤害} 点伤害，{防御单位.名称} 剩余 {防御单位.生命值} HP")
        self.回合记录.append(记录)
        return 防御单位.是否存活()
    def 模拟对战(self, 最大回合数=100):
        """模拟整个对战过程"""
        print("="*60)
        print("对战开始！")
        print(f"红方部队: {len(self.红方部队)} 个单位")
        print(f"蓝方部队: {len(self.蓝方部队)} 个单位")
        print("="*60)
        回合 = 0
        while 回合 < 最大回合数:
            回合 += 1
            # 红方先手，然后蓝方后手
            蓝方存活 = self.执行回合(self.红方部队, self.蓝方部队)
            if not 蓝方存活:
                print(f"第{回合}回合，蓝方部队全灭！")
                return "红方", 回合
            红方存活 = self.执行回合(self.蓝方部队, self.红方部队)
            if not 红方存活:
                print(f"第{回合}回合，红方部队全灭！")
                return "蓝方", 回合
        return "平局", 回合
    def 统计双方战损(self):
        """统计双方战损情况"""
        红方战损 = sum(1 for u in self.红方部队 if not u.是否存活())
        蓝方战损 = sum(1 for u in self.蓝方部队 if not u.是否存活())
        红方血量损失 = sum(u.初始生命值 - u.生命值 for u in self.红方部队)
        蓝方血量损失 = sum(u.初始生命值 - u.生命值 for u in self.蓝方部队)
        return {
            "红方战损单位数": 红方战损,
            "蓝方战损单位数": 蓝方战损,
            "红方总血量损失": 红方血量损失,
            "蓝方总血量损失": 蓝方血量损失
        }
# 创建部队
def 创建红方():
    部队 = [
        作战单位("虎式坦克", 作战单位类型.坦克, 45, 35, 120),
        作战单位("T-34坦克", 作战单位类型.坦克, 42, 30, 100),
        作战单位("装甲步兵", 作战单位类型.步兵, 25, 20, 60),
        作战单位("迫击炮兵", 作战单位类型.炮兵, 35, 15, 50)
    ]
    return 部队
def 创建蓝方():
    部队 = [
        作战单位("豹式坦克", 作战单位类型.坦克, 48, 38, 110),
        作战单位("谢尔曼坦克", 作战单位类型.坦克, 40, 32, 95),
        作战单位("海军陆战队", 作战单位类型.步兵, 30, 22, 65),
        作战单位("火箭炮兵", 作战单位类型.炮兵, 38, 12, 45)
    ]
    return 部队
# 执行模拟
def 模拟单次对战():
    红方 = 创建红方()
    蓝方 = 创建蓝方()
    对战机系统 = 对战机(红方, 蓝方)
    胜利方, 回合数 = 对战机系统.模拟对战()
    print(f"\n战斗结果: {胜利方} - 胜利，共进行 {回合数} 回合")
    统计 = 对战机系统.统计双方战损()
    print("\n战损统计:")
    for 键, 值 in 统计.items():
        print(f"  {键}: {值}")
    return 胜利方, 回合数
# 多次模拟统计
def 多次模拟(次数=100):
    print(f"\n{'='*60}")
    print(f"进行 {次数} 次模拟对战统计")
    print(f"{'='*60}")
    结果统计 = {"红方": 0, "蓝方": 0, "平局": 0}
    平均回合数 = 0
    for i in range(次数):
        胜利方, 回合数 = 模拟单次对战()
        结果统计[胜利方] += 1
        平均回合数 += 回合数
        print(f"第{i+1}次模拟: {胜利方} 胜利，用时 {回合数} 回合\n")
    平均回合数 /= 次数
    print(f"\n{'='*60}")
    print(f"{次数}次模拟统计结果:")
    print(f"红方胜率: {结果统计['红方']/次数*100:.1f}%")
    print(f"蓝方胜率: {结果统计['蓝方']/次数*100:.1f}%")
    print(f"平局概率: {结果统计['平局']/次数*100:.1f}%")
    print(f"平均回合数: {平均回合数:.1f}")
    print(f"{'='*60}")
    return 结果统计
if __name__ == "__main__":
    # 执行单次模拟
    # 模拟单次对战()
    # 执行多次模拟统计
    多次模拟(10)

方案2：历史战役数据分析

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
class 历史战役分析:
    def __init__(self):
        # 模拟历史战役数据
        self.战役数据 = pd.DataFrame({
            '战役名称': ['诺曼底登陆', '斯大林格勒', '北非战役', '库尔斯克战役', '柏林战役'],
            '红方兵力': [150000, 400000, 220000, 800000, 250000],
            '蓝方兵力': [300000, 300000, 180000, 500000, 1000000],
            '红方阵亡': [29000, 80000, 35000, 100000, 36000],
            '蓝方阵亡': [200000, 250000, 120000, 50000, 100000],
            '地形': ['海滩', '城市', '沙漠', '平原', '城市'],
            '天气': ['恶劣', '严寒', '干燥', '晴朗', '多云'],
            '指挥官素质': [0.8, 0.9, 0.7, 0.85, 0.75]  # 0-1范围
        })
    def 分析胜率(self):
        """分析各因素对胜负的影响"""
        print("=== 战役数据分析 ===")
        print(self.战役数据)
        # 计算兵力对比
        self.战役数据['兵力比率'] = self.战役数据['红方兵力'] / self.战役数据['蓝方兵力']
        self.战役数据['阵亡比率'] = self.战役数据['红方阵亡'] / self.战役数据['蓝方阵亡']
        # 判定胜负（红方阵亡少且兵力比率高）
        self.战役数据['红方胜利'] = (self.战役数据['兵力比率'] > 0.8) & \
                                (self.战役数据['阵亡比率'] < 0.3)
        print("\n=== 分析结果 ===")
        红方胜率 = self.战役数据['红方胜利'].sum() / len(self.战役数据) * 100
        print(f"红方胜率: {红方胜率:.1f}%")
        # 按地形分析
        print("\n=== 地形对战局影响 ===")
        for 地形 in self.战役数据['地形'].unique():
            子集 = self.战役数据[self.战役数据['地形'] == 地形]
            胜率 = 子集['红方胜利'].sum() / len(子集) * 100
            print(f"{地形}: 胜率 {胜率:.0f}%")
        # 可视化
        self.绘制分析图()
    def 绘制分析图(self):
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
        # 兵力对比图
        ax1.bar(self.战役数据['战役名称'], self.战役数据['兵力比率'], color='coral')
        ax1.set_title('兵力比率对比')
        ax1.set_ylabel('红方/蓝方兵力')
        ax1.axhline(y=1, color='red', linestyle='--', label='均衡线')
        ax1.legend()
        # 阵亡数量对比图
        ax2.bar(self.战役数据['战役名称'] - 0.2, self.战役数据['红方阵亡'], 
                width=0.4, label='红方阵亡', color='red')
        ax2.bar(self.战役数据['战役名称'] + 0.2, self.战役数据['蓝方阵亡'], 
                width=0.4, label='蓝方阵亡', color='blue')
        ax2.set_title('阵亡数量对比')
        ax2.set_ylabel('阵亡人数')
        ax2.legend()
        plt.tight_layout()
        plt.show()
# 执行历史分析
if __name__ == "__main__":
    分析 = 历史战役分析()
    分析.分析胜率()

方案3：战略作战模拟

import numpy as np
import random
class 战略模拟器:
    def __init__(self):
        self.地形影响 = {
            '山地': {'防御增益': 0.3, '攻击削弱': 0.2},
            '平原': {'防御增益': 0.0, '攻击削弱': 0.0},
            '城市': {'防御增益': 0.5, '攻击削弱': 0.1},
            '河流': {'防御增益': 0.2, '攻击削弱': 0.3}
        }
    class 部队:
        def __init__(self, 名称, 类型, 规模, 战斗力, 防御力):
            self.名称 = 名称
            self.类型 = 类型
            self.规模 = 规模
            self.战斗力 = 战斗力
            self.防御力 = 防御力
            self.初始规模 = 规模
        def 战斗力计算(self, 地形):
            地形加成 = 0.0 if 地形 not in self.__class__.__name__ else 0
            return (self.战斗力 * self.规模/self.初始规模) + 地形加成
    def 模拟战斗(self, 红方兵力, 蓝方兵力, 地形, 战术熟练度=0.5):
        """
        模拟单场战斗
        地形: '山地', '平原', '城市', '河流'
        战术熟练度: 0-1之间
        """
        地形数据 = self.地形影响[地形]
        # 计算实际战斗力
        红方攻击力 = 红方兵力 * (1 - 地形数据['攻击削弱'])
        蓝方防御力 = 蓝方兵力 * (1 + 地形数据['防御增益'])
        # 加入战术因素
        红方攻击力 *= (1 + 战术熟练度 * 0.2)
        # 战斗模拟（兰彻斯特方程简化版）
        while 红方攻击力 > 0 and 蓝方防御力 > 0:
            红方损失 = 蓝方防御力 * 0.05 * (1 - 地形数据['防御增益'])
            蓝方损失 = 红方攻击力 * 0.05 * (1 - 战术熟练度*0.1)
            红方攻击力 -= 红方损失
            蓝方防御力 -= 蓝方损失
        胜负 = "红方" if 红方攻击力 > 0 else "蓝方"
        战损比 = max(红方损失, 1) / max(蓝方损失, 1)
        return {
            '胜利方': 胜负,
            '战损比': 战损比,
            '剩余红方': 红方攻击力,
            '剩余蓝方': 蓝方防御力
        }
    def 大规模模拟(self, 模拟次数=1000):
        """大规模模拟不同场景"""
        结果 = {'红方胜': 0, '蓝方胜': 0, '平局': 0}
        地形胜率 = {地形: {'红方': 0, '蓝方': 0} for 地形 in self.地形影响}
        for _ in range(模拟次数):
            地形 = random.choice(list(self.地形影响.keys()))
            红方兵力 = random.randint(500, 5000)
            蓝方兵力 = random.randint(500, 5000)
            战术 = random.random()
            战斗结果 = self.模拟战斗(红方兵力, 蓝方兵力, 地形, 战术)
            结果[战斗结果['胜利方'] + '胜' if 战斗结果['胜利方'] == '红方' else '蓝方胜'] += 1
            地形胜率[地形][战斗结果['胜利方']] += 1
        print(f"\n=== {模拟次数}次大规模模拟结果 ===")
        print(f"红方胜利: {结果['红方胜']} ({结果['红方胜']/模拟次数*100:.1f}%)")
        print(f"蓝方胜利: {结果['蓝方胜']} ({结果['蓝方胜']/模拟次数*100:.1f}%)")
        print(f"平局: {结果['平局']} ({结果['平局']/模拟次数*100:.1f}%)")
        print("\n=== 地形胜率分析 ===")
        for 地形, 胜率 in 地形胜率.items():
            总次数 = 胜率['红方'] + 胜率['蓝方']
            if 总次数 > 0:
                print(f"{地形}: 红方 {胜率['红方']/总次数*100:.1f}% / "
                      f"蓝方 {胜率['蓝方']/总次数*100:.1f}%")
# 战略模拟执行
if __name__ == "__main__":
    战略模拟 = 战略模拟器()
    # 单场景测试
    print("=== 单场战斗模拟 ===")
    for 地形 in ['山地', '平原', '城市', '河流']:
        结果 = 战略模拟.模拟战斗(1000, 1000, 地形)
        print(f"{地形}: {结果}")
    # 大规模模拟
    战略模拟.大规模模拟(1000)

使用建议

1. 方案1适合简单的部队对战模拟和胜负统计
2. 方案2适合分析历史数据，找出胜负规律
3. 方案3适合战略层面的推演和大数据分析

运行这些代码后,您会得到：

• 单次对战的具体回合记录
• 多次模拟的胜率统计
• 地形、兵力等因素对战局的影响分析
• 可视化的图表（需安装matplotlib）

这个案例覆盖了从微观（单兵作战）到宏观（全局战略）的完整模拟体系，您可以根据实际需求选择使用。