本文目录导读：
我来设计一个综合性的Python案例，模拟空中对抗（空战）系统,分析哪支队伍更具优势。
空中对抗优势分析系统
import random
import numpy as np
import pandas as pd
from dataclasses import dataclass
from typing import List, Dict, Tuple
import matplotlib.pyplot as plt
from enum import Enum
# ============ 基础枚举和数据结构 ============
class AircraftType(Enum):
"""战机类型"""
FIGHTER = "歼击机"
BOMBER = "轰炸机"
AWACS = "预警机"
UAV = "无人机"
class MissionType(Enum):
"""任务类型"""
AIR_SUPERIORITY = "制空作战"
STRIKE = "对地打击"
INTERCEPT = "拦截作战"
RECON = "侦察任务"
@dataclass
class Aircraft:
"""战机类"""
id: str
type: AircraftType
speed: float # 最大速度 (km/h)
maneuverability: float # 机动性 (0-100)
stealth: float # 隐身能力 (0-100)
weapon_range: float # 武器射程 (km)
radar_range: float # 雷达探测范围 (km)
ecm_capability: float # 电子对抗能力 (0-100)
fuel: float # 燃料 (百分比)
crew_count: int # 机组人数
durability: float # 生存能力 (0-100)
def __post_init__(self):
self.hp = 100.0 # 生命值
@dataclass
class Squadron:
"""中队类"""
name: str
aircrafts: List[Aircraft]
@property
def total_strength(self) -> float:
"""计算中队总战力"""
return sum(self._calculate_strength(ac) for ac in self.aircrafts)
def _calculate_strength(self, ac: Aircraft) -> float:
"""计算单架战机战力"""
base_strength = (ac.speed / 2000) * 20 + \
ac.maneuverability * 0.25 + \
ac.stealth * 0.2 + \
ac.weapon_range / 100 * 15 + \
ac.radar_range / 200 * 20 + \
ac.ecm_capability * 0.15 + \
ac.durability * 0.1
# 根据机型加成
if ac.type == AircraftType.AWACS:
base_strength *= 1.3 # 预警机指挥加成
elif ac.type == AircraftType.UAV:
base_strength *= 1.1 # 无人机成本效益
return base_strength
# ============ 空战模拟引擎 ============
class AirCombatSimulator:
"""空战模拟器"""
def __init__(self, red_team: Squadron, blue_team: Squadron):
self.red_team = red_team
self.blue_team = blue_team
self.combat_log = []
def simulate_engagement(self, num_rounds: int = 3) -> Dict:
"""模拟多轮交战"""
results = []
for round_num in range(num_rounds):
round_result = self._single_engagement(round_num + 1)
results.append(round_result)
self._reset_for_next_round()
return self._aggregate_results(results)
def _single_engagement(self, round_num: int) -> Dict:
"""单轮交战模拟"""
self._initialize_combat()
red_initial = sum(ac.hp for ac in self.red_team.aircrafts)
blue_initial = sum(ac.hp for ac in self.blue_team.aircrafts)
# 战术决策（简化的规则引擎）
tactics = self._decide_tactics()
# 执行交战
for tick in range(10): # 10个时间步
self._missile_phase()
self._dogfight_phase()
self._log_combat_state(tick)
# 计算损失
red_loss = red_initial - sum(ac.hp for ac in self.red_team.aircrafts)
blue_loss = blue_initial - sum(ac.hp for ac in self.blue_team.aircrafts)
return {
'round': round_num,
'red_loss': red_loss,
'blue_loss': blue_loss,
'red_remaining': sum(ac.hp > 0 for ac in self.red_team.aircrafts),
'blue_remaining': sum(ac.hp > 0 for ac in self.blue_team.aircrafts),
'tactics_used': tactics,
'red_advantage': blue_loss - red_loss,
'victory': 'red' if blue_loss > red_loss else 'blue' if red_loss > blue_loss else 'draw'
}
def _initialize_combat(self):
"""初始化战斗状态"""
self.detected_units = {'red': [], 'blue': []}
def _decide_tactics(self) -> Dict:
"""战术决策（基于规则）"""
red_strength = self.red_team.total_strength
blue_strength = self.blue_team.total_strength
if red_strength > blue_strength * 1.2:
red_tactic = "主动进攻"
elif red_strength < blue_strength * 0.8:
red_tactic = "防御反击"
else:
red_tactic = "平衡战术"
return {"red": red_tactic, "blue": "动态调整"}
def _missile_phase(self):
"""导弹交战阶段（超视距）"""
for red_ac in self.red_team.aircrafts:
for blue_ac in self.blue_team.aircrafts:
if random.random() < 0.3: # 30%概率发射导弹
hit_probability = self._calculate_hit_probability(red_ac, blue_ac)
if random.random() < hit_probability:
damage = random.uniform(15, 25)
blue_ac.hp -= damage
self.combat_log.append(f"{red_ac.id} 命中 {blue_ac.id}，造成 {damage:.1f} 伤害")
def _dogfight_phase(self):
"""近距格斗阶段"""
for red_ac in self.red_team.aircrafts:
for blue_ac in self.blue_team.aircrafts:
if random.random() < 0.2: # 20%概率进入格斗
hit_probability = self._calculate_hit_probability(red_ac, blue_ac, close_range=True)
if random.random() < hit_probability:
damage = random.uniform(8, 15)
blue_ac.hp -= damage
self.combat_log.append(f"{red_ac.id} 近距命中 {blue_ac.id}，造成 {damage:.1f} 伤害")
def _calculate_hit_probability(self, attacker: Aircraft, defender: Aircraft, close_range=False) -> float:
"""计算命中概率"""
base_probability = 0.5 if close_range else 0.35
# 隐身能力影响
stealth_difference = attacker.stealth - defender.stealth * 0.5
# 机动性影响
maneuver_ratio = attacker.maneuverability / (attacker.maneuverability + defender.maneuverability)
# ECM对抗
ecm_factor = (attacker.ecm_capability - defender.ecm_capability) / 100
probability = base_probability + stealth_difference * 0.002 + \
(maneuver_ratio - 0.5) * 0.3 + ecm_factor * 0.3
return max(0.05, min(0.95, probability))
def _log_combat_state(self, tick: int):
"""记录战斗状态"""
red_total = sum(ac.hp for ac in self.red_team.aircrafts)
blue_total = sum(ac.hp for ac in self.blue_team.aircrafts)
self.combat_log.append(f"Tick {tick}: 红军剩余战力 {red_total:.1f}, 蓝军剩余战力 {blue_total:.1f}")
def _reset_for_next_round(self):
"""重置战斗状态"""
for ac in self.red_team.aircrafts + self.blue_team.aircrafts:
ac.hp = 100.0
self.combat_log.clear()
def _aggregate_results(self, results: List[Dict]) -> Dict:
"""汇总结果"""
red_total_loss = sum(r['red_loss'] for r in results)
blue_total_loss = sum(r['blue_loss'] for r in results)
red_wins = sum(1 for r in results if r['victory'] == 'red')
blue_wins = sum(1 for r in results if r['victory'] == 'blue')
return {
'red_total_loss': red_total_loss,
'blue_total_loss': blue_total_loss,
'red_wins': red_wins,
'blue_wins': blue_wins,
'advantage_team': 'red' if red_total_loss < blue_total_loss else 'blue',
'win_ratio': red_wins / len(results)
}
# ============ 数据分析与可视化 ============
class CombatAnalyzer:
"""战斗分析器"""
@staticmethod
def analyze_strengths(red_team: Squadron, blue_team: Squadron) -> pd.DataFrame:
"""分析两队优势"""
data = []
for team_name, squadron in [("红军", red_team), ("蓝军", blue_team)]:
total = squadron.total_strength
for ac in squadron.aircrafts:
data.append({
'队伍': team_name,
'战机ID': ac.id,
'机型': ac.type.value,
'速度评级': min(5, ac.speed / 400),
'机动性评级': ac.maneuverability / 20,
'隐身评级': ac.stealth / 20,
'武器评级': min(5, ac.weapon_range / 15),
'雷达评级': min(5, ac.radar_range / 18),
'电子战评级': ac.ecm_capability / 20,
'综合战力': total
})
return pd.DataFrame(data)
@staticmethod
def plot_advantages(results: Dict):
"""可视化优势分析"""
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 8))
# 损失对比
teams = ['红军', '蓝军']
losses = [results['red_total_loss'], results['blue_total_loss']]
ax1.bar(teams, losses, color=['red', 'blue'])
ax1.set_title('总损失对比')
ax1.set_ylabel('损失值')
# 胜利场次
wins = [results['red_wins'], results['blue_wins']]
ax2.pie(wins, labels=teams, autopct='%1.1f%%', colors=['red', 'blue'])
ax2.set_title('胜利次数分布')
# 优势雷达图
ax3.axis('off')
ax3.text(0.5, 0.5,
f"优势方: {results['advantage_team']}\n胜率: {results['win_ratio']*100:.1f}%",
ha='center', va='center', fontsize=16)
ax3.set_title('综合判定')
# 战力分布（简单的柱状图）
ax4.bar(['红军', '蓝军'], [results['red_total_loss'], results['blue_total_loss']],
color=['red', 'blue'], alpha=0.6)
ax4.set_title('战力损失对比')
ax4.set_ylabel('损失')
plt.tight_layout()
return plt
# ============ 主程序：创建两队并模拟 ============
def create_aircraft_squadrons():
"""创建两支队伍"""
# 红军：更强悍的攻击编队
red_team = Squadron("红军编号-101", [
Aircraft("R-01", AircraftType.FIGHTER, speed=2200, maneuverability=85,
stealth=70, weapon_range=150, radar_range=320,
ecm_capability=80, fuel=90, crew_count=1, durability=70),
Aircraft("R-02", AircraftType.AWACS, speed=900, maneuverability=60,
stealth=50, weapon_range=100, radar_range=650,
ecm_capability=95, fuel=80, crew_count=5, durability=60),
Aircraft("R-03", AircraftType.FIGHTER, speed=2000, maneuverability=90,
stealth=75, weapon_range=130, radar_range=300,
ecm_capability=75, fuel=85, crew_count=1, durability=75),
Aircraft("R-04", AircraftType.UAV, speed=450, maneuverability=95,
stealth=90, weapon_range=50, radar_range=450,
ecm_capability=85, fuel=95, crew_count=0, durability=85),
])
# 蓝军：更均衡的战力编队
blue_team = Squadron("蓝军编号-102", [
Aircraft("B-01", AircraftType.FIGHTER, speed=2100, maneuverability=80,
stealth=65, weapon_range=140, radar_range=300,
ecm_capability=70, fuel=88, crew_count=1, durability=72),
Aircraft("B-02", AircraftType.FIGHTER, speed=1900, maneuverability=82,
stealth=60, weapon_range=120, radar_range=280,
ecm_capability=65, fuel=82, crew_count=1, durability=68),
Aircraft("B-03", AircraftType.BOMBER, speed=1200, maneuverability=55,
stealth=45, weapon_range=200, radar_range=280,
ecm_capability=60, fuel=75, crew_count=2, durability=55),
Aircraft("B-04", AircraftType.UAV, speed=420, maneuverability=92,
stealth=85, weapon_range=45, radar_range=420,
ecm_capability=80, fuel=92, crew_count=0, durability=80),
])
return red_team, blue_team
# ============ 执行分析 ============
def main():
print("======= 空中对抗优势分析系统 =======\n")
# 创建队伍
red_team, blue_team = create_aircraft_squadrons()
# 展示队伍信息
print("红军编队:")
for ac in red_team.aircrafts:
print(f" {ac.id}: {ac.type.value} - 速度:{ac.speed}km/h, 机动:{ac.maneuverability}, 隐身:{ac.stealth}")
print("\n蓝军编队:")
for ac in blue_team.aircrafts:
print(f" {ac.id}: {ac.type.value} - 速度:{ac.speed}km/h, 机动:{ac.maneuverability}, 隐身:{ac.stealth}")
# 静态分析
print("\n======= 静态战力分析 =======")
red_strength = red_team.total_strength
blue_strength = blue_team.total_strength
print(f"红军总战力: {red_strength:.2f}")
print(f"蓝军总战力: {blue_strength:.2f}")
print(f"战力差: {abs(red_strength - blue_strength):.2f}")
print(f"兵力对比: {'红军' if red_strength > blue_strength else '蓝军'}优势明显" if
abs(red_strength - blue_strength) > 20 else "双方势均力敌")
# 动态模拟
print("\n======= 动态模拟交战 =======")
simulator = AirCombatSimulator(red_team, blue_team)
simulation_results = simulator.simulate_engagement(num_rounds=5)
print("\n战线损失统计:")
print(f"红军总损失: {simulation_results['red_total_loss']:.1f}")
print(f"蓝军总损失: {simulation_results['blue_total_loss']:.1f}")
print(f"红军胜场: {simulation_results['red_wins']}")
print(f"蓝军胜场: {simulation_results['blue_wins']}")
# 数据分析
print("\n======= 详细数据分析 =======")
analyzer = CombatAnalyzer()
df = analyzer.analyze_strengths(red_team, blue_team)
print("\n队伍综合能力评估:")
print(df[['队伍', '战机ID', '机型', '速度评级', '机动性评级',
'隐身评级', '武器评级', '雷达评级', '电子战评级']])
# 生成图表
print("\n正在生成分析图表...")
plot = analyzer.plot_advantages(simulation_results)
plot.savefig('air_combat_analysis.png', dpi=150)
print("图表已保存为 air_combat_analysis.png")
# 最终结论
print("\n======= 最终判定 =======")
advantage = simulation_results['advantage_team']
win_ratio = simulation_results['win_ratio']
print(f"获胜方：{'红军' if advantage == 'red' else '蓝军'}")
print(f"红军胜率：{win_ratio*100:.1f}%")
if red_strength > blue_strength * 1.1:
print("红军在整体实力和空中对抗中显现出显著优势")
elif blue_strength > red_strength * 1.1:
print("蓝军在整体实力和空中对抗中显现出显著优势")
else:
print("双方实力接近，优势取决于临场发挥和战术运用")
if __name__ == "__main__":
main()
运行效果说明
运行此程序,你将得到：
队伍信息输出
- 展示两队战机配置和关键参数
静态战力分析
- 计算两队总战力值
- 评估兵力对比
动态空战模拟
- 进行多轮交战模拟
- 统计胜利场次和损失
数据可视化
生成包含4个子图的分析图表：
- 损失对比柱状图
- 胜利次数饼图
- 综合判定雷达图
- 战力损失对比
最终结论
- 确定优势方
- 给出综合判断
关键特性
- 多维度评估：考虑速度、机动性、隐身、武器、雷达、电子对抗等
- 动态模拟：模拟导弹发射、近距格斗等空战阶段
- 战术决策：根据实力对比自动调整战术
- 数据统计：多次模拟取平均结果提高可靠性
这个案例展示了Python在军事模拟领域的实际应用能力，结合了面向对象编程、数据分析和可视化等综合技术。
