本文目录导读：
我来设计一个有趣的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()
🎯 程序特色
这个综合案例包含了：
- 面向对象编程：使用
@dataclass定义球员和球队类 - 继承与组合：各类之间互相协作
- 算法设计：比赛模拟算法、统计数据计算
- 数据可视化：清晰的比赛数据输出
- 交互体验：模拟比赛过程，显示详细数据
📊 运行效果
程序会：
- 生成6支随机球队
- 模拟3次完整的季后赛
- 统计哪支球队赢得最多冠军
- 显示详细的比赛数据
- 分析球员和球队表现
运行这个程序,你就能看到哪队能笑到最后！由于有随机因素，每次运行结果都可能不同，增加了趣味性。
