综合python案例，中卫组合默契度如何量化？

wen python案例 2026-08-13 165
我来设计一个综合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()
主要功能特点：