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

wen python案例 2026-08-19 212

本文目录导读：

方案一：基于位置变化的统计
方案二：更复杂的多维度统计
方案三：实时可视化模拟
核心功能说明

我来为你设计一个统计假动作晃过防守次数的Python案例,这个案例模拟足球比赛中球员使用假动作晃过防守球员的情景。

基于位置变化的统计

import random
import time
from collections import defaultdict
class FootballGame:
    def __init__(self):
        self.player_pos = [50, 0]  # 球员位置 (x, y)
        self.defender_pos = [50, 5]  # 防守球员位置
        self.fake_moves = 0  # 使用的假动作次数
        self.successful_beat = 0  # 成功晃过的次数
        self.fail_count = 0  # 失败次数
        self.move_history = []
    def perform_fake_move(self, direction):
        """执行假动作"""
        print(f"向{direction}方向做假动作...")
        self.fake_moves += 1
        # 记录假动作前的防守距离
        distance_before = abs(self.player_pos[0] - self.defender_pos[0])
        # 模拟假动作：先向一个方向虚晃
        fake_direction = random.choice(['left', 'right'])
        if fake_direction == 'left':
            self.player_pos[0] -= 3
        else:
            self.player_pos[0] += 3
        # 防守球员反应
        defender_reaction = random.random()
        if defender_reaction < 0.6:  # 60%概率被晃过
            # 假动作成功后向另一方向突破
            if fake_direction == 'left':
                self.player_pos[0] += 6  # 向相反方向突破
            else:
                self.player_pos[0] -= 6
            distance_after = abs(self.player_pos[0] - self.defender_pos[0])
            # 判断是否成功晃过（距离拉大超过3个单位）
            if distance_after - distance_before > 3:
                self.successful_beat += 1
                self.move_history.append(('success', fake_direction, distance_before, distance_after))
                print(f"✓ 成功晃过防守！距离从{distance_before:.1f}扩大到{abs(self.player_pos[0]-self.defender_pos[0]):.1f}")
                return True
            else:
                self.fail_count += 1
                self.move_history.append(('fail', fake_direction, distance_before, distance_after))
                print(f"✗ 没有完全晃开防守")
                return False
        else:
            self.fail_count += 1
            self.move_history.append(('fail', fake_direction, 0, 0))
            print(f"✗ 假动作被识破！")
            return False
    def simulate_play(self, max_actions=10):
        """模拟进攻过程"""
        print("\n=== 比赛开始 ===")
        for i in range(max_actions):
            print(f"\n第{i+1}次进攻尝试:")
            # 随机选择行动：假动作或传球
            action = random.choice(['fake', 'fake', 'fake', 'pass'])
            if action == 'fake':
                direction = random.choice(['左', '右'])
                self.perform_fake_move(direction)
                # 如果成功晃过2次就算进球
                if self.successful_beat >= 2:
                    print("\n🎉 成功突破防线，射门得分！")
                    break
            else:
                print("选择传球，调整进攻节奏")
            # 更新防守球员位置（重新调整防守）
            if len(self.move_history) > 0:
                self.defender_pos[0] += random.uniform(-2, 2)
                self.defender_pos[0] = max(0, min(100, self.defender_pos[0]))
        return self.get_statistics()
    def get_statistics(self):
        """获取统计数据"""
        return {
            '总假动作次数': self.fake_moves,
            '成功晃过次数': self.successful_beat,
            '失败次数': self.fail_count,
            '成功率': f"{self.successful_beat/self.fake_moves*100:.1f}%" if self.fake_moves > 0 else "0%"
        }
# 运行模拟
game = FootballGame()
stats = game.simulate_play(max_actions=10)
print("\n=== 比赛统计 ===")
for key, value in stats.items():
    print(f"{key}: {value}")

更复杂的多维度统计

import numpy as np
import pandas as pd
from enum import Enum
from datetime import datetime
class MoveType(Enum):
    FAKE_LEFT = "假动作-向左"
    FAKE_RIGHT = "假动作-向右"
    CUT_INSIDE = "内切"
    STEP_OVER = "踩单车"
class GameAnalyzer:
    def __init__(self):
        self.moves_record = []
        self.current_position = (50, 0)
    def record_move(self, move_type, defenders_beaten, speed=0, prediction_error=0):
        """记录每次假动作数据"""
        move_data = {
            'timestamp': datetime.now(),
            'move_type': move_type.value,
            'defenders_beaten': defenders_beaten,
            'success': defenders_beaten > 0,
            'player_speed': speed,
            'defender_prediction_error': prediction_error,
            'position': self.current_position
        }
        self.moves_record.append(move_data)
    def analyze_performance(self):
        """分析整个比赛表现"""
        df = pd.DataFrame(self.moves_record)
        stats = {
            '总假动作次数': len(df),
            '成功晃过次数': df['success'].sum(),
            '成功率': f"{df['success'].mean()*100:.1f}%",
            '平均晃过防守数': df['defenders_beaten'].mean(),
            '最佳表现': self._find_best_move(df),
            '战术选择': self._analyze_tactics(df)
        }
        return stats
    def _find_best_move(self, df):
        """找出最成功的假动作"""
        best_move = df.loc[df['defenders_beaten'].idxmax()]
        return {
            '类型': best_move['move_type'],
            '晃过人数': best_move['defenders_beaten'],
            '速度': best_move['player_speed']
        }
    def _analyze_tactics(self, df):
        """分析战术选择"""
        tactics = {}
        for move in MoveType:
            move_df = df[df['move_type'] == move.value]
            if len(move_df) > 0:
                tactics[move.name] = {
                    '次数': len(move_df),
                    '成功率': f"{move_df['success'].mean()*100:.1f}%",
                    '平均晃过人数': move_df['defenders_beaten'].mean()
                }
        return tactics
    def visualize_results(self):
        """可视化统计结果"""
        df = pd.DataFrame(self.moves_record)
        # 使用matplotlib展示
        import matplotlib.pyplot as plt
        fig, axes = plt.subplots(2, 2, figsize=(12, 8))
        # 1. 每次假动作的晃过人数
        axes[0,0].bar(range(len(df)), df['defenders_beaten'])
        axes[0,0].set_title('每次假动作晃过防守人数')
        axes[0,0].set_xlabel('尝试次数')
        axes[0,0].set_ylabel('晃过人数')
        # 2. 战术成功率
        tactics = self._analyze_tactics(df)
        move_types = [m['move_type'] for m in self.moves_record]
        success_rates = [m['defenders_beaten']/max(m['defenders_beaten'],1) for m in self.moves_record]
        axes[0,1].pie([sum(1 for m in self.moves_record if m['success']),
                       sum(1 for m in self.moves_record if not m['success'])],
                      labels=['成功', '失败'],
                      autopct='%1.1f%%')
        axes[0,1].set_title('成功率分布')
        # 3. 速度与成功率关系
        axes[1,0].scatter(df['player_speed'], df['defenders_beaten'])
        axes[1,0].set_title('球员速度与晃过人数关系')
        axes[1,0].set_xlabel('速度')
        axes[1,0].set_ylabel('晃过人数')
        # 4. 防守预测误差分析
        axes[1,1].bar(range(len(df)), df['defender_prediction_error'])
        axes[1,1].set_title('防守球员预测误差')
        axes[1,1].set_xlabel('尝试次数')
        axes[1,1].set_ylabel('预测误差')
        plt.tight_layout()
        plt.show()
# 使用示例
analyzer = GameAnalyzer()
# 模拟一场比赛
for i in range(15):
    move_type = random.choice(list(MoveType))
    defenders = random.choices([0, 1, 2, 3], weights=[0.3, 0.4, 0.2, 0.1])[0]
    speed = random.uniform(5, 12)
    prediction_error = random.uniform(0, 5) if defenders > 0 else 0
    analyzer.record_move(move_type, defenders, speed, prediction_error)
stats = analyzer.analyze_performance()
print("=== 数据分析结果 ===")
for key, value in stats.items():
    print(f"{key}: {value}")
# 如果想查看详细战术分析
print("\n=== 战术分析 ===")
for tactic, info in stats['战术选择'].items():
    print(f"\n{tactic}:")
    for k, v in info.items():
        print(f"  {k}: {v}")

实时可视化模拟

import time
import random
class RealTimeSimulation:
    def __init__(self):
        self.frame = 0
        self.player_x = 50
        self.defender_x = 40
        self.defenders_beaten = 0
        self.success_count = 0
        self.total_fake_moves = 0
    def display_visual(self):
        """显示球场可视化界面"""
        print("\n" * 2)
        print("=" * 80)
        print(f"第{self.frame}帧 | 成功晃过: {self.success_count} | 总假动作: {self.total_fake_moves}")
        print("-" * 80)
        # 绘制球场坐标
        field_width = 100
        field = ['-'] * field_width
        # 标注球员和防守球员
        player_idx = int(self.player_x)
        defender_idx = int(self.defender_x)
        field[player_idx] = '🏃'  # 进攻球员
        field[defender_idx] = '🛡️'  # 防守球员
        # 显示球场
        field_str = ' '.join(field)
        print(field_str)
        # 显示距离
        distance = abs(self.player_x - self.defender_x)
        print(f"距离: {distance:.1f} 米")
        # 统计信息
        if self.total_fake_moves > 0:
            success_rate = self.success_count / self.total_fake_moves * 100
            print(f"成功率: {success_rate:.1f}%")
        print("=" * 80)
    def simulate_fake_move(self):
        """模拟假动作"""
        self.total_fake_moves += 1
        # 假动作决策
        fake_direction = random.choice(['left', 'right'])
        move_power = random.uniform(3, 8)
        # 记录假动作
        print(f"\n➡️ 使用假动作，方向: {fake_direction}, 力度: {move_power:.1f}")
        # 假动作执行
        old_position = self.player_x
        # 假动作虚晃
        if fake_direction == 'left':
            self.player_x -= move_power * 0.3
        else:
            self.player_x += move_power * 0.3
        # 防守球员反应
        reaction_time = random.random()
        # 显示动画 - 模拟几帧
        for i in range(3):
            self.frame += 1
            self.display_visual()
            time.sleep(0.3)
            # 中间状态
            if i == 0:
                print("🔮 防守球员开始移动...")
            elif i == 1:
                if reaction_time < 0.7:
                    print("⚡ 防守球员向假动作方向移动！")
                else:
                    print("🕴️ 防守球员保持位置，没有被骗到！")
        # 假动作后的突破
        if reaction_time < 0.7:  # 70%概率被骗
            # 向相反方向突破
            if fake_direction == 'left':
                self.player_x += move_power * 2
            else:
                self.player_x -= move_power * 2
            # 检查是否晃过（距离拉大）
            new_distance = abs(self.player_x - self.defender_x)
            old_distance = abs(old_position - self.defender_x)
            if new_distance > old_distance + 2:
                self.success_count += 1
                self.defenders_beaten += 1
                print(f"\n🎉 成功晃过防守！距离扩大到{new_distance:.1f}米")
            else:
                print(f"\n⚠️ 未能完全晃开，防守球员跟上")
            # 防守球员调整位置
            self.defender_x += random.uniform(-3, 3) * (1 if self.player_x > self.defender_x else -1)
            self.defender_x = max(0, min(100, self.defender_x))
        else:
            # 被看穿
            print(f"\n❌ 假动作被识破！")
            self.defender_x += random.uniform(1, 3) * (1 if self.defender_x > self.player_x else -1)
        self.frame += 1
        self.display_visual()
    def run_match(self, minutes=90):
        """运行整场比赛"""
        print("⚽ 足球比赛模拟器 - 假动作统计系统")
        print("*" * 80)
        # 每5分钟统计一次
        for minute in range(0, minutes, 5):
            print(f"\n⏱️ 比赛第{minute}分钟")
            # 每5分钟尝试2-3次突破
            attempts = random.randint(1, 3)
            for _ in range(attempts):
                self.simulate_fake_move()
                time.sleep(0.5)
        # 
        print("\n" + "="*80)
        print("📊 比赛总结")
        print("-" * 80)
        print(f"🔄 总假动作次数: {self.total_fake_moves}")
        print(f"✅ 成功晃过次数: {self.success_count}")
        print(f"📈 成功率: {self.success_count/self.total_fake_moves*100:.1f}%")
        # 判断比赛结果
        if self.success_count >= self.total_fake_moves * 0.5:
            print("🥇 表现出色！假动作让人眼花缭乱")
        elif self.success_count >= self.total_fake_moves * 0.3:
            print("🥈 表现不错，有几次精彩突破")
        else:
            print("🥉 仍需提高假动作的质量")
# 运行模拟
if __name__ == "__main__":
    game = RealTimeSimulation()
    game.run_match(minutes=30)  # 模拟30分钟的比赛