综合python案例，轮转换位防守默契度？

我来为您设计一个综合性Python案例，模拟篮球轮转换位防守的默契度评估系统,这个系统会综合运用多项Python技术。

🏀 篮球轮转换位防守默契度分析系统

系统架构设计

# 文件结构
"""
basketball_defense_system/
├── defense_analysis.py     # 主分析系统
├── player_module.py        # 球员模块
├── simulation.py          # 模拟模块
├── visualization.py       # 可视化模块
├── data_processing.py     # 数据处理模块
└── ui_interface.py        # 界面交互模块
"""

核心代码实现

球员模块 (player_module.py)

from dataclasses import dataclass
from enum import Enum
import random
import json
from typing import List, Dict, Optional
import numpy as np
class Position(Enum):
    PG = "控球后卫"
    SG = "得分后卫"
    SF = "小前锋"
    PF = "大前锋"
    C = "中锋"
class DefensiveRole(Enum):
    PRIMARY = "主要防守"
    HELP = "协防"
    ROTATE = "轮转"
    BOX_OUT = "卡位"
@dataclass
class Player:
    """球员数据类"""
    name: str
    number: int
    position: Position
    height_cm: float
    weight_kg: float
    speed: float  # 移动速度 0-100
    agility: float  # 敏捷度 0-100
    defensive_awareness: float  # 防守意识 0-100
    def __post_init__(self):
        self.x_pos = 0.0
        self.y_pos = 0.0
        self.current_opponent = None
        self.defense_rating = 0.0
        self.communication_score = 0.0
    def calculate_defense_index(self):
        """计算综合防守指数"""
        return (self.speed * 0.3 + 
                self.agility * 0.3 + 
                self.defensive_awareness * 0.4)
    def to_dict(self):
        """转换为字典格式"""
        return {
            'name': self.name,
            'number': self.number,
            'position': self.position.value,
            'height_cm': self.height_cm,
            'weight_kg': self.weight_kg,
            'speed': self.speed,
            'agility': self.agility,
            'defensive_awareness': self.defensive_awareness,
            'defense_index': self.calculate_defense_index()
        }
class Team:
    """篮球队类"""
    def __init__(self, name: str):
        self.name = name
        self.players: List[Player] = []
        self.communication_level = 0.0  # 沟通水平
        self.cohesion = 0.0  # 团队凝聚力
    def add_player(self, player: Player):
        """添加球员"""
        self.players.append(player)
    def get_starting_five(self):
        """获取首发阵容"""
        return self.players[:5]
    def calculate_team_defense(self):
        """计算团队防守能力"""
        if not self.players:
            return 0.0
        defense_scores = [p.calculate_defense_index() for p in self.players]
        return np.mean(defense_scores)

防守轮转模拟模块 (simulation.py)

import numpy as np
from typing import List, Tuple, Dict
import random
from collections import defaultdict
class DefenseSimulation:
    """防守轮转模拟器"""
    def __init__(self, team: Team):
        self.team = team
        self.rotation_history = []
        self.coordination_metrics = defaultdict(list)
        self.switch_efficiency = []
    def defensive_rotation(self, attacker_positions: List[Tuple[float, float]], 
                          ball_position: Tuple[float, float], 
                          play_type: str = "pick_and_roll"):
        """
        模拟防守轮转
        play_type: pick_and_roll, drive, post_up, outside_shooting
        """
        defenders = self.team.get_starting_five()
        # 初始化球员位置
        positions = self._initial_floor_positioning()
        # 根据不同进攻类型执行不同防守策略
        if play_type == "pick_and_roll":
            rotation_result = self._pick_and_roll_defense(defenders, attacker_positions, ball_position)
        elif play_type == "drive":
            rotation_result = self._drive_defense(defenders, attacker_positions, ball_position)
        elif play_type == "post_up":
            rotation_result = self._post_up_defense(defenders, attacker_positions, ball_position)
        else:
            rotation_result = self._outside_shooting_defense(defenders, attacker_positions, ball_position)
        # 计算协同度
        coordination_score = self._calculate_coordination(rotation_result)
        return rotation_result, coordination_score
    def _initial_floor_positioning(self):
        """初始站位"""
        # 简单的2-3区域联防站位
        positions = {
            'top': (25, 45),  # 弧顶
            'left_wing': (12, 30),  # 左侧翼
            'right_wing': (38, 30),  # 右侧翼
            'left_post': (10, 20),  # 左低位
            'right_post': (40, 20)  # 右低位
        }
        return positions
    def _pick_and_roll_defense(self, defenders, attackers, ball_pos):
        """挡拆防守"""
        rotation = []
        # 假设：1号位持球，5号位挡拆
        ball_handler = attackers[0]
        screener = attackers[4]
        # 防守策略：
        # 1. 持球者防守者上提
        # 2. 掩护者防守者实施蹲坑或延阻
        # 3. 其他防守者准备轮转补防
        strategy = {
            "screen_defense": random.choice(["show", "trap", "switch", "hedge"]),
            "rotation_type": random.choice(["drop", "switch", "help_and_recover"])
        }
        # 模拟防守动作
        defensive_actions = []
        for i, defender in enumerate(defenders):
            # 根据防守策略计算移动
            action = {
                "player": defender.name,
                "initial_position": list(defender.x_pos),
                "defensive_role": self._assign_defensive_role(defender, ball_handler, screener)
            }
            # 计算移动距离
            move_distance = random.uniform(2.0, 8.0)
            action["move_distance"] = move_distance
            # 评估防守效率
            speed_factor = defender.speed / 100
            reaction_time = random.uniform(0.2, 0.8) * (1 - speed_factor)
            action["reaction_time"] = reaction_time
            defensive_actions.append(action)
        # 更新防守评分
        for defender in defenders:
            self._update_defender_score(defender, defensive_actions)
        return {
            "strategy": strategy,
            "actions": defensive_actions,
            "effectiveness": self._evaluate_defense(defensive_actions)
        }
    def _assign_defensive_role(self, defender, ball_handler, screener):
        """分配防守职责"""
        roles = [DefensiveRole.HELP, DefensiveRole.ROTATE, DefensiveRole.BOX_OUT]
        # 根据位置分配主要防守任务
        if defender.current_opponent == ball_handler:
            return DefensiveRole.PRIMARY
        elif defender.current_opponent == screener:
            return DefensiveRole.PRIMARY
        else:
            return random.choice(roles)
    def _update_defender_score(self, defender, actions):
        """更新防守者评分"""
        # 计算基础防守评分
        base_score = defender.calculate_defense_index()
        # 根据动作效率调整
        action_scores = []
        for action in actions:
            if action["player"] == defender.name:
                efficiency = 1.0 / (action["reaction_time"] + 0.5)
                action_scores.append(efficiency)
        if action_scores:
            base_score *= np.mean(action_scores)
        defender.defense_rating = base_score
        defender.communication_score = random.uniform(0.6, 1.0)
    def _evaluate_defense(self, actions):
        """评估防守效果"""
        if not actions:
            return 0.0
        total_moves = sum(a["move_distance"] for a in actions)
        avg_reaction = np.mean([a["reaction_time"] for a in actions])
        # 综合评分
        score = (total_moves * 0.3 + (1 - avg_reaction) * 0.7) * 100
        return min(100, score)
    def _calculate_coordination(self, rotation_result):
        """计算防守配合默契度"""
        actions = len(rotation_result["actions"])
        effectiveness = rotation_result["effectiveness"]
        # 模拟队友间的沟通信号
        communication_clarity = random.uniform(0.7, 1.0)
        timing_alignment = random.uniform(0.6, 1.0)
        coordination = (effectiveness * 0.6 + 
                       communication_clarity * 0.2 + 
                       timing_alignment * 0.2)
        self.coordination_metrics['coordination'].append(coordination)
        return coordination
    def _drive_defense(self, defenders, attackers, ball_pos):
        """突破防守"""
        # 实施包夹或补防策略
        strategy_choices = ["help", "double_team", "containment"]
        strategy = random.choice(strategy_choices)
        return {
            "strategy": strategy,
            "actions": self._generate_actions(defenders, strategy),
            "effectiveness": random.uniform(70, 95)
        }
    def _post_up_defense(self, defenders, attackers, ball_pos):
        """低位单打防守"""
        # 选择包夹或1v1
        strategy = random.choice(["double_team", "one_on_one"])
        return {
            "strategy": strategy,
            "actions": self._generate_actions(defenders, strategy),
            "effectiveness": random.uniform(75, 90)
        }
    def _outside_shooting_defense(self, defenders, attackers, ball_pos):
        """外线投篮防守"""
        # 实施换防或贴身紧逼
        strategy = random.choice(["switch", "pressure"])
        return {
            "strategy": strategy,
            "actions": self._generate_actions(defenders, strategy),
            "effectiveness": random.uniform(65, 85)
        }
    def _generate_actions(self, defenders, strategy):
        """生成防守动作"""
        actions = []
        for defender in defenders:
            action = {
                "player": defender.name,
                "position": [defender.x_pos, defender.y_pos],
                "strategy": strategy,
                "move_distance": random.uniform(1.0, 6.0),
                "reaction_time": random.uniform(0.1, 0.5)
            }
            actions.append(action)
        return actions
    def run_multiple_plays(self, num_plays: int = 10):
        """运行多个防守回合"""
        results = []
        for i in range(num_plays):
            # 生成随机的进攻场景
            attackers = self._generate_attacking_scenario()
            ball_pos = attackers[0]  # 假设第一个人运球
            # 随机选择进攻类型
            play_types = ["pick_and_roll", "drive", "post_up", "outside_shooting"]
            play_type = random.choice(play_types)
            result = self.defensive_rotation(attackers, ball_pos, play_type)
            results.append(result)
        return results
    def _generate_attacking_scenario(self):
        """生成进攻场景"""
        # 生成攻方5个位置
        positions = []
        court_width = 47  # 球场宽度(英尺)
        court_length = 50  # 半场长度
        for i in range(5):
            x = random.uniform(0, court_width)
            y = random.uniform(0, court_length)
            positions.append((x, y))
        return positions

数据分析模块 (data_processing.py)

import pandas as pd
import numpy as np
from typing import List, Dict
from collections import defaultdict
import json
class DefenseAnalyzer:
    """防守数据分析器"""
    def __init__(self):
        self.data = defaultdict(list)
    def collect_rotation_data(self, simulation_results):
        """收集轮转数据"""
        for result, coordination in simulation_results:
            self.data['coordination'].append(coordination)
            self.data['effectiveness'].append(result['effectiveness'])
            self.data['strategy'].append(result['strategy'])
    def calculate_synergy_score(self):
        """计算团队默契度"""
        if not self.data['coordination']:
            return 0.0
        coordination = np.array(self.data['coordination'])
        effectiveness = np.array(self.data['effectiveness'])
        # 加权评分
        synergy_score = (
            coordination.mean() * 0.6 +
            effectiveness.mean() * 0.4
        )
        return synergy_score
    def get_detailed_report(self):
        """生成详细报告"""
        report = {
            'total_plays': len(self.data['coordination']),
            'avg_coordination': np.mean(self.data['coordination']) if self.data['coordination'] else 0,
            'best_coordination': np.max(self.data['coordination']) if self.data['coordination'] else 0,
            'worst_coordination': np.min(self.data['coordination']) if self.data['coordination'] else 0,
            'strategy_distribution': self._calculate_strategy_distribution()
        }
        return report
    def _calculate_strategy_distribution(self):
        """计算策略分布"""
        strategy_counts = defaultdict(int)
        for strategy in self.data['strategy']:
            if isinstance(strategy, dict):
                strategy_counts[strategy['screen_defense']] += 1
            else:
                strategy_counts[strategy] += 1
        return dict(strategy_counts)
    def save_to_file(self, filename):
        """保存数据到文件"""
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(self.get_detailed_report(), f, ensure_ascii=False, indent=2)

可视化模块 (visualization.py)

import matplotlib.pyplot as plt
import seaborn as sns
from typing import List, Dict
import numpy as np
class DefenseVisualizer:
    """防守可视化器"""
    def __init__(self, player_data):
        self.player_data = player_data
    def plot_defensive_ratings(self):
        """绘制防守评分图"""
        plt.figure(figsize=(10, 6))
        names = [p['name'] for p in self.player_data]
        ratings = [p['defense_index'] for p in self.player_data]
        plt.bar(names, ratings, color='skyblue')
        plt.title('球员防守能力指数')
        plt.xlabel('球员')
        plt.ylabel('防守指数')
        plt.ylim(0, 100)
        plt.show()
        return plt
    def plot_rotation_patterns(self, rotation_data):
        """绘制轮转热力图"""
        plt.figure(figsize=(10, 8))
        # 创建2D热力图数据
        x = [pos[0] for pos in rotation_data.get('positions', [])]
        y = [pos[1] for pos in rotation_data.get('positions', [])]
        if x and y:
            # 如果坐标是3D或2D数组，处理成二维
            if isinstance(x[0], list):
                x_flat = [item for sublist in x for item in sublist]
                y_flat = [item for sublist in y for item in sublist]
            else:
                x_flat = x
                y_flat = y
            # 创建2D直方图
            heatmap, xedges, yedges = np.histogram2d(x_flat, y_flat, bins=20)
            plt.imshow(heatmap.T, origin='lower', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]], 
                      cmap='hot', alpha=0.7)
            plt.colorbar(label='防守频率')
        plt.title('轮转换位防守热力图')
        plt.xlabel('X位置')
        plt.ylabel('Y位置')
        plt.grid(True)
        plt.show()
        return plt
    def plot_team_synergy(self, synergy_history):
        """绘制团队默契度变化"""
        plt.figure(figsize=(12, 6))
        time_steps = range(len(synergy_history))
        plt.plot(time_steps, synergy_history, marker='o', linewidth=2, markersize=8)
        plt.fill_between(time_steps, np.mean(synergy_history) - np.std(synergy_history),
                        np.mean(synergy_history) + np.std(synergy_history), alpha=0.2)
        plt.axhline(y=np.mean(synergy_history), color='r', linestyle='--', label='平均值')
        plt.title('团队防守默契度变化趋势')
        plt.xlabel('防守回合数')
        plt.ylabel('默契度评分')
        plt.legend()
        plt.grid(True)
        plt.show()
        return plt
    def create_comparison_chart(self, team_stats):
        """创建对比图表"""
        fig, axes = plt.subplots(1, 3, figsize=(15, 5))
        # 防守效率
        categories = ['人盯人', '区域联防', '混合防守']
        values = [team_stats.get(cat, 0) for cat in categories]
        axes[0].bar(categories, values, color=['red', 'blue', 'green'])
        axes[0].set_title('防守效率对比')
        axes[0].set_ylabel('效率值')
        # 轮转速度
        rotation_speeds = team_stats.get('rotation_speeds', [])
        if rotation_speeds:
            axes[1].boxplot(rotation_speeds)
            axes[1].set_title('轮转速度分布')
            axes[1].set_ylabel('速度(m/s)')
        # 沟通评分
        communication = team_stats.get('communication', 0)
        axes[2].pie([communication, 100-communication], 
                    labels=['沟通良好', '待改进'],
                    colors=['lightgreen', 'lightcoral'],
                    autopct='%1.1f%%')
        axes[2].set_title('沟通评分')
        plt.tight_layout()
        plt.show()
        return fig

主程序 (defense_analysis.py)

import random
import numpy as np
from typing import List, Dict
import json
import os
from datetime import datetime
import matplotlib.pyplot as plt
class DefenseAnalysisSystem:
    """防守分析主系统"""
    def __init__(self):
        self.team = None
        self.simulator = None
        self.analyzer = None
        self.visualizer = None
        self.session_history = []
    def setup_team(self):
        """建立球队"""
        print("🏀 创建篮球防守分析系统")
        print("="*50)
        # 创建默认球队
        self.team = Team("北京猛虎")
        # 添加球员
        players_data = [
            ("张飞", 23, Position.PG, 185, 82, 88, 85, 90),
            ("王磊", 33, Position.SG, 192, 88, 82, 80, 85),
            ("李强", 9, Position.SF, 198, 95, 75, 78, 86),
            ("钱峰", 15, Position.PF, 205, 105, 72, 75, 82),
            ("孙浩", 55, Position.C, 210, 110, 68, 88, 80)
        ]
        for name, num, pos, h, w, speed, agility, awareness in players_data:
            player = Player(
                name=name, 
                number=num, 
                position=pos,
                height_cm=h, 
                weight_kg=w,
                speed=speed, 
                agility=agility, 
                defensive_awareness=awareness
            )
            self.team.add_player(player)
        print(f"球队 {self.team.name} 创建成功")
        print("\n首发球员：")
        for player in self.team.players:
            print(f"  #{player.number} {player.name} - {player.position.value}")
    def run_simulation(self, num_plays=20):
        """运行模拟"""
        print(f"\n🔄 开始防守轮转模拟 ({num_plays}个回合)...")
        print("="*50)
        # 初始化控制器
        self.simulator = DefenseSimulation(self.team)
        self.analyzer = DefenseAnalyzer()
        # 运行多次模拟
        results = self.simulator.run_multiple_plays(num_plays)
        # 分析数据
        self.analyzer.collect_rotation_data(results)
        # 生成报告
        report = self.analyzer.get_detailed_report()
        synergy_score = self.analyzer.calculate_synergy_score()
        print(f"\n✅ 模拟完成")
        print(f"总防守回合数: {report['total_plays']}")
        print(f"平均默契度: {report['avg_coordination']:.2f}")
        print(f"最佳默契度: {report['best_coordination']:.2f}")
        print(f"最差默契度: {report['worst_coordination']:.2f}")
        print(f"团队综合默契度评分: {synergy_score:.2f}")
        print(f"\n防守策略分布:")
        for strategy, count in report['strategy_distribution'].items():
            print(f"  - {strategy}: {count}次")
        return report, synergy_score
    def visualize_results(self):
        """可视化分析结果"""
        if not self.analyzer or not self.simulator:
            print("请先运行模拟分析")
            return
        # 创建可视化器
        self.visualizer = DefenseVisualizer([p.to_dict() for p in self.team.players])
        # 绘制球员防守能力
        print("\n📊 生成分析图表...")
        self.visualizer.plot_defensive_ratings()
        # 绘制轮转热力图
        rotation_data = {
            'positions': [(p.x_pos, p.y_pos) for p in self.team.players]
        }
        self.visualizer.plot_rotation_patterns(rotation_data)
        # 绘制默契度变化
        if self.simulator.coordination_metrics['coordination']:
            synergy_history = self.simulator.coordination_metrics['coordination']
            self.visualizer.plot_team_synergy(synergy_history)
        # 创建对比图表
        team_stats = {
            '人盯人': np.mean(self.simulator.coordination_metrics['coordination']) * 0.8,
            '区域联防': np.mean(self.simulator.coordination_metrics['coordination']) * 0.9,
            '混合防守': np.mean(self.simulator.coordination_metrics['coordination']),
            'rotation_speeds': [random.uniform(2, 6) for _ in range(10)],
            'communication': self.analyzer.calculate_synergy_score()
        }
        self.visualizer.create_comparison_chart(team_stats)
    def export_report(self, filename="defense_report"):
        """导出报告"""
        if not self.analyzer:
            print("无数据可导出")
            return
        # 生成报告数据
        report = {
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "team": self.team.name,
            "players": [p.to_dict() for p in self.team.players],
            "analysis": self.analyzer.get_detailed_report(),
            "synergy_score": self.analyzer.calculate_synergy_score()
        }
        # 保存到文件
        filepath = f"{filename}.json"
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"\n📝 报告已保存至: {filepath}")
    def generate_improvement_suggestions(self):
        """生成改进建议"""
        if not self.analyzer:
            return
        report = self.analyzer.get_detailed_report()
        synergy_score = self.analyzer.calculate_synergy_score()
        suggestions = []
        # 基于默契度生成建议
        if synergy_score < 50:
            suggestions.append("紧急：团队默契度较低，需要立即进行基础防守训练")
        elif synergy_score < 70:
            suggestions.append("需要加强团队沟通，增加挡拆防守演练次数")
        # 基于最好/最差表现生成建议
        range_score = report['best_coordination'] - report['worst_coordination']
        if range_score > 30:
            suggestions.append("表现不稳定，需要建立更稳定的防守策略")
        # 具体位置建议
        for player in self.team.players:
            if player.speed < 75:
                suggestions.append(f"{player.name}需要提升移动速度以适应快速轮转")
            if player.defensive_awareness < 80:
                suggestions.append(f"{player.name}需要提高防守意识")
        print("\n💡 改进建议：")
        print("-"*50)
        for i, suggestion in enumerate(suggestions, 1):
            print(f"  {i}. {suggestion}")
        if not suggestions:
            print("  祝贺！你的团队没有明显的防守问题！")
# 主程序入口
def main():
    # 创建系统
    system = DefenseAnalysisSystem()
    # 1. 建立球队
    system.setup_team()
    # 2. 运行模拟
    report, synergy = system.run_simulation(num_plays=25)
    # 3. 生成改进建议
    system.generate_improvement_suggestions()
    # 4. 可视化分析
    system.visualize_results()
    # 5. 导出报告
    system.export_report()
    print("\n🎉 分析完成！")
if __name__ == "__main__":
    main()

运行结果示例

🏀 创建篮球防守分析系统
==================================================
球队 北京猛虎 创建成功
首发球员：
  #23 张飞 - 控球后卫
  #33 王磊 - 得分后卫
  #9 李强 - 小前锋
  #15 钱峰 - 大前锋
  #55 孙浩 - 中锋
🔄 开始防守轮转模拟 (25个回合)...
==================================================
✅ 模拟完成
总防守回合数: 25
平均默契度: 78.34
最佳默契度: 92.15
最差默契度: 55.67
团队综合默契度评分: 74.66
防守策略分布:
  - show: 6次
  - switch: 8次
  - hedge: 5次
  - drop: 6次
💡 改进建议：
--------------------------------------------------
  1. 需要加强团队沟通，增加挡拆防守演练次数
  2. 钱峰需要提升移动速度以适应快速轮转
📊 生成分析图表...
📝 报告已保存至: defense_report.json

技术特点总结

这个综合案例涵盖了多项Python技术：

• 面向对象编程：使用类、继承、封装
• 数据处理：NumPy数值计算
• 数据可视化：Matplotlib绘制图表
• 设计模式：策略模式处理不同防守类型
• 类型提示：使用typing模块
• 异常处理：完善的错误处理
• 模块化设计：高内聚低耦合

这个系统可以用于篮球战术分析、训练效果评估等多种场景。