本文目录导读：
我来设计一个综合Python案例,模拟篮球/足球比赛中轮转换位防守的默契度评估系统。
完整案例：防守轮转换位默契度分析系统
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from collections import defaultdict
import warnings
warnings.filterwarnings('ignore')
# 设置中文显示
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
class DefenseRotationAnalyzer:
"""
防守轮转换位默契度分析系统
模拟5名防守球员的轮转换位配合质量
"""
def __init__(self, team_name="Team_A"):
self.team_name = team_name
self.players = ['P1', 'P2', 'P3', 'P4', 'P5']
self.positions = ['PG', 'SG', 'SF', 'PF', 'C']
self.defense_data = None
self.rotation_metrics = {}
self.synergy_scores = {}
def generate_rotation_data(self, n_plays=100):
"""
生成模拟防守轮转数据
包含时间、球员位置、移动距离、防守成功与否等信息
"""
np.random.seed(42)
data = []
# 标准防守站位（半场防守位置）
standard_positions = {
'PG': [0, 4], 'SG': [0, 2], 'SF': [0, 0],
'PF': [3, 1], 'C': [3, -1]
}
for play in range(n_plays):
# 模拟进攻方位置
offense_pos = np.random.rand(2) * [8, 10]
for player in self.players:
pos_idx = self.players.index(player)
position = self.positions[pos_idx]
# 模拟球员移动（包含默契度好的快速补位和差的延迟）
base_speed = np.random.normal(1.0, 0.2)
rotation_quality = np.random.uniform(0.5, 1.5)
# 计算该球员移动距离（根据位置和进攻方位置）
standard_pos = standard_positions[position]
distance_to_offense = np.linalg.norm(np.array(standard_pos) - offense_pos)
movement_distance = distance_to_offense * base_speed * (2 - rotation_quality)
# 判断防守成功概率（距离越近成功率越高）
success_prob = max(0, 1 - movement_distance/15) * rotation_quality
defense_success = np.random.random() < min(success_prob, 0.9)
# 模拟和相邻球员的配合时间差
team_sync = np.random.normal(0.5, 0.3) # 0-1之间的同步率
data.append({
'play_id': play,
'player': player,
'position': position,
'x': standard_pos[0] + np.random.normal(0, 0.5),
'y': standard_pos[1] + np.random.normal(0, 0.5),
'movement_distance': movement_distance,
'defense_success': defense_success,
'reaction_time': np.random.exponential(0.3) / rotation_quality,
'team_sync': team_sync,
'opponent_zone': int(offense_pos[0] // 2), # 进攻区域
'rotation_quality': rotation_quality
})
self.defense_data = pd.DataFrame(data)
return self.defense_data
def calculate_rotation_metrics(self):
"""
计算轮转换位的关键指标
"""
if self.defense_data is None:
raise ValueError("请先生成数据")
# 1. 个人防守效率
player_stats = self.defense_data.groupby('player').agg({
'defense_success': ['mean', 'count'],
'movement_distance': 'mean',
'reaction_time': 'mean',
'team_sync': 'mean'
}).round(3)
player_stats.columns = ['success_rate', 'plays', 'avg_distance', 'avg_reaction', 'avg_sync']
player_stats['efficiency'] = player_stats['success_rate'] * 100
self.player_stats = player_stats
# 2. 球员间的默契度矩阵
synergy_matrix = np.zeros((5, 5))
# 定义球员间的相邻关系
adjacent_relations = [
(0, 1), (1, 2), (2, 3), (3, 4), # 位置相邻
(0, 2), (1, 3), (2, 4) # 跳位补防
]
for i, j in adjacent_relations:
# 计算两个球员的配合默契度
p1_data = self.defense_data[self.defense_data['player'] == self.players[i]]
p2_data = self.defense_data[self.defense_data['player'] == self.players[j]]
# 同步率平均值
sync_score = np.mean([
p1_data['team_sync'].mean(),
p2_data['team_sync'].mean()
])
# 防守成功率互补
success_complement = np.mean([
p1_data['defense_success'].mean(),
p2_data['defense_success'].mean()
])
# 反应时间一致性（方差越小越默契）
reaction_consistency = 1 - np.std(p1_data['reaction_time'].values - p2_data['reaction_time'].values)
synergy_score = (sync_score * 0.4 + success_complement * 0.4 + reaction_consistency * 0.2)
synergy_matrix[i, j] = synergy_matrix[j, i] = synergy_score
self.synergy_matrix = synergy_matrix
# 3. 整体团队默契度
team_scores = {
'overall_synergy': np.mean([self.player_stats['avg_sync'].mean(),
self.player_stats['success_rate'].mean() * 0.5]),
'avg_reaction_consistency': np.mean(self.synergy_matrix[self.synergy_matrix > 0]),
'defense_efficiency': self.player_stats['efficiency'].mean()
}
self.rotation_metrics = team_scores
return self.player_stats, self.synergy_matrix, team_scores
def analyze_rotation_zones(self):
"""
分析不同防守区域的轮转表现
"""
# 按区域分析
zone_analysis = self.defense_data.groupby(['opponent_zone', 'player']).agg({
'defense_success': 'mean',
'movement_distance': 'mean',
'reaction_time': 'mean'
}).reset_index()
zone_performance = zone_analysis.groupby('opponent_zone').agg({
'defense_success': 'mean',
'movement_distance': 'mean',
'reaction_time': 'mean'
}).round(3)
zone_performance.columns = ['success_rate', 'avg_distance', 'avg_reaction']
# 判断弱侧防守区域
weak_zones = zone_performance[zone_performance['success_rate'] < zone_performance['success_rate'].mean()].index.tolist()
return zone_performance, weak_zones
def detect_rotation_patterns(self):
"""
使用K-means聚类识别防守模式
"""
# 提取特征
features = self.defense_data[['movement_distance', 'reaction_time', 'team_sync', 'rotation_quality']]
scaler = StandardScaler()
features_scaled = scaler.fit_transform(features)
# K-means聚类
kmeans = KMeans(n_clusters=3, random_state=42)
self.defense_data['pattern'] = kmeans.fit_predict(features_scaled)
# 分析每个pattern的特征
pattern_analysis = self.defense_data.groupby('pattern').agg({
'defense_success': 'mean',
'movement_distance': 'mean',
'reaction_time': 'mean'
}).round(3)
pattern_labels = {0: '高效补防', 1: '延迟反应', 2: '过度移动'}
pattern_analysis['type'] = [pattern_labels.get(i, '未知') for i in pattern_analysis.index]
return pattern_analysis
def generate_performance_report(self):
"""
生成综合性能报告和可视化
"""
if not self.rotation_metrics:
self.calculate_rotation_metrics()
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
# 1. 球员防守效率柱状图
ax1 = axes[0, 0]
self.player_stats['efficiency'].plot(kind='bar', ax=ax1, color='skyblue')
ax1.set_title('球员防守效率')
ax1.set_xlabel('球员')
ax1.set_ylabel('效率(%)')
ax1.set_ylim(0, 100)
# 2. 默契度矩阵热力图
ax2 = axes[0, 1]
sns.heatmap(self.synergy_matrix, annot=True, fmt='.2f', cmap='YlGnBu',
xticklabels=self.players, yticklabels=self.players, ax=ax2)
ax2.set_title('球员间默契度矩阵')
# 3. 移动距离分布
ax3 = axes[0, 2]
self.defense_data.groupby('player')['movement_distance'].plot(kind='line', ax=ax3)
ax3.set_title('球员移动距离趋势')
ax3.set_xlabel('比赛回合')
ax3.set_ylabel('移动距离')
ax3.legend(self.players, loc='upper right')
# 4. 反应时间箱线图
ax4 = axes[1, 0]
self.defense_data.boxplot(column='reaction_time', by='player', ax=ax4)
ax4.set_title('球员反应时间分布')
ax4.set_xlabel('球员')
ax4.set_ylabel('反应时间')
plt.suptitle('')
# 5. 防守模式分布
ax5 = axes[1, 1]
if 'pattern' in self.defense_data.columns:
pattern_counts = self.defense_data['pattern'].value_counts()
ax5.pie(pattern_counts, labels=['高效补防', '延迟反应', '过度移动'], autopct='%1.1f%%')
ax5.set_title('防守模式分布')
# 6. 区域防守表现
zone_perf = self.defense_data.groupby('opponent_zone')['defense_success'].mean()
ax6 = axes[1, 2]
zone_perf.plot(kind='line', marker='o', ax=ax6)
ax6.set_title('不同区域防守成功率')
ax6.set_xlabel('防守区域')
ax6.set_ylabel('成功率')
ax6.set_ylim(0.5, 1)
plt.tight_layout()
plt.show()
return fig
def get_synergy_ranking(self):
"""
Get synergy ranking
"""
player_synergy = self.synergy_matrix.sum(axis=1)
ranking = pd.DataFrame({
'player': self.players,
'position': self.positions,
'synergy_score': player_synergy,
'efficiency': self.player_stats['efficiency'].values
})
ranking['overall'] = ranking['synergy_score'] * 0.6 + ranking['efficiency'] / 100 * 0.4
ranking = ranking.sort_values('overall', ascending=False)
ranking['rank'] = range(1, 6)
return ranking
def main():
"""
主程序 - 执行完整分析流程
"""
print("="*60)
print("篮球防守轮转换位默契度分析系统")
print("="*60)
# 1. 初始化分析器
analyzer = DefenseRotationAnalyzer("Champions")
# 2. 生成模拟数据
print("\n1. 生成模拟防守数据...")
data = analyzer.generate_rotation_data(n_plays=200)
print(f" 数据生成完成：{len(data)} 条记录")
# 3. 计算轮转指标
print("\n2. 计算轮转指标...")
player_stats, synergy_matrix, team_scores = analyzer.calculate_rotation_metrics()
print("\n球员个人统计：")
print(player_stats.round(3))
print("\n团队默契度指标：")
for key, value in team_scores.items():
print(f" {key}: {value:.3f}")
# 4. 区域分析
print("\n3. 防守区域分析...")
zone_perf, weak_zones = analyzer.analyze_rotation_zones()
print("区域防守表现：")
print(zone_perf)
print(f"薄弱区域：{weak_zones}")
# 5. 模式识别
print("\n4. 防守模式识别...")
patterns = analyzer.detect_rotation_patterns()
print("防守模式分析：")
print(patterns)
# 6. 球员排名
print("\n5. 球员综合排名：")
ranking = analyzer.get_synergy_ranking()
print(ranking[['player', 'position', 'synergy_score', 'efficiency', 'overall', 'rank']])
# 7. 生成可视化报告
print("\n6. 生成可视化报告...")
fig = analyzer.generate_performance_report()
# 8. 输出总结
print("\n" + "="*60)
print("分析总结：")
print(f"团队整体防守效率：{team_scores['defense_efficiency']:.1f}%")
print(f"轮转默契度指数：{team_scores['overall_synergy']:.3f}")
print(f"平均反应一致性：{team_scores['avg_reaction_consistency']:.3f}")
print("="*60)
# 9. 建议生成
print("\n改进建议：")
if weak_zones:
print(f" - 加强区域 {weak_zones} 的轮转训练")
if team_scores['avg_reaction_consistency'] < 0.6:
print(" - 提高球员间的反应协同性")
worst_player = ranking.iloc[-1]
print(f" - 重点关注 {worst_player['player']} ({worst_player['position']}) 的防守意识提升")
if __name__ == "__main__":
main()
进阶版本：包含实时模拟和AI建议
import time
import random
from datetime import datetime
class AdvancedDefenseAnalysis(DefenseRotationAnalyzer):
"""
高级防守分析：包含实时模拟和AI决策建议
"""
def __init__(self, team_name="Elite_Team"):
super().__init__(team_name)
self.decision_history = []
self.optimal_lineups = []
def simulate_live_game(self, n_minutes=10):
"""
模拟实时比赛防守表现
"""
print(f"\n模拟 {n_minutes} 分钟实时防守...")
timeline_data = []
for minute in range(n_minutes):
# 模拟每分钟的防守回合
n_possessions = random.randint(3, 6)
for possession in range(n_possessions):
# 随机进攻位置
offense_location = np.random.rand(2) * [10, 10]
# 模拟防守反应
team_alertness = np.random.normal(0.7, 0.1)
defense_effectiveness = team_alertness * np.random.beta(2, 3)
# 记录决策点
decision = {
'minute': minute,
'possession': possession + 1,
'offense_location': offense_location,
'defense_score': defense_effectiveness,
'needs_rotation': defense_effectiveness < 0.5,
'rotated': random.random() < 0.6 if defense_effectiveness < 0.5 else True,
'action_taken': random.choice(['贴防', '协防', '换防'])
}
timeline_data.append(decision)
self.decision_history.append(decision)
time.sleep(0.1) # 模拟实时数据流
self.timeline_data = pd.DataFrame(timeline_data)
return self.timeline_data
def analyze_real_time_decisions(self):
"""
分析实时决策质量
"""
if not self.decision_history:
return "无决策数据"
df = self.timeline_data
metrics = {
'total_decisions': len(df),
'avg_alertness': df['defense_score'].mean(),
'rotation_necessity': (df['needs_rotation']).mean(),
'rotation_fulfillment': (df[df['needs_rotation']]['rotated']).mean() if df['needs_rotation'].any() else 0,
'action_distribution': df['action_taken'].value_counts(normalize=True).to_dict()
}
return metrics
def generate_strategy_recommendations(self):
"""
生成智能策略建议
"""
recommendations = []
# 基于数据的策略建议
player_data = self.player_stats
weak_players = player_data[player_data['efficiency'] < 70].index.tolist()
strong_players = player_data[player_data['efficiency'] > 85].index.tolist()
if weak_players:
recommendations.append(f"建议对 {weak_players} 进行针对性训练，提升单防效率")
if strong_players:
recommendations.append(f"可考虑以 {strong_players} 为核心组建防守阵容")
if 'pattern' in self.defense_data.columns:
poor_pattern = self.defense_data.groupby('pattern')['defense_success'].mean().idxmin()
if self.defense_data[self.defense_data['pattern'] == poor_pattern]['defense_success'].mean() < 0.6:
recommendations.append("防守出现延迟反应模式，需要提高预判能力")
# 阵容推荐
if hasattr(self, 'synergy_matrix'):
best_pair = np.unravel_index(np.argmax(self.synergy_matrix), self.synergy_matrix.shape)
recommendations.append(f"最优防守对位：{self.players[best_pair[0]]} - {self.players[best_pair[1]]}")
return recommendations
def create_defense_heatmap(self):
"""
生成防守热力图
"""
if self.defense_data is None:
return None
# 简化版热力图
x = self.defense_data['x']
y = self.defense_data['y']
fig, ax = plt.subplots(figsize=(10, 8))
hb = ax.hexbin(x, y, gridsize=30, cmap='YlOrRd')
plt.colorbar(hb, label='防守强度')
ax.set_title('团队防守热力图')
ax.set_xlabel('X方向')
ax.set_ylabel('Y方向')
plt.show()
return fig
# 高级使用示例
def advanced_analysis():
"""
高级分析流程
"""
print("\n" + "★"*50)
print("高级防守分析系统")
print("★"*50)
# 初始化
analyzer = AdvancedDefenseAnalysis("Elite_Team")
# 基础分析
data = analyzer.generate_rotation_data(500)
analyzer.calculate_rotation_metrics()
# 实时模拟
print("\n[实时防守模拟]")
live_data = analyzer.simulate_live_game(n_minutes=3)
# 决策分析
print("\n[决策质量分析]")
decision_metrics = analyzer.analyze_real_time_decisions()
print("决策指标：")
for key, value in decision_metrics.items():
print(f" {key}: {value}")
# 策略建议
print("\n[智能策略建议]")
recommendations = analyzer.generate_strategy_recommendations()
for i, rec in enumerate(recommendations, 1):
print(f" {i}. {rec}")
# 可视化
print("\n[生成防守热力图]")
analyzer.create_defense_heatmap()
return analyzer
# 执行高级分析
if __name__ == "__main__":
# 基础版分析
main()
# 高级版分析
print("\n" + "="*50)
print("切换至高级分析模式...")
print("="*50)
advanced_analyzer = advanced_analysis()
输出示例
运行后会生成：
- 球员防守效率统计表：显示每个球员的成功率、移动距离、反应时间
- 球员间默契度矩阵：5x5热力图显示队友间的配合程度
- 防守模式识别：识别出高效补防、延迟反应、过度移动等模式
- 实时决策分析：模拟比赛中的防守决策质量
- 可视化报告：
- 球员防守效率柱状图
- 默契度矩阵热力图
- 移动距离趋势图
- 反应时间箱线图
- 防守模式分布饼图
- 区域防守表现折线图
这个系统综合运用了：
- NumPy/Pandas：数据处理和分析
- Matplotlib/Seaborn：可视化
- Scikit-learn：K-means聚类识别防守模式
- 面向对象编程：类的设计和封装
- 统计分析：成功率、标准差、相关性分析
- 实时模拟：模拟比赛中的动态决策
这个案例可以评估球队的防守轮换默契度,识别薄弱环节，并给出改进建议。
