python案例统计撞墙式配合完成了几次？

本文目录导读：

1. 足球比赛撞墙式配合统计器
2. 增强版本（支持输入自定义比赛数据）
3. 使用示例
4. 核心功能说明

我来为你创建一个统计"撞墙式配合"（One-Two配合）次数的Python案例。

足球比赛撞墙式配合统计器

import re
from collections import defaultdict
class OneTwoCounter:
    """统计足球比赛中的撞墙式配合（One-Two）次数"""
    def __init__(self):
        # 记录球员之间的配合关系
        self.player_pairs = defaultdict(int)
        # 记录当前连续的传球序列
        self.current_sequence = []
        # 记录所有配合
        self.all_sequences = []
    def parse_event(self, event_text):
        """
        解析比赛事件文本
        输入格式: "时间 事件类型 球员A -> 球员B"
        事件类型: PASS(传球), SHOT(射门), GOAL(进球)
        """
        # 解析文本格式
        # 例: "23:45 PASS 梅西 -> 阿尔巴"
        pattern = r'(\d+:\d+)\s+(\w+)\s+([^->\s]+)\s*->\s*(\w+)'
        match = re.match(pattern, event_text)
        if match:
            time, event_type, player1, player2 = match.groups()
            return {
                'time': time,
                'event_type': event_type,
                'player1': player1,
                'player2': player2
            }
        return None
    def check_one_two(self, sequence):
        """
        检查是否是撞墙式配合
        撞墙式配合定义：A传给B，B立即回传A，并且至少有3次连续传球
        """
        if len(sequence) < 3:
            return False
        # 检查连续的传球是否符合 A->B->A->B 模式
        for i in range(len(sequence) - 2):
            # 检查是否有回传
            if (sequence[i][0] == sequence[i+2][0] and  # 第三个球员 = 第一个球员
                sequence[i][1] == sequence[i+1][0]):    # 第二个球员接第一个球员的球
                return True
        return False
    def analyze_sequence(self, events):
        """
        分析整个比赛的事件序列
        events: 比赛事件列表，按时间排序
        """
        for event in events:
            if event['event_type'] == 'PASS':
                # 记录传球关系
                relationship = (event['player1'], event['player2'])
                self.player_pairs[relationship] += 1
                self.current_sequence.append((event['player1'], event['player2']))
            else:
                # 遇到射门或进球，检查当前序列
                if self.check_one_two(self.current_sequence):
                    self.all_sequences.append(self.current_sequence.copy())
                self.current_sequence = []
        # 检查最后一个序列
        if self.check_one_two(self.current_sequence):
            self.all_sequences.append(self.current_sequence.copy())
        return len(self.all_sequences)
    def get_detail_report(self):
        """生成详细统计报告"""
        report = {
            'total_one_two': len(self.all_sequences),
            'sequences': [],
            'player_pairs': dict(self.player_pairs)
        }
        for seq in self.all_sequences:
            report['sequences'].append({
                'players': [f"{p1}->{p2}" for p1, p2 in seq],
                'duration': len(seq)
            })
        return report
# 示例数据生成器
def generate_match_data():
    """生成示例比赛数据"""
    events = []
    # 模拟一次梅西-阿尔巴的撞墙式配合
    events.extend([
        "10:00 PASS 梅西 -> 阿尔巴",
        "10:05 PASS 阿尔巴 -> 梅西",
        "10:08 PASS 梅西 -> 阿尔巴",
        "10:10 SHOT 阿尔巴 -> 球门"
    ])
    # 模拟一次布斯克茨-德容的撞墙式配合
    events.extend([
        "25:00 PASS 布斯克茨 -> 德容",
        "25:04 PASS 德容 -> 布斯克茨",
        "25:07 PASS 布斯克茨 -> 德容",
        "25:12 GOAL 德容 -> 球门"
    ])
    # 普通传球（不构成撞墙式配合）
    events.extend([
        "40:00 PASS 门将 -> 后卫",
        "40:10 PASS 后卫 -> 中场",
        "40:20 PASS 中场 -> 前锋",
        "40:30 SHOT 前锋 -> 球门"
    ])
    # 又一次撞墙式配合
    events.extend([
        "60:00 PASS 佩德里 -> 加维",
        "60:03 PASS 加维 -> 佩德里",
        "60:06 PASS 佩德里 -> 加维",
        "60:09 PASS 加维 -> 佩德里",
        "60:15 GOAL 佩德里 -> 球门"
    ])
    return events
def main():
    """主函数"""
    print("="*60)
    print("足球比赛撞墙式配合统计系统")
    print("="*60)
    # 创建计数器实例
    counter = OneTwoCounter()
    # 生成比赛数据
    match_events = generate_match_data()
    # 解析所有事件
    parsed_events = []
    for event_text in match_events:
        parsed_event = counter.parse_event(event_text)
        if parsed_event:
            parsed_events.append(parsed_event)
    # 分析配合
    total = counter.analyze_sequence(parsed_events)
    # 输出结果
    print(f"\n比赛事件总数: {len(parsed_events)}")
    print(f"发现撞墙式配合次数: {total}")
    # 详细报告
    report = counter.get_detail_report()
    print("\n" + "="*60)
    print("撞墙式配合详细记录:")
    print("="*60)
    for i, seq in enumerate(report['sequences'], 1):
        print(f"\n配合{i}:")
        print(f"  传球路线: {' → '.join(seq['players'])}")
        print(f"  传球次数: {seq['duration']}")
    # 球员配合统计
    print("\n" + "="*60)
    print("球员传球组合统计:")
    print("="*60)
    for pair, count in sorted(report['player_pairs'].items(), 
                             key=lambda x: x[1], reverse=True):
        print(f"  {pair[0]} → {pair[1]}: {count}次")
    # 分析结果
    print("\n" + "="*60)
    print("统计分析结论:")
    print("="*60)
    if total == 0:
        print("本场比赛没有出现撞墙式配合")
    elif total <= 2:
        print(f"本场比赛出现了 {total} 次撞墙式配合，属于中规中矩的表现")
    else:
        print(f"本场比赛出现了 {total} 次撞墙式配合，显示了出色的团队配合能力")
    return total
if __name__ == "__main__":
    result = main()

增强版本（支持输入自定义比赛数据）

class AdvancedOneTwoCounter(OneTwoCounter):
    """增强版撞墙式配合计数器"""
    def analyze_live_events(self, events_list):
        """
        实时分析比赛事件
        events_list: 列表，每个元素格式为:
        ("PASS", "梅西", "阿尔巴") 或 ("SHOT", "梅西", "球门")
        """
        for event in events_list:
            event_type = event[0]
            if event_type == "PASS":
                player1, player2 = event[1], event[2]
                self.current_sequence.append((player1, player2))
            else:
                if self.check_one_two(self.current_sequence):
                    self.all_sequences.append(self.current_sequence.copy())
                self.current_sequence = []
        # 检查最后一个序列
        if self.check_one_two(self.current_sequence):
            self.all_sequences.append(self.current_sequence.copy())
        return len(self.all_sequences)
    def visualize_sequences(self):
        """可视化显示配合路线"""
        import matplotlib.pyplot as plt
        # 创建简单的可视化
        for idx, seq in enumerate(self.all_sequences[:5]):  # 只显示前5个
            plt.figure(figsize=(8, 4))
            players = []
            for p1, p2 in seq:
                if p1 not in players:
                    players.append(p1)
                if p2 not in players:
                    players.append(p2)
            # 绘制传球路线
            x_positions = list(range(len(players)))
            for i, (p1, p2) in enumerate(seq):
                try:
                    x1 = x_positions[players.index(p1)]
                    x2 = x_positions[players.index(p2)]
                    plt.annotate('', xy=(x2, 1), xytext=(x1, 1),
                                arrowprops=dict(arrowstyle='->', lw=2))
                except ValueError:
                    continue
            plt.yticks([])
            plt.xticks(x_positions, players, rotation=45)
            plt.title(f'配合{idx+1} 传球路线')
            plt.tight_layout()
            plt.show()

使用示例

# 使用示例
if __name__ == "__main__":
    # 方法1：使用示例数据
    print("=== 示例数据分析 ===")
    main()
    # 方法2：使用增强版实时分析
    print("\n=== 增强版实时分析 ===")
    adv_counter = AdvancedOneTwoCounter()
    # 实时比赛事件
    live_events = [
        ("PASS", "罗德里", "福登"),
        ("PASS", "福登", "罗德里"),
        ("PASS", "罗德里", "福登"),
        ("SHOT", "福登", "球门"),  # 射击结束序列
        ("PASS", "后卫", "门将"),
        ("PASS", "门将", "后卫"),
        ("SHOT", "后卫", "球门")
    ]
    result = adv_counter.analyze_live_events(live_events)
    print(f"实时分析结果: 检测到 {result} 次撞墙式配合")
    # 可视化
    adv_counter.visualize_sequences()

核心功能说明

1. 撞墙式配合识别：通过分析连续传球序列，识别A→B→A的回传模式
2. 多维度统计：累计次数、持续时间、参与球员等多维度分析
3. 实时分析：支持实时处理比赛事件流
4. 可视化呈现：可视化的传球路线图（需要matplotlib）
5. 详细报告：生成包含所有配合细节的统计报告

这个系统能够准确统计出示例数据中出现了3次撞墙式配合,并提供了详细的分析报告。