我来设计一个综合Python案例，用于量化中卫组合的默契度,这个案例会整合多个维度的数据分析和处理：
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
from sklearn.preprocessing import StandardScaler
from sklearn.metrics.pairwise import cosine_similarity
import warnings
warnings.filterwarnings('ignore')
class DefenderPartnershipAnalyzer:
"""
中卫组合默契度分析系统
通过多个维度量化中卫搭档的默契程度
"""
def __init__(self):
self.data = None
self.scores = {}
def generate_sample_data(self, n_matches=50):
"""
生成模拟比赛数据
包含传球、防守、跑位、交流等维度
"""
np.random.seed(42)
# 中卫组合
defenders = [
('Van Dijk', 'Matip'),
('Stones', 'Dias'),
('Ramos', 'Varane'),
('Pique', 'Lenglet')
]
matches = []
for match_id in range(1, n_matches+1):
for defender_pair in defenders:
d1, d2 = defender_pair
# 基础默契指标
base_sync = np.random.normal(75, 8)
# 传球配合
pass_attempts = np.random.randint(30, 60)
pass_completions = int(pass_attempts * (0.75 + np.random.normal(0, 0.05)))
key_passes = np.random.randint(5, 15)
# 防守协同
defensive_actions = np.random.randint(15, 30)
combined_tackles = int(defensive_actions * np.random.uniform(0.2, 0.4))
interceptions = np.random.randint(5, 15)
clearances = np.random.randint(10, 20)
# 位置协同
offside_traps = np.random.randint(0, 5)
offside_trap_success = np.random.uniform(0.3, 0.8)
# 跑动配合
d1_distance = np.random.uniform(8, 12) # km
d2_distance = np.random.uniform(8, 12)
distance_difference = abs(d1_distance - d2_distance)
# 沟通交流
communications = np.random.randint(20, 50)
successful_communications = int(communications * np.random.uniform(0.6, 0.9))
# 比赛结果
goals_conceded = np.random.poisson(1.2)
clean_sheet = 1 if goals_conceded == 0 else 0
match_result = np.random.choice(['win', 'draw', 'loss'], p=[0.5, 0.3, 0.2])
matches.append({
'match_id': match_id,
'defender_pair': f'{d1} & {d2}',
'd1_name': d1,
'd2_name': d2,
'pass_attempts': pass_attempts,
'pass_completions': pass_completions,
'pass_accuracy': pass_completions / pass_attempts * 100,
'key_passes': key_passes,
'defensive_actions': defensive_actions,
'combined_tackles': combined_tackles,
'interceptions': interceptions,
'clearances': clearances,
'offside_traps': offside_traps,
'offside_trap_success_rate': offside_trap_success * 100,
'd1_distance': d1_distance,
'd2_distance': d2_distance,
'distance_difference': distance_difference,
'communications': communications,
'successful_communications': successful_communications,
'communication_accuracy': successful_communications / communications * 100,
'goals_conceded': goals_conceded,
'clean_sheet': clean_sheet,
'match_result': match_result,
'base_sync': base_sync,
'defensive_solidity': 100 - goals_conceded * 20 + clean_sheet * 15
})
self.data = pd.DataFrame(matches)
return self.data
def calculate_pass_coordination(self):
"""传球配合默契度"""
df = self.data.groupby('defender_pair').agg({
'pass_accuracy': 'mean',
'key_passes': 'mean',
'pass_completions': 'sum'
}).reset_index()
# 标准化后计算综合得分
scaler = StandardScaler()
df['pass_score'] = scaler.fit_transform(df[['pass_accuracy', 'key_passes']]).mean(axis=1) * 50 + 50
df['pass_score'] = df['pass_score'].clip(0, 100)
return df[['defender_pair', 'pass_score', 'pass_accuracy', 'key_passes']]
def calculate_defensive_coordination(self):
"""防守协同默契度"""
df = self.data.groupby('defender_pair').agg({
'combined_tackles': 'mean',
'interceptions': 'mean',
'clearances': 'mean',
'defensive_solidity': 'mean'
}).reset_index()
# 权重分配
weights = {
'combined_tackles': 0.3,
'interceptions': 0.3,
'clearances': 0.2,
'defensive_solidity': 0.2
}
df['defensive_score'] = 0
for col, weight in weights.items():
if col == 'defensive_solidity':
df['defensive_score'] += df[col] * weight
else:
normalized = (df[col] - df[col].min()) / (df[col].max() - df[col].min()) * 100
df['defensive_score'] += normalized * weight
return df[['defender_pair', 'defensive_score', 'combined_tackles', 'interceptions', 'clearances']]
def calculate_positional_sync(self):
"""位置协同默契度"""
df = self.data.groupby('defender_pair').agg({
'offside_trap_success_rate': 'mean',
'distance_difference': 'mean',
'd1_distance': 'mean',
'd2_distance': 'mean'
}).reset_index()
# 位置同步性：距离差异越小越好
df['positional_sync'] = 100 - (df['distance_difference'] / 2 * 100)
# 越位陷阱成功率
df['positional_sync'] = 0.5 * df['positional_sync'] + 0.5 * df['offside_trap_success_rate']
# 限制在0-100范围
df['positional_sync'] = df['positional_sync'].clip(0, 100)
return df[['defender_pair', 'positional_sync', 'offside_trap_success_rate', 'distance_difference']]
def calculate_communication_quality(self):
"""沟通质量默契度"""
df = self.data.groupby('defender_pair').agg({
'communication_accuracy': 'mean',
'communications': 'sum'
}).reset_index()
# 沟通量和准确度综合评估
scaler = StandardScaler()
df['communication_score'] = scaler.fit_transform(
df[['communication_accuracy', 'communications']]
).mean(axis=1) * 50 + 50
df['communication_score'] = df['communication_score'].clip(0, 100)
return df[['defender_pair', 'communication_score', 'communication_accuracy', 'communications']]
def calculate_tactical_synergy(self):
"""战术执行同步性（基于比赛结果）"""
df = self.data.groupby('defender_pair').agg({
'clean_sheet': 'mean',
'goals_conceded': 'mean',
'base_sync': 'mean'
}).reset_index()
# 综合战术效果
df['tactical_score'] = (
df['clean_sheet'] * 40 +
(1 - df['goals_conceded'] / 5) * 30 +
df['base_sync'] / 100 * 30
)
df['tactical_score'] = df['tactical_score'].clip(0, 100)
return df[['defender_pair', 'tactical_score', 'clean_sheet', 'goals_conceded']]
def comprehensive_sync_score(self):
"""综合默契度评分（加权平均）"""
print("\n" + "="*80)
print("中卫组合默契度综合分析报告")
print("="*80)
# 计算各个维度的分数
pass_score = self.calculate_pass_coordination()
defensive_score = self.calculate_defensive_coordination()
positional_sync = self.calculate_positional_sync()
communication_score = self.calculate_communication_quality()
tactical_score = self.calculate_tactical_synergy()
# 合并所有分数
final_df = pass_score[['defender_pair', 'pass_score']].merge(
defensive_score[['defender_pair', 'defensive_score']], on='defender_pair'
).merge(
positional_sync[['defender_pair', 'positional_sync']], on='defender_pair'
).merge(
communication_score[['defender_pair', 'communication_score']], on='defender_pair'
).merge(
tactical_score[['defender_pair', 'tactical_score']], on='defender_pair'
)
# 权重配置（可调整）
weights = {
'pass_score': 0.25,
'defensive_score': 0.3,
'positional_sync': 0.2,
'communication_score': 0.1,
'tactical_score': 0.15
}
# 计算综合得分
final_df['final_sync_score'] = sum(
final_df[col] * weight for col, weight in weights.items()
)
# 评级
def get_grade(score):
if score >= 85: return 'S级（配合默契）'
elif score >= 70: return 'A级（配合良好）'
elif score >= 55: return 'B级（基本联系）'
else: return 'C级（需要提升）'
final_df['grade'] = final_df['final_sync_score'].apply(get_grade)
# 排序
final_df = final_df.sort_values('final_sync_score', ascending=False)
# 输出结果
print("\n中卫组合默契度排行：")
print("-"*80)
for idx, row in final_df.iterrows():
print(f"\n组合: {row['defender_pair']}")
print(f"综合得分: {row['final_sync_score']:.2f} | 评级: {row['grade']}")
print(f"传球配合: {row['pass_score']:.2f} | 防守协同: {row['defensive_score']:.2f} "
f"| 位置同步: {row['positional_sync']:.2f} | 沟通质量: {row['communication_score']:.2f} "
f"| 战术执行: {row['tactical_score']:.2f}")
# 保存结果
self.final_df = final_df
return final_df
def visualize_sync_analysis(self):
"""可视化分析"""
if not hasattr(self, 'final_df'):
print("请先运行综合分析")
return
# 设置中文显示
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False
# 1. 雷达图
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
# 雷达图数据
categories = ['传球配合', '防守协同', '位置同步', '沟通质量', '战术执行']
cat_vars = ['pass_score', 'defensive_score', 'positional_sync',
'communication_score', 'tactical_score']
for idx, (ax, (pair, row)) in enumerate(zip(axes.flatten(), self.final_df.iterrows())):
# 雷达图
if idx < 4:
values = [row[col] for col in cat_vars]
values += values[:1]
angles = np.linspace(0, 2*np.pi, len(cat_vars), endpoint=False).tolist()
angles += angles[:1]
ax.plot(angles, values, 'o-', linewidth=2, color='blue' if idx==0 else 'green')
ax.fill(angles, values, alpha=0.25)
ax.set_xticks(angles[:-1])
ax.set_xticklabels(categories, fontsize=8)
ax.set_ylim(0, 100)
ax.set_title(f"{pair} - 得分:{row['final_sync_score']:.1f}", fontsize=10)
ax.grid(True)
plt.suptitle('中卫组合默契度雷达图', fontsize=16, y=1.02)
plt.tight_layout()
plt.savefig('defender_sync_radar.png', dpi=150, bbox_inches='tight')
plt.show()
# 2. 柱状图
fig, ax = plt.subplots(figsize=(10, 6))
pairs = self.final_df['defender_pair']
scores = self.final_df['final_sync_score']
colors = ['blue' if score >= 80 else 'green' if score >= 70 else 'orange' for score in scores]
bars = ax.bar(pairs, scores, color=colors)
ax.set_ylabel('默契度得分')
ax.set_title('中卫组合综合默契度对比')
ax.set_ylim(0, 100)
# 添加数据标签
for bar, score in zip(bars, scores):
ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 2,
f'{score:.1f}', ha='center', fontweight='bold')
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('defender_sync_comparison.png', dpi=150)
plt.show()
# 3. 热力图
fig, ax = plt.subplots(figsize=(10, 8))
heatmap_data = self.final_df[['defender_pair'] + cat_vars].set_index('defender_pair')
sns.heatmap(heatmap_data, annot=True, fmt='.1f', cmap='YlOrRd', ax=ax)
ax.set_title('中卫组合各维度默契度热力图')
plt.tight_layout()
plt.savefig('defender_sync_heatmap.png', dpi=150)
plt.show()
def identify_improvement_areas(self, pair_name):
"""识别特定组合的改进空间"""
if not hasattr(self, 'final_df'):
print("请先运行综合分析")
return
pair_data = self.final_df[self.final_df['defender_pair'] == pair_name]
if pair_data.empty:
print(f"未找到组合: {pair_name}")
return
print(f"\n{pair_name} 改进分析：")
print("-"*40)
cols = ['pass_score', 'defensive_score', 'positional_sync',
'communication_score', 'tactical_score']
labels = ['传球配合', '防守协同', '位置同步', '沟通质量', '战术执行']
# 找出较弱维度
for col, label in zip(cols, labels):
value = pair_data[col].values[0]
avg = self.final_df[col].mean()
if value < avg:
diff = avg - value
print(f"📉 {label}低于平均值 {diff:.2f}分，需要重点提升")
else:
diff = value - avg
print(f"📈 {label}高于平均值 {diff:.2f}分")
def predict_success_rate(self):
"""
预测组合成功率（基于历史数据）
"""
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
# 准备特征
features = [
'pass_accuracy', 'key_passes', 'combined_tackles',
'interceptions', 'clearances', 'offside_trap_success_rate',
'communication_accuracy', 'distance_difference'
]
X = self.data[features]
y = self.data['defensive_solidity']
# 训练模型
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# 预测
predictions = model.predict(X_test)
# 评估
from sklearn.metrics import r2_score, mean_squared_error
r2 = r2_score(y_test, predictions)
mse = mean_squared_error(y_test, predictions)
print(f"\n模型预测能力评估：")
print(f"R²分数: {r2:.4f} (接近1表示预测能力好)")
print(f"MSE: {mse:.2f}")
# 特征重要性
feature_importance = pd.Series(
model.feature_importances_,
index=features
).sort_values(ascending=False)
print("\n影响防守稳固性的关键因素：")
for feature, importance in feature_importance.iteritems():
print(f" {feature}: {importance:.3f}")
return model
# 主程序
def main():
# 创建分析器
analyzer = DefenderPartnershipAnalyzer()
# 生成模拟数据
print("生成模拟比赛数据...")
data = analyzer.generate_sample_data(n_matches=100)
print(f"共 {len(data)} 条比赛记录")
# 运行综合分析
results = analyzer.comprehensive_sync_score()
# 可视化
analyzer.visualize_sync_analysis()
# 针对特定组合分析
analyzer.identify_improvement_areas('Van Dijk & Matip')
# 预测模型
analyzer.predict_success_rate()
# 输出分析总结
print("\n" + "="*80)
print("分析总结")
print("="*80)
print("本次分析综合了以下维度：")
print("1. 传球配合默契度")
print("2. 防守协同能力")
print("3. 位置同步性")
print("4. 沟通质量")
print("5. 战术执行效果")
print("\n量化指标采用0-100分制，权重可根据实际需求调整")
# 保存结果
if hasattr(analyzer, 'final_df'):
analyzer.final_df.to_csv('defender_sync_analysis.csv', index=False)
print("\n分析结果已保存至 defender_sync_analysis.csv")
if __name__ == "__main__":
main()
主要功能特点：
-
多维度分析：
- 传球配合默契度
- 防守协同能力
- 位置同步性
- 沟通质量
- 战术执行效果
-
综合评分系统：
- 采用加权平均算法
- 可自定义权重
- 输出各维度明细分数
-
数据可视化：
- 雷达图展示各维度表现
- 柱状图对比组合
- 热力图显示细节
-
智能分析：
- 机器学习预测
- 特征重要性分析
- 针对性改进建议
-
实用功能：
- 自动生成报告
- 数据导出
- 组合横向对比
使用场景：
- 教练团队评估中卫搭档
- 转会市场球员评价
- 战术调整数据支持
- 球员训练效果追踪
这个框架可以被扩展用于实际数据分析,只需替换数据源和调整参数即可。
