python案例统计假动作晃过防守几次？

wen python案例 2026-08-14 162

本文目录导读：

基础版本：简单统计
进阶版本：包含球员和比赛信息
可视化版本：实时追踪
实战模拟版本
使用说明

我来创建一个Python案例,统计足球比赛中球员使用假动作晃过防守球员的次数。

基础版本：简单统计

class FakeMoveTracker:
    def __init__(self):
        # 初始化统计字典
        self.fake_moves = {
            'body_feint': 0,      # 身体虚晃
            'step_over': 0,       # 踩单车
            'cryuff_turn': 0,     # 克鲁伊夫转身
            'roulette': 0,        # 马赛回旋
            'rainbow': 0,         # 彩虹过人
            'elastico': 0,        # 弹球过人
        }
        self.total_success = 0    # 总成功次数
        self.total_attempts = 0   # 总尝试次数
    def record_attempt(self, move_type, success=True):
        """
        记录一次假动作尝试
        Args:
            move_type: 假动作类型
            success: 是否成功晃过防守
        """
        self.total_attempts += 1
        if success:
            self.fake_moves[move_type] += 1
            self.total_success += 1
        print(f"记录到{move_type}: {'成功' if success else '失败'}")
    def get_statistics(self):
        """返回统计结果"""
        stats = {
            '总尝试次数': self.total_attempts,
            '成功晃过次数': self.total_success,
            '成功率': f"{(self.total_success / self.total_attempts * 100):.1f}%" if self.total_attempts > 0 else "0%",
            '各动作详情': self.fake_moves
        }
        return stats
# 使用示例
tracker = FakeMoveTracker()
tracker.record_attempt('body_feint', True)
tracker.record_attempt('step_over', True)
tracker.record_attempt('cryuff_turn', False)
tracker.record_attempt('roulette', True)
tracker.record_attempt('elastico', True)
print("\n=== 统计数据 ===")
stats = tracker.get_statistics()
for key, value in stats.items():
    print(f"{key}: {value}")

进阶版本：包含球员和比赛信息

from datetime import datetime
import json
class AdvancedFakeMoveTracker:
    def __init__(self, player_name, match_date=None):
        self.player_name = player_name
        self.match_date = match_date or datetime.now().strftime("%Y-%m-%d")
        self.events = []  # 存储所有事件
        self.skill_types = {
            '左右变向': 0,
            '背后扣球': 0,
            '踩单车': 0,
            '假射真扣': 0,
            '人球分过': 0,
            '转身过人': 0
        }
    def add_event(self, skill_type, opponent_name, position, success=True):
        """
        添加假动作事件
        Args:
            skill_type: 技能类型
            opponent_name: 被晃过的防守球员名字
            position: 位置（如中场/禁区等）
            success: 是否成功
        """
        event = {
            'timestamp': datetime.now().strftime("%H:%M:%S"),
            'skill': skill_type,
            'against': opponent_name,
            'position': position,
            'success': success
        }
        self.events.append(event)
        if success:
            self.skill_types[skill_type] += 1
        return event
    def generate_report(self):
        """生成详细报告"""
        report = {
            '球员': self.player_name,
            '比赛日期': self.match_date,
            '总尝试': len(self.events),
            '成功次数': sum(1 for e in self.events if e['success']),
            '失败次数': sum(1 for e in self.events if not e['success']),
            '成功率': f"{(sum(1 for e in self.events if e['success']) / len(self.events) * 100):.1f}%" if self.events else "0%",
            '技能统计': self.skill_types,
            '被晃过的球员': self.get_victims_list()
        }
        return report
    def get_victims_list(self):
        """获取被晃过的球员列表"""
        victims = {}
        for event in self.events:
            if event['success']:
                name = event['against']
                if name in victims:
                    victims[name] += 1
                else:
                    victims[name] = 1
        return victims
    def save_to_file(self, filename=None):
        """保存数据到文件"""
        if not filename:
            filename = f"{self.player_name}_statistics.json"
        report = self.generate_report()
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"数据已保存到 {filename}")
# 使用示例
tracker = AdvancedFakeMoveTracker("C罗", "2024-01-15")
# 添加事件
tracker.add_event('踩单车', '后卫1', '中场', True)
tracker.add_event('左右变向', '后卫2', '禁区', True)
tracker.add_event('假射真扣', '中卫', '边路', True)
tracker.add_event('踩单车', '后卫1', '中场', False)  # 这次失败了
tracker.add_event('转身过人', '门将', '禁区', True)
# 生成报告
report = tracker.generate_report()
print("\n=== 高级统计报告 ===")
for key, value in report.items():
    print(f"{key}: {value}")
# 保存到文件
tracker.save_to_file()

可视化版本：实时追踪

import matplotlib.pyplot as plt
import numpy as np
class VisualFakeMoveTracker:
    def __init__(self):
        self.minutes = []  # 记录比赛时间（分钟）
        self.success_moves = []  # 存储成功假动作
        self.failed_moves = []   # 存储失败假动作
        self.best_moves = []     # 精彩动作
    def record_move(self, minute, skill_type, success=True, is_highlight=False):
        """记录假动作"""
        self.minutes.append(minute)
        move = (minute, skill_type)
        if success:
            self.success_moves.append(move)
        else:
            self.failed_moves.append(move)
        if is_highlight and success:
            self.best_moves.append(move)
    def visualize_statistics(self):
        """可视化统计数据"""
        fig, axes = plt.subplots(2, 2, figsize=(12, 10))
        # 1. 时间线分布
        ax1 = axes[0, 0]
        minutes = list(range(1, 91))
        success_counts = [sum(1 for m in self.success_moves if m[0] == min) for min in minutes]
        failed_counts = [sum(1 for m in self.failed_moves if m[0] == min) for min in minutes]
        ax1.bar(minutes, success_counts, label='成功', alpha=0.7)
        ax1.bar(minutes, failed_counts, label='失败', alpha=0.7, bottom=success_counts)
        ax1.set_title('比赛时间线分布')
        ax1.set_xlabel('比赛分钟')
        ax1.set_ylabel('次数')
        ax1.legend()
        # 2. 技能类型统计
        ax2 = axes[0, 1]
        skill_names = []
        success_count = []
        failed_count = []
        all_skills = list(set([m[1] for m in self.success_moves + self.failed_moves]))
        for skill in all_skills:
            skill_names.append(skill)
            success_count.append(sum(1 for m in self.success_moves if m[1] == skill))
            failed_count.append(sum(1 for m in self.failed_moves if m[1] == skill))
        x_pos = np.arange(len(skill_names))
        width = 0.35
        ax2.bar(x_pos - width/2, success_count, width, label='成功', alpha=0.7)
        ax2.bar(x_pos + width/2, failed_count, width, label='失败', alpha=0.7)
        ax2.set_title('技能类型统计')
        ax2.set_xticks(x_pos)
        ax2.set_xticklabels(skill_names)
        ax2.legend()
        # 3. 成功率饼图
        ax3 = axes[1, 0]
        total_success = len(self.success_moves)
        total_failed = len(self.failed_moves)
        ax3.pie([total_success, total_failed], labels=['成功', '失败'], 
                autopct='%1.1f%%', colors=['lightgreen', 'lightcoral'])
        ax3.set_title('成功率分布')
        # 4. 精彩动作
        ax4 = axes[1, 1]
        if self.best_moves:
            best_skills = [m[1] for m in self.best_moves]
            skill_set = list(set(best_skills))
            counts = [best_skills.count(s) for s in skill_set]
            ax4.bar(skill_set, counts, color='gold')
            ax4.set_title('精彩动作统计')
            ax4.set_xlabel('技巧类型')
            ax4.set_ylabel('次数')
        else:
            ax4.text(0.5, 0.5, '暂无精彩动作', ha='center')
            ax4.set_title('精彩动作统计')
        plt.tight_layout()
        plt.show()
# 使用示例
visual_tracker = VisualFakeMoveTracker()
# 模拟比赛数据
skills = ['踩单车', '变向', '转身', '人球分过']
for minute in range(1, 91, 5):  # 每5分钟记录一次
    if np.random.random() > 0.6:  # 40%概率有动作
        is_success = np.random.random() > 0.3  # 70%成功率
        skill = np.random.choice(skills)
        visual_tracker.record_move(minute, skill, is_success, 
                                 is_highlight=success := np.random.random() > 0.8)
# 显示统计
visual_tracker.visualize_statistics()

实战模拟版本

import random
from collections import defaultdict
class MatchSimulator:
    def __init__(self, player_name):
        self.player_name = player_name
        self.stats = defaultdict(lambda: {'attempts': 0, 'success': 0})
        self.total_attacks = 0
        self.total_defenders_fooled = 0
    def simulate_match(self, minutes=90):
        """
        模拟一场比赛
        """
        match_log = []
        for minute in range(1, minutes + 1):
            # 每1-3分钟可能有一次进攻机会
            if random.random() < 0.2:  # 20%概率有进攻
                self.total_attacks += 1
                attack = self.simulate_attack(minute)
                match_log.append(attack)
        return match_log
    def simulate_attack(self, minute):
        """
        模拟一次进攻
        """
        # 随机选择假动作类型
        move_types = [
            '身体虚晃', '变向过人', '踩单车', 
            '假射真扣', '转身过人', '人球分过'
        ]
        move_type = random.choice(move_types)
        # 计算成功率（基础成功率70%，随机浮动）
        success_rate = 0.7 + random.uniform(-0.2, 0.2)
        success = random.random() < success_rate
        # 更新统计
        attempt_info = {
            'minute': minute,
            'move': move_type,
            'attempts': 1,
            'success': success
        }
        self.stats[move_type]['attempts'] += 1
        if success:
            self.stats[move_type]['success'] += 1
            self.total_defenders_fooled += 1
            # 可能一次进攻连续晃过多人
            extra_defenders = random.randint(0, 2)
            for i in range(extra_defenders):
                self.total_defenders_fooled += 1
        return attempt_info
    def get_detailed_statistics(self):
        """
        获取详细统计
        """
        report = {
            '球员': self.player_name,
            '总进攻次数': self.total_attacks,
            '总晃过防守次数': self.total_defenders_fooled,
            '平均每次进攻晃过': f"{(self.total_defenders_fooled / self.total_attacks):.2f}" if self.total_attacks > 0 else "0",
            '技能明细': {}
        }
        for skill, data in self.stats.items():
            success_rate = (data['success'] / data['attempts'] * 100) if data['attempts'] > 0 else 0
            report['技能明细'][skill] = {
                '尝试': data['attempts'],
                '成功': data['success'],
                '成功率': f"{success_rate:.1f}%"
            }
        # 找到最佳技能
        if self.stats:
            best_skill = max(self.stats.items(), 
                           key=lambda x: x[1]['success']/x[1]['attempts'] if x[1]['attempts'] > 0 else 0)
            report['最有威胁技能'] = best_skill[0]
        return report
# 使用示例
simulator = MatchSimulator("梅西")
match_data = simulator.simulate_match(90)
print("比赛模拟完成！")
print("\n=== 实战统计 ===")
report = simulator.get_detailed_statistics()
for key, value in report.items():
    if key != '技能明细':
        print(f"{key}: {value}")
print("\n技能明细:")
for skill, data in report['技能明细'].items():
    print(f"  {skill}: {data}")
print(f"\n结论: {report['球员']}在本场比赛中总共晃过了 {report['总晃过防守次数']} 次防守球员！")