本文目录导读：
我来为你设计一个统计假动作晃过防守次数的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分钟的比赛
核心功能说明
-
基础统计（方案一）：
- 记录假动作次数和成功晃过数量
- 计算成功率
- 分析防守球员反应
-
数据分析（方案二）：
- 使用pandas进行数据分析
- 生成统计报告
- 可视化展示结果
-
实时模拟（方案三）：
- 动态显示球场状态
- 实时更新统计数据
- 模拟完整比赛过程
你可以选择适合你需求的方案,或者组合使用，如果需要特定功能或修改，请告诉我！
