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

wen python案例 2026-08-14 181

本文目录导读：

基础版本：跟踪球权转移
进阶版本：更多功能
可视化版本

我来给你设计一个统计撞墙式配合次数的Python案例,撞墙式配合通常是指球员A传球给球员B，球员B立即回传(一脚传球)给球员A，然后再传给其他人。

基础版本：跟踪球权转移

class WallPassCounter:
    """统计撞墙式配合（二过一）次数"""
    def __init__(self):
        self.events = []  # 所有传球事件
        self.wall_passes = []  # 撞墙式配合记录
        self.current_ball_holder = None  # 当前持球队员
    def record_pass(self, passer, receiver, time):
        """
        记录一次传球
        :param passer: 传球队员
        :param receiver: 接球队员
        :param time: 传球时间
        """
        event = {
            'passer': passer,
            'receiver': receiver,
            'time': time,
            'is_wall_pass': False
        }
        # 检查是否是撞墙式配合
        if self.events and len(self.events) >= 1:
            last_event = self.events[-1]
            # 条件：上次接球者现在是传球者，上次传球者现在是接球者
            if (last_event['receiver'] == passer and 
                last_event['passer'] == receiver):
                # 标记这次传球为撞墙式配合
                event['is_wall_pass'] = True
                self.wall_passes.append({
                    'first_pass': last_event,
                    'second_pass': event,
                    'players': (passer, receiver)
                })
        self.events.append(event)
        self.current_ball_holder = receiver
    def get_total_wall_passes(self):
        """获取撞墙式配合总数"""
        return len(self.wall_passes)
    def get_wall_pass_details(self):
        """获取所有撞墙式配合详情"""
        return self.wall_passes
    def print_summary(self):
        """打印统计摘要"""
        print(f"撞墙式配合次数: {len(self.wall_passes)}")
        for i, wp in enumerate(self.wall_passes, 1):
            print(f"第{i}次: 队员{wp['players'][0]} → 队员{wp['players'][1]} → "
                  f"队员{wp['players'][0]}")
# 使用示例
def simulate_match():
    """模拟一场比赛的传球序列"""
    counter = WallPassCounter()
    # 模拟传球序列: (传球者, 接球者, 时间)
    passes = [
        ('A', 'B', 1.0),
        ('B', 'C', 1.5),  # A-B-C 不是撞墙式
        ('C', 'D', 2.0),
        ('D', 'E', 2.5),
        ('E', 'D', 3.0),  # D-E-D 是撞墙式配合
        ('D', 'F', 3.5),
        ('F', 'A', 4.0),
        ('A', 'C', 4.5),
        ('C', 'A', 5.0),  # A-C-A 是撞墙式配合
        ('A', 'B', 5.5),
        ('B', 'X', 6.0),
    ]
    # 记录所有传球
    for passer, receiver, time in passes:
        counter.record_pass(passer, receiver, time)
    return counter
# 运行模拟
if __name__ == "__main__":
    counter = simulate_match()
    counter.print_summary()
    print("\n详细记录:")
    for i, wp in enumerate(counter.get_wall_pass_details(), 1):
        print(f"配合{i}: 队员{wp['first_pass']['passer']}→{wp['first_pass']['receiver']}"
              f" 在第{wp['first_pass']['time']}秒")
        print(f"       回传 队员{wp['second_pass']['passer']}→{wp['second_pass']['receiver']}"
              f" 在第{wp['second_pass']['time']}秒")

进阶版本：更多功能

import json
from datetime import datetime
from collections import defaultdict
class AdvancedWallPassCounter(WallPassCounter):
    """增强版撞墙式配合统计器"""
    def __init__(self):
        super().__init__()
        self.pair_stats = defaultdict(int)  # 统计特定组合的配合次数
    def record_pass(self, passer, receiver, time):
        """重写：增加额外统计"""
        super().record_pass(passer, receiver, time)
        # 检查最后一对事件是否形成撞墙式
        if len(self.events) >= 2:
            if self.events[-1]['is_wall_pass']:
                pair_key = tuple(sorted([passer, receiver]))
                self.pair_stats[pair_key] += 1
    def get_pair_statistics(self):
        """获取双人组合的撞墙式配合统计"""
        result = {}
        for (player1, player2), count in self.pair_stats.items():
            result[f"{player1}-{player2}"] = count
        return result
    def analyze_wall_pass_quality(self):
        """分析撞墙式配合的质量"""
        if not self.wall_passes:
            return "没有撞墙式配合"
        analysis = {
            'total': len(self.wall_passes),
            'unique_pairs': len(self.pair_stats),
            'best_pair': max(self.pair_stats.items(), 
                            key=lambda x: x[1]) if self.pair_stats else None,
            'average_interval': self._calculate_avg_interval()
        }
        return analysis
    def _calculate_avg_interval(self):
        """计算撞墙式配合的平均时间间隔"""
        intervals = []
        for i in range(1, len(self.wall_passes)):
            time1 = self.wall_passes[i-1]['second_pass']['time']
            time2 = self.wall_passes[i]['first_pass']['time']
            intervals.append(time2 - time1)
        return sum(intervals)/len(intervals) if intervals else 0
# 更复杂的使用场景
def analyze_team_match():
    """分析团队比赛数据"""
    # 从文件读取真实比赛数据（模拟）
    match_data = [
        {"passer": "10号", "receiver": "7号", "time": 23.5},
        {"passer": "7号", "receiver": "10号", "time": 23.8},
        {"passer": "10号", "receiver": "9号", "time": 24.2},
        {"passer": "9号", "receiver": "11号", "time": 25.0},
        {"passer": "11号", "receiver": "8号", "time": 25.3},
        {"passer": "8号", "receiver": "11号", "time": 25.6},
        {"passer": "11号", "receiver": "9号", "time": 25.9},
        {"passer": "5号", "receiver": "7号", "time": 30.1},
        {"passer": "7号", "receiver": "5号", "time": 30.4},
        {"passer": "5号", "receiver": "10号", "time": 30.7},
        {"passer": "10号", "receiver": "7号", "time": 31.0},
        {"passer": "7号", "receiver": "10号", "time": 31.3},
    ]
    counter = AdvancedWallPassCounter()
    # 记录所有传球
    for event in match_data:
        counter.record_pass(
            event['passer'], 
            event['receiver'], 
            event['time']
        )
    # 输出详细分析
    print("=== 撞墙式配合分析报告 ===")
    counter.print_summary()
    print("\n=== 最佳组合 ===")
    pair_stats = counter.get_pair_statistics()
    for pair, count in sorted(pair_stats.items(), key=lambda x: x[1], reverse=True):
        print(f"{pair}: {count}次")
    print("\n=== 质量分析 ===")
    quality = counter.analyze_wall_pass_quality()
    for key, value in quality.items():
        print(f"{key}: {value}")
# 运行高级分析
if __name__ == "__main__":
    analyze_team_match()

可视化版本

import matplotlib.pyplot as plt
def visualize_wall_passes(counter):
    """可视化撞墙式配合"""
    if not counter.wall_passes:
        print("没有数据可展示")
        return
    # 准备数据
    pass_times = []
    pass_pairs = []
    for wp in counter.wall_passes:
        first_time = wp['first_pass']['time']
        second_time = wp['second_pass']['time']
        pass_times.append((first_time, second_time))
        pairs = f"{wp['first_pass']['passer']}→{wp['first_pass']['receiver']}→" \
                f"{wp['second_pass']['passer']}"
        pass_pairs.append(pairs)
    # 创建图表
    fig, ax = plt.subplots(figsize=(10, 6))
    y_pos = range(len(pass_pairs))
    # 绘制水平和垂直线段表示撞墙式
    for i, (start, end) in enumerate(pass_times):
        ax.plot([start, end], [i, i], 'bo-', linewidth=2, markersize=8)
        ax.text((start+end)/2, i, f'({start:.1f}-{end:.1f}s)', 
                ha='center', va='bottom')
    ax.set_yticks(y_pos)
    ax.set_yticklabels(pass_pairs)
    ax.set_xlabel('时间 (秒)')
    ax.set_title('撞墙式配合时间分布图')
    plt.tight_layout()
    plt.show()
# 使用可视化
if __name__ == "__main__":
    counter = simulate_match()
    visualize_wall_passes(counter)

这些代码提供了：