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

wen python案例 2026-08-21 221
本文目录导读：
综合python案例，哪队能笑到最后？
🏀 篮球联赛季后赛模拟系统
🎯 程序特色
📊 运行效果
我来设计一个有趣的Python综合案例：模拟篮球联赛季后赛，看看哪支球队能笑到最后！
🏀 篮球联赛季后赛模拟系统

import random
import time
from dataclasses import dataclass
from typing import List, Dict
import math
from collections import defaultdict
# ========== 数据类定义 ==========
@dataclass
class Player:
    """球员类"""
    name: str
    position: str  # PG, SG, SF, PF, C
    overall: int   # 综合能力值 70-99
    three_point: int  # 三分能力
    stamina: int = 100  # 体力
    def __str__(self):
        return f"{self.name}({self.position}) {self.overall}"
@dataclass
class Team:
    """球队类"""
    name: str
    city: str
    players: List[Player]
    wins: int = 0
    losses: int = 0
    chemistry: float = 0.7  # 团队默契度
    def get_team_rating(self):
        """计算球队整体实力"""
        if not self.players:
            return 0
        return sum(p.overall for p in self.players) / len(self.players)
# ========== 比赛模拟类 ==========
class MatchSimulator:
    """比赛模拟器"""
    def __init__(self, home_team: Team, away_team: Team):
        self.home = home_team
        self.away = away_team
        self.home_score = 0
        self.away_score = 0
        self.quarter_scores = []  # 记录每节比分
        self.game_events = []  # 比赛事件
    def simulate_quarter(self, quarter_num: int):
        """模拟一节比赛"""
        # 根据球队实力计算得分概率
        home_rating = self.home.get_team_rating()
        away_rating = self.away.get_team_rating()
        # 加入主场优势(3%)
        home_rating *= 1.03
        # 计算得分能力（加入随机因素）
        home_ability = home_rating * (0.85 + random.random() * 0.3)
        away_ability = away_rating * (0.85 + random.random() * 0.3)
        # 计算本节得分（每节大约20-35分）
        home_quarter_score = int(home_ability / 10) + random.randint(15, 25)
        away_quarter_score = int(away_ability / 10) + random.randint(15, 25)
        # 记录事件
        self.game_events.append(
            f"第{quarter_num}节: {self.home.name} {home_quarter_score} - "
            f"{away_quarter_score} {self.away.name}"
        )
        # 更新总分和记录
        self.home_score += home_quarter_score
        self.away_score += away_quarter_score
        self.quarter_scores.append((home_quarter_score, away_quarter_score))
        # 消耗体力
        for player in self.home.players + self.away.players:
            player.stamina -= random.randint(5, 15)
    def simulate_game(self) -> Team:
        """模拟整场比赛，返回获胜球队"""
        print(f"\n🏀 {self.home.name} vs {self.away.name} 比赛开始！")
        # 模拟4节比赛
        for quarter in range(1, 5):
            self.simulate_quarter(quarter)
            time.sleep(0.5)
        # 加时赛处理
        overtime_count = 0
        while self.home_score == self.away_score and overtime_count < 3:
            print("🕐 进入加时赛！")
            self.simulate_quarter(5 + overtime_count)
            overtime_count += 1
        # 输出比赛结果
        winner = self.home if self.home_score > self.away_score else self.away
        print("\n📊 比赛详细数据：")
        for i, (home_s, away_s) in enumerate(self.quarter_scores, 1):
            print(f"  第{i}节: {self.home.name} {home_s} - {away_s} {self.away.name}")
        print(f"\n🏆 最终比分: {self.home.name} {self.home_score} - "
              f"{self.away_score} {self.away.name}")
        print(f"🎉 获胜球队: {winner.name}!")
        # 更新球队战绩
        self.home.wins += 1 if winner == self.home else 0
        self.home.losses += 1 if winner == self.away else 0
        self.away.wins += 1 if winner == self.away else 0
        self.away.losses += 1 if winner == self.home else 0
        return winner
# ========== 赛季模拟类 ==========
class SeasonSimulator:
    """赛季模拟器"""
    def __init__(self, teams: List[Team]):
        self.teams = teams
        self.playoff_results = []
    def simulate_playoff(self):
        """模拟季后赛"""
        print("\n" + "="*50)
        print("🏆 NBA季后赛开始！")
        print("="*50)
        # 随机分组进行比赛
        teams_copy = self.teams.copy()
        round_num = 1
        while len(teams_copy) > 1:
            print(f"\n📢 第{round_num}轮比赛，剩余球队：{len(teams_copy)}支")
            next_round = []
            # 相邻球队配对
            for i in range(0, len(teams_copy), 2):
                if i + 1 < len(teams_copy):
                    team1 = teams_copy[i]
                    team2 = teams_copy[i+1]
                    # 开始3局2胜系列赛
                    series_winner = self.simulate_series(team1, team2)
                    next_round.append(series_winner)
                else:
                    next_round.append(teams_copy[i])
            teams_copy = next_round
            round_num += 1
        champion = teams_copy[0]
        print(f"\n🌟 冠军球队：{champion.name}！")
        return champion
    def simulate_series(self, team1: Team, team2: Team, best_of: int = 3):
        """模拟系列赛"""
        print(f"\n🎯 系列赛：{team1.name} vs {team2.name} (三局两胜)")
        team1_wins = 0
        team2_wins = 0
        games_played = 0
        # 恢复体力
        for team in [team1, team2]:
            for player in team.players:
                player.stamina = 100
        while games_played < best_of and max(team1_wins, team2_wins) < 2:
            games_played += 1
            # 交替主客场
            if games_played % 2 == 1:
                simulator = MatchSimulator(team1, team2)
            else:
                simulator = MatchSimulator(team2, team1)
            winner = simulator.simulate_game()
            if winner == team1:
                team1_wins += 1
            else:
                team2_wins += 1
            print(f"系列赛比分: {team1.name} {team1_wins} - {team2_wins} {team2.name}")
        series_winner = team1 if team1_wins > team2_wins else team2
        print(f"🏁 系列赛获胜: {series_winner.name}!")
        return series_winner
# ========== 统计分析类 ==========
class StatsAnalyzer:
    """统计分析类"""
    @staticmethod
    def analyze_team_performance(teams: List[Team]):
        """分析球队表现"""
        print("\n📊 球队战绩统计：")
        print("-"*40)
        # 按胜率排序
        sorted_teams = sorted(teams, key=lambda t: t.wins / max(t.wins + t.losses, 1), reverse=True)
        for i, team in enumerate(sorted_teams, 1):
            win_rate = team.wins / max(team.wins + team.losses, 1)
            rating = team.get_team_rating()
            print(f"第{i}名: {team.name}")
            print(f"  战绩: {team.wins}胜{team.losses}负 (胜率{win_rate:.1%})")
            print(f"  球队实力: {rating:.1f}")
            print(f"  最佳球员: {max(team.players, key=lambda p: p.overall)}")
            print()
    @staticmethod
    def analyze_player_stats(teams: List[Team]):
        """分析球员数据"""
        print("\n🌟 球员排行榜：")
        print("-"*40)
        all_players = []
        for team in teams:
            for player in team.players:
                all_players.append((player, team))
        # 按能力值排序
        sorted_players = sorted(all_players, key=lambda x: x[0].overall, reverse=True)
        print("MVP候选人 TOP 5:")
        for i, (player, team) in enumerate(sorted_players[:5], 1):
            print(f"  {i}. {player} - {team.name} 能力值:{player.overall}")
# ========== 数据生成器 ==========
def generate_players() -> List[Player]:
    """生成球员数据"""
    positions = ['PG', 'SG', 'SF', 'PF', 'C']
    first_names = ['库里', '詹姆斯', '杜兰特', '字母哥', '东契奇', '约基奇', 
                   '塔图姆', '布克', '恩比德', '莫兰特', '保罗', '利拉德']
    last_names = ['亚历山大', '汤普森', '格林', '戴维斯', '欧文', '威廉姆斯']
    players = []
    for i in range(10):  # 每队10人
        name = f"{random.choice(first_names)}{random.choice(last_names)}"
        position = random.choice(positions)
        # 生成不同水平的球员
        if i < 3:  # 明星球员
            overall = random.randint(88, 96)
            three_point = random.randint(85, 98)
        elif i < 6:  # 主力球员
            overall = random.randint(80, 88)
            three_point = random.randint(70, 90)
        else:  # 角色球员
            overall = random.randint(72, 80)
            three_point = random.randint(50, 75)
        players.append(Player(name, position, overall, three_point))
    return players
def create_teams() -> List[Team]:
    """创建球队"""
    team_names = [
        ("湖人", "洛杉矶"),
        ("勇士", "旧金山"),
        ("凯尔特人", "波士顿"),
        ("雄鹿", "密尔沃基"),
        ("太阳", "菲尼克斯"),
        ("掘金", "丹佛"),
    ]
    teams = []
    for city, name in team_names:
        players = generate_players()
        team = Team(name, city, players)
        teams.append(team)
    return teams
# ========== 主程序 ==========
def main():
    """主函数"""
    print("🎮 NBA季后赛模拟系统")
    print("="*50)
    # 创建球队
    print("\n📋 创建球队中...")
    teams = create_teams()
    # 显示球队信息
    print("\n🏟️ 参赛球队：")
    for team in teams:
        print(f"  {team.name} (实力评级: {team.get_team_rating():.1f})")
    # 创建分析器
    analyzer = StatsAnalyzer()
    # 运行模拟（可以多次运行）
    num_simulations = 3
    champions = defaultdict(int)
    for sim in range(num_simulations):
        print(f"\n{'='*50}")
        print(f"🎲 模拟第{sim+1}次季后赛")
        print(f"{'='*50}")
        # 重置战绩
        for team in teams:
            team.wins = 0
            team.losses = 0
        # 创建赛季模拟器
        season = SeasonSimulator(teams)
        # 模拟季后赛
        champion = season.simulate_playoff()
        champions[champion.name] += 1
        # 休息一会
        time.sleep(1)
    # 统计结果
    print("\n" + "="*50)
    print("📊 最终统计结果")
    print("="*50)
    # 显示冠军统计
    print("\n🏆 冠军次数统计：")
    for team_name, count in sorted(champions.items(), key=lambda x: x[1], reverse=True):
        print(f"  {team_name}: {count}次")
    # 分析球队表现
    analyzer.analyze_team_performance(teams)
    # 查看球员数据
    analyzer.analyze_player_stats(teams)
    # 得出最终结论
    final_champion = max(champions, key=champions.get)
    print(f"\n🎉 最终结论：{final_champion}队笑到了最后！他们获得了{champions[final_champion]}次冠军！")
    print("\n感谢观看！")
# 程序入口
if __name__ == "__main__":
    main()