python案例统计界外球进攻威胁次数？

wen python案例 2026-08-14 172

本文目录导读：

完整案例：界外球进攻威胁统计系统
可视化分析（可选）

我来设计一个足球比赛中统计界外球进攻威胁次数的Python案例。

完整案例：界外球进攻威胁统计系统

import pandas as pd
import numpy as np
from datetime import datetime
import json
class ThrowInThreatAnalyzer:
    """界外球进攻威胁分析器"""
    def __init__(self):
        # 威胁等级定义
        self.threat_levels = {
            '极低': 1,
            '低': 2,
            '中等': 3,
            '高': 4,
            '极高': 5
        }
        # 记录所有事件
        self.events = []
    def add_throw_in_event(self, 
                          team_name, 
                          player_name, 
                          throw_in_position,
                          receiver_position,
                          is_long_throw,
                          is_direct_into_box,
                          outcome,
                          minute):
        """
        添加一次界外球事件记录
        参数:
        - team_name: 球队名称
        - player_name: 掷球员姓名
        - throw_in_position: 掷球位置 (x, y坐标)
        - receiver_position: 接球位置 (x, y坐标)
        - is_long_throw: 是否为长距离界外球
        - is_direct_into_box: 是否直接掷入禁区
        - outcome: 结果 ('成功接球', '争抢', '直接射门', '解围', '出界', '犯规')
        - minute: 比赛分钟
        """
        event = {
            'team': team_name,
            'player': player_name,
            'throw_in_position': throw_in_position,
            'receiver_position': receiver_position,
            'is_long_throw': is_long_throw,
            'is_direct_into_box': is_direct_into_box,
            'outcome': outcome,
            'minute': minute,
            'timestamp': datetime.now()
        }
        # 计算威胁分数
        event['threat_score'] = self._calculate_threat_score(event)
        self.events.append(event)
        return event
    def _calculate_distance_to_goal(self, position, goal_position=(105, 37.5)):
        """计算到球门的距离"""
        return np.sqrt((position[0] - goal_position[0])**2 + 
                      (position[1] - goal_position[1])**2)
    def _calculate_threat_score(self, event):
        """
        计算威胁分数 (1-10分)
        考虑因素:
        - 掷球位置距离球门的距离
        - 接球位置离球门的距离
        - 是否为长距离界外球
        - 是否直接掷入禁区
        - 结果类型
        """
        score = 0
        # 1. 掷球位置因素 (占总分30%)
        throw_in_distance = self._calculate_distance_to_goal(event['throw_in_position'])
        if throw_in_distance < 20:
            score += 3  # 距离球门很近
        elif throw_in_distance < 30:
            score += 2  # 靠近禁区
        elif throw_in_distance < 40:
            score += 1  # 中场附近
        # 超过40米不加分
        # 2. 接球位置因素 (占总分30%)
        receiver_distance = self._calculate_distance_to_goal(event['receiver_position'])
        if receiver_distance < 15:
            score += 3  # 直接在禁区/小禁区
        elif receiver_distance < 25:
            score += 2  # 禁区附近
        elif receiver_distance < 35:
            score += 1  # 大禁区外
        # 3. 战术因素 (占总分20%)
        if event['is_long_throw']:
            score += 1
        if event['is_direct_into_box']:
            score += 1
        # 4. 事件结果因素 (占总分20%)
        outcome_scores = {
            '直接射门': 2,
            '成功接球': 1.5,
            '争抢': 1,
            '解围': 0.5,
            '出界': 0,
            '犯规': 0
        }
        score += outcome_scores.get(event['outcome'], 0)
        # 标准化到1-10分
        score = min(max(score, 1), 10)
        return round(score, 1)
    def get_team_threat_summary(self, team_name=None):
        """获取球队威胁统计"""
        if team_name:
            team_events = [e for e in self.events if e['team'] == team_name]
        else:
            team_events = self.events
        if not team_events:
            return {}
        summary = {
            'total_throw_ins': len(team_events),
            'average_threat_score': np.mean([e['threat_score'] for e in team_events]),
            'high_threat_count': len([e for e in team_events if e['threat_score'] >= 7]),
            'medium_threat_count': len([e for e in team_events if 4 <= e['threat_score'] < 7]),
            'low_threat_count': len([e for e in team_events if e['threat_score'] < 4]),
            'long_throw_count': len([e for e in team_events if e['is_long_throw']]),
            'into_box_count': len([e for e in team_events if e['is_direct_into_box']]),
            'dangerous_zone_minutes': [e['minute'] for e in team_events if e['threat_score'] >= 8]
        }
        return summary
    def get_threat_trend_by_minute(self, interval=15):
        """按时间段统计威胁趋势"""
        trend = {}
        for event in self.events:
            period = f"{((event['minute']-1)//interval)*interval + 1}-{((event['minute']-1)//interval)*interval + interval}分钟"
            if period not in trend:
                trend[period] = {'count': 0, 'total_threat': 0}
            trend[period]['count'] += 1
            trend[period]['total_threat'] += event['threat_score']
        # 计算平均威胁
        for period in trend:
            trend[period]['average_threat'] = trend[period]['total_threat'] / trend[period]['count']
        return trend
    def get_player_ranking(self):
        """球员威胁排名"""
        player_stats = {}
        for event in self.events:
            player = event['player']
            if player not in player_stats:
                player_stats[player] = {
                    'throw_ins': 0,
                    'total_threat': 0,
                    'max_threat': 0,
                    'high_threat_throws': 0
                }
            player_stats[player]['throw_ins'] += 1
            player_stats[player]['total_threat'] += event['threat_score']
            player_stats[player]['max_threat'] = max(player_stats[player]['max_threat'], 
                                                    event['threat_score'])
            if event['threat_score'] >= 7:
                player_stats[player]['high_threat_throws'] += 1
        # 计算平均威胁并排序
        for player in player_stats:
            player_stats[player]['average_threat'] = (
                player_stats[player]['total_threat'] / player_stats[player]['throw_ins']
            )
        ranking = sorted(player_stats.items(), 
                        key=lambda x: (x[1]['average_threat'], x[1]['high_threat_throws']), 
                        reverse=True)
        return ranking
    def identify_dangerous_patterns(self):
        """识别危险模式"""
        patterns = []
        # 模式1: 连续高威胁界外球
        for i in range(len(self.events) - 2):
            consecutive = self.events[i:i+3]
            if all(e['threat_score'] >= 7 for e in consecutive):
                patterns.append({
                    'type': '连续高威胁界外球',
                    'team': consecutive[0]['team'],
                    'minutes': [e['minute'] for e in consecutive],
                    'total_threat': sum(e['threat_score'] for e in consecutive)
                })
        # 模式2: 比赛末段界外球比例
        late_events = [e for e in self.events if e['minute'] > 75]
        if late_events and len(late_events) > len(self.events) * 0.3:
            patterns.append({
                'type': '比赛末段界外球比例过高',
                'late_events_count': len(late_events),
                'percentage': len(late_events) / len(self.events) * 100
            })
        # 模式3: 同一区域多次掷球
        from collections import Counter
        positions = Counter((round(e['throw_in_position'][0], 1), 
                           round(e['throw_in_position'][1], 1)) 
                          for e in self.events)
        hot_zones = {pos: count for pos, count in positions.items() if count >= 3}
        if hot_zones:
            patterns.append({
                'type': '热点区域',
                'hot_zones': hot_zones
            })
        return patterns
    def generate_report(self):
        """生成完整分析报告"""
        report = {
            '总界外球次数': len(self.events),
            '各队威胁统计': {},
            '总体威胁分布': {},
            '最危险球员': None,
            '危险模式': self.identify_dangerous_patterns()
        }
        # 球队统计
        for team in set(e['team'] for e in self.events):
            report['各队威胁统计'][team] = self.get_team_threat_summary(team)
        # 威胁分数分布
        threat_scores = [e['threat_score'] for e in self.events]
        report['总体威胁分布'] = {
            '平均威胁': np.mean(threat_scores),
            '最高威胁': max(threat_scores),
            '最低威胁': min(threat_scores),
            '高威胁次数': len([s for s in threat_scores if s >= 7]),
            '中等威胁次数': len([s for s in threat_scores if 4 <= s < 7]),
            '低威胁次数': len([s for s in threat_scores if s < 4])
        }
        # 最危险球员
        ranking = self.get_player_ranking()
        if ranking:
            report['最危险球员'] = ranking[0][0]
        return report
# 使用示例
def main():
    # 初始化分析器
    analyzer = ThrowInThreatAnalyzer()
    # 模拟一场比赛数据
    sample_events = [
        # (球队, 球员, 掷球位置, 接球位置, 长掷, 掷入禁区, 结果, 分钟)
        ("曼联", "卢克·肖", (38, 35), (50, 30), False, False, "成功接球", 5),
        ("曼联", "卢克·肖", (25, 32), (42, 38), False, True, "争抢", 12),
        ("利物浦", "罗伯逊", (30, 40), (48, 35), True, True, "直接射门", 15),
        ("曼联", "马拉西亚", (35, 36), (52, 32), True, False, "成功接球", 20),
        ("利物浦", "罗伯逊", (20, 38), (35, 42), True, True, "争抢", 25),
        ("曼联", "卢克·肖", (32, 33), (46, 28), False, True, "解围", 32),
        ("利物浦", "阿诺德", (15, 35), (28, 40), False, False, "成功接球", 45),
        ("曼联", "马拉西亚", (28, 30), (44, 36), True, True, "直接射门", 60),
        ("利物浦", "罗伯逊", (36, 42), (50, 38), False, False, "成功接球", 68),
        ("利物浦", "罗伯逊", (31, 35), (45, 33), True, True, "争抢", 72),
        ("曼联", "卢克·肖", (26, 34), (40, 30), False, True, "直接射门", 78),
        ("利物浦", "阿诺德", (40, 37), (52, 32), False, False, "出界", 82),
        ("曼联", "马拉西亚", (24, 31), (38, 35), True, True, "争抢", 85),
        ("利物浦", "罗伯逊", (18, 33), (32, 38), True, True, "直接射门", 88),
        ("曼联", "卢克·肖", (30, 36), (43, 34), False, True, "成功接球", 90)
    ]
    for event_data in sample_events:
        analyzer.add_throw_in_event(
            team_name=event_data[0],
            player_name=event_data[1],
            throw_in_position=event_data[2],
            receiver_position=event_data[3],
            is_long_throw=event_data[4],
            is_direct_into_box=event_data[5],
            outcome=event_data[6],
            minute=event_data[7]
        )
    # 生成分析报告
    report = analyzer.generate_report()
    print("=" * 60)
    print("界外球进攻威胁分析报告")
    print("=" * 60)
    print(f"\n1. 总览")
    print(f"   - 总界外球次数: {report['总界外球次数']}")
    print(f"   - 平均威胁分数: {report['总体威胁分布']['平均威胁']:.2f}")
    print(f"   - 最高威胁: {report['总体威胁分布']['最高威胁']}")
    print(f"\n2. 各队威胁统计")
    for team, stats in report['各队威胁统计'].items():
        print(f"   {team}:")
        print(f"     - 界外球次数: {stats['total_throw_ins']}")
        print(f"     - 平均威胁: {stats['average_threat_score']:.2f}")
        print(f"     - 高威胁次数 ({stats['high_threat_count']}次)")
        print(f"     - 长掷球次数: {stats['long_throw_count']}")
        print(f"     - 掷入禁区次数: {stats['into_box_count']}")
        if stats['dangerous_zone_minutes']:
            print(f"     - 危险时段: {stats['dangerous_zone_minutes']}")
    print(f"\n3. 最危险球员: {report['最危险球员']}")
    print(f"\n4. 球员威胁排名")
    ranking = analyzer.get_player_ranking()
    for i, (player, stats) in enumerate(ranking[:5], 1):
        print(f"   {i}. {player}: 平均威胁 {stats['average_threat_score']:.2f}, "
              f"高威胁次数 {stats['high_threat_throws']}")
    print(f"\n5. 危险模式识别")
    for pattern in report['危险模式']:
        print(f"   - {pattern['type']}: {pattern}")
    print(f"\n6. 威胁时间段分布")
    trend = analyzer.get_threat_trend_by_minute()
    for period, stats in trend.items():
        print(f"   {period}: {stats['count']}次, 平均威胁 {stats['average_threat']:.2f}")
    # 输出JSON格式总结
    print("\n" + "=" * 60)
    print("关键指标摘要")
    summary = {
        '总进攻威胁': sum(e['threat_score'] for e in analyzer.events),
        '球队威胁对比': {
            team: stats['average_threat_score'] 
            for team, stats in report['各队威胁统计'].items()
        },
        '进攻效率': report['总体威胁分布']['高威胁次数'] / report['总界外球次数']
    }
    print(json.dumps(summary, indent=2, ensure_ascii=False))
if __name__ == "__main__":
    main()

可视化分析（可选）

import matplotlib.pyplot as plt
import seaborn as sns
def visualize_threat_analysis(analyzer):
    """可视化威胁分析结果"""
    # 1. 威胁分数时间线
    plt.figure(figsize=(12, 6))
    minutes = [e['minute'] for e in analyzer.events]
    scores = [e['threat_score'] for e in analyzer.events]
    plt.subplot(2, 2, 1)
    plt.plot(minutes, scores, 'o-')
    plt.xlabel('比赛分钟')
    plt.ylabel('威胁分数')
    plt.title('界外球威胁时间线')
    plt.grid(True, alpha=0.3)
    # 2. 球队对比
    teams = set(e['team'] for e in analyzer.events)
    team_scores = {team: [] for team in teams}
    for event in analyzer.events:
        team_scores[event['team']].append(event['threat_score'])
    plt.subplot(2, 2, 2)
    data = [team_scores[team] for team in teams]
    plt.boxplot(data, labels=list(teams))
    plt.ylabel('威胁分数')
    plt.title('球队威胁分数分布')
    # 3. 时间段热力图
    trend = analyzer.get_threat_trend_by_minute(10)
    periods = list(trend.keys())
    avg_threats = [trend[p]['average_threat'] for p in periods]
    plt.subplot(2, 2, 3)
    plt.bar(periods, avg_threats, color='skyblue')
    plt.xlabel('时间段')
    plt.ylabel('平均威胁')
    plt.title('不同时间段平均威胁')
    plt.xticks(rotation=45)
    # 4. 位置热力图
    plt.subplot(2, 2, 4)
    positions = [(e['throw_in_position'][0], e['throw_in_position'][1]) 
                 for e in analyzer.events]
    x = [p[0] for p in positions]
    y = [p[1] for p in positions]
    scores = [e['threat_score'] for e in analyzer.events]
    scatter = plt.scatter(x, y, c=scores, cmap='RdYlGn', s=100, alpha=0.6)
    plt.colorbar(scatter, label='威胁分数')
    plt.xlabel('场地横向位置')
    plt.ylabel('场地纵向位置')
    plt.title('掷球位置与威胁关系')
    plt.tight_layout()
    plt.show()
# 使用可视化
# visualize_threat_analysis(analyzer)

这个系统包含以下核心功能：