综合python案例，高速跑动距离对比？

wen python案例 2026-09-09 93
本文目录导读：
📊 核心功能
📈 输出结果
我来为您设计一个综合Python案例,分析不同运动状态下的高速跑动距离对比，这个案例将包含数据生成、处理、可视化和分析。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')
# 设置中文显示
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
class SprintAnalyzer:
    """高速跑动分析器"""
    def __init__(self, player_name="运动员", sampling_rate=10):
        """
        初始化分析器
        player_name: 运动员名称
        sampling_rate: 采样频率(Hz)，GPS每0.1秒记录一次
        """
        self.player_name = player_name
        self.sampling_rate = sampling_rate
        self.df = None
        self.speed_thresholds = {
            '低速走': (0, 2.0),      # 0-2 m/s
            '慢跑': (2.0, 4.0),     # 2-4 m/s
            '中速跑': (4.0, 6.0),   # 4-6 m/s
            '高速跑': (6.0, 8.0),   # 6-8 m/s
            '冲刺': (8.0, 12.0)      # >8 m/s
        }
        self.high_speed_threshold = 6.0  # 高速跑阈值 m/s
    def generate_training_data(self, sessions=3, minutes=30):
        """生成模拟训练数据"""
        all_data = []
        for session in range(sessions):
            # 每节训练时长
            duration_seconds = minutes * 60
            n_samples = duration_seconds * self.sampling_rate
            # 生成时间序列
            start_time = datetime.now() - timedelta(days=sessions - session - 1)
            timestamps = [start_time + timedelta(seconds=i/self.sampling_rate) 
                         for i in range(n_samples)]
            # 模拟变速跑动模式
            # 使用正弦函数组合+随机噪声模拟真实跑动
            t = np.linspace(0, 4*np.pi, n_samples)
            # 基础速度模式（包括加速、减速、冲刺阶段）
            base_speed = 3.5 + \
                        1.5*np.sin(t) + \
                        0.8*np.sin(2*t + 0.5) + \
                        2.0*np.exp(-((t-2*np.pi)**2)/(2*0.5**2))  # 冲刺峰值
            # 添加随机噪声
            noise = np.random.normal(0, 0.3, n_samples)
            speed = np.clip(base_speed + noise, 0, 11)
            # 生成位置数据（通过速度积分）
            position_x = np.cumsum(speed) / self.sampling_rate * np.cos(np.linspace(0, 5, n_samples))
            position_y = np.cumsum(speed) / self.sampling_rate * np.sin(np.linspace(0, 5, n_samples))
            # 创建DataFrame
            session_data = pd.DataFrame({
                'timestamp': timestamps,
                'speed_mps': speed,
                'position_x': position_x,
                'position_y': position_y,
                'session': f'训练{session+1}'
            })
            all_data.append(session_data)
        self.df = pd.concat(all_data, ignore_index=True)
        print(f"✅ 数据生成完成！共{len(self.df)}条记录，"
              f"{len(all_data)}节训练课")
        return self.df
    def classify_speed(self):
        """速度分类"""
        if self.df is None:
            raise ValueError("请先加载或生成数据")
        def categorize(speed):
            for category, (low, high) in self.speed_thresholds.items():
                if low <= speed < high:
                    return category
            return '冲刺'
        self.df['speed_category'] = self.df['speed_mps'].apply(categorize)
        self.df['is_high_speed'] = self.df['speed_mps'] >= self.high_speed_threshold
        return self.df
    def calculate_distance(self):
        """计算各速度段的距离"""
        if 'speed_category' not in self.df.columns:
            self.df = self.classify_speed()
        # 计算每段的距离
        self.df['distance'] = self.df['speed_mps'] / self.sampling_rate
        # 按训练课和速度分类统计
        summary = self.df.groupby(['session', 'speed_category'])['distance'].sum().reset_index()
        # 计算各训练课的总距离
        total_distance = self.df.groupby('session')['distance'].sum()
        # 高速跑距离统计
        high_speed_summary = self.df[self.df['is_high_speed']].groupby('session')['distance'].sum()
        print("\n📊 === 距离统计 ===")
        for session in self.df['session'].unique():
            print(f"\n{session}:")
            session_data = summary[summary['session'] == session]
            for _, row in session_data.iterrows():
                print(f"  {row['speed_category']}: {row['distance']:.1f}米")
            print(f"  总距离: {total_distance[session]:.1f}米")
            print(f"  高速跑距离: {high_speed_summary.get(session, 0):.1f}米")
        return summary
    def plot_speed_profile(self):
        """绘制速度曲线"""
        fig, axes = plt.subplots(2, 2, figsize=(15, 10))
        # 1. 速度时间曲线
        ax1 = axes[0, 0]
        for session in self.df['session'].unique():
            session_data = self.df[self.df['session'] == session]
            sample_indices = np.arange(0, len(session_data), 100)  # 每隔10秒采样一次
            ax1.plot(sample_indices/self.sampling_rate/60, 
                    session_data['speed_mps'].iloc[sample_indices], 
                    label=session, alpha=0.7)
        ax1.axhline(y=self.high_speed_threshold, color='red', linestyle='--', 
                   label=f'高速阈值({self.high_speed_threshold}m/s)')
        ax1.set_xlabel('时间(分钟)')
        ax1.set_ylabel('速度(m/s)')
        ax1.set_title(f'{self.player_name} - 跑动速度曲线')
        ax1.legend()
        ax1.grid(True, alpha=0.3)
        # 2. 速度分布箱线图
        ax2 = axes[0, 1]
        sns.boxplot(data=self.df, x='session', y='speed_mps', ax=ax2)
        ax2.axhline(y=self.high_speed_threshold, color='red', linestyle='--')
        ax2.set_ylabel('速度(m/s)')
        ax2.set_title('各训练课速度分布')
        ax2.grid(True, alpha=0.3)
        # 3. 高速跑距离对比
        ax3 = axes[1, 0]
        high_speed_dist = self.df[self.df['is_high_speed']].groupby('session')['distance'].sum()
        total_dist = self.df.groupby('session')['distance'].sum()
        percentage = (high_speed_dist / total_dist * 100)
        bars = ax3.bar(high_speed_dist.index, high_speed_dist.values, color='coral', alpha=0.8)
        # 添加标签
        for bar, dist, pct in zip(bars, high_speed_dist.values, percentage.values):
            ax3.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 5,
                    f'{dist:.0f}m\n({pct:.1f}%)', ha='center', va='bottom')
        ax3.set_ylabel('高速跑距离(米)')
        ax3.set_title('各训练课高速跑距离对比')
        ax3.grid(True, alpha=0.3, axis='y')
        # 4. 速度分类频率图
        ax4 = axes[1, 1]
        time_in_category = self.df.groupby(['session', 'speed_category']).size().unstack() / self.sampling_rate / 60
        time_in_category.plot(kind='bar', stacked=True, ax=ax4, colormap='viridis')
        ax4.set_ylabel('时间(分钟)')
        ax4.set_title('速度区间时间分布')
        ax4.legend(title='速度等级')
        ax4.set_xticklabels(ax4.get_xticklabels(), rotation=0)
        ax4.grid(True, alpha=0.3, axis='y')
        plt.tight_layout()
        plt.show()
    def calculate_high_speed_metrics(self):
        """计算高速跑关键指标"""
        if self.df is None:
            raise ValueError("请先加载或生成数据")
        # 识别冲刺（连续高速跑动）
        high_speed_mask = self.df['is_high_speed'].values
        sprint_count = 0
        sprints = []
        sprint_start = None
        for i, is_high in enumerate(high_speed_mask):
            if is_high and sprint_start is None:
                sprint_start = i
            elif not is_high and sprint_start is not None:
                sprint_count += 1
                duration_seconds = (i - sprint_start) / self.sampling_rate
                distance = self.df['distance'][sprint_start:i].sum()
                avg_speed = self.df['speed_mps'][sprint_start:i].mean()
                max_speed = self.df['speed_mps'][sprint_start:i].max()
                sprints.append({
                    'sprint_id': sprint_count,
                    'duration_seconds': duration_seconds,
                    'distance': distance,
                    'avg_speed': avg_speed,
                    'max_speed': max_speed,
                    'session': self.df['session'][sprint_start]
                })
                sprint_start = None
        self.sprint_stats = pd.DataFrame(sprints)
        print("\n🏃 === 冲刺统计 ===")
        if len(self.sprint_stats) > 0:
            print(f"冲刺次数: {len(self.sprint_stats)}")
            print(f"平均冲刺速度: {self.sprint_stats['avg_speed'].mean():.2f} m/s")
            print(f"最大冲刺速度: {self.sprint_stats['max_speed'].max():.2f} m/s")
            print(f"平均冲刺时长: {self.sprint_stats['duration_seconds'].mean():.2f}秒")
            print(f"平均冲刺距离: {self.sprint_stats['distance'].mean():.2f}米")
            print(f"最远冲刺: {self.sprint_stats['distance'].max():.2f}米")
            # 按训练课统计
            print("\n各训练课冲刺统计:")
            session_sprint = self.sprint_stats.groupby('session').agg({
                'sprint_id': 'count',
                'distance': ['sum', 'mean', 'max'],
                'max_speed': 'max',
                'duration_seconds': 'sum'
            }).round(2)
            print(session_sprint)
        else:
            print("未检测到冲刺")
        return self.sprint_stats
    def generate_report(self):
        """生成分析报告"""
        if self.df is None:
            raise ValueError("请先加载或生成数据")
        # 计算总体指标
        total_distance = self.df['distance'].sum()
        avg_speed = self.df['speed_mps'].mean()
        max_speed = self.df['speed_mps'].max()
        high_speed_distance = self.df[self.df['is_high_speed']]['distance'].sum()
        high_speed_percentage = (high_speed_distance / total_distance * 100)
        # 创建报告文本
        report = f"""
        ╔══════════════════════════════════════════╗
        ║        {self.player_name} - 高速跑动分析报告        ║
        ╚══════════════════════════════════════════╝
        📅 数据概况
        ─────────────────────────────────
        • 训练时长: {(len(self.df) / self.sampling_rate / 60):.1f} 分钟
        • 总跑动距离: {total_distance:.1f} 米
        • 平均速度: {avg_speed:.2f} m/s
        • 最大速度: {max_speed:.2f} m/s
        🏃 高速跑动指标
        ─────────────────────────────────
        • 高速跑阈值: ≥ {self.high_speed_threshold} m/s
        • 高速跑距离: {high_speed_distance:.1f} 米
        • 高速跑占比: {high_speed_percentage:.1f}%
        📊 冲刺表现
        ─────────────────────────────────"""
        if hasattr(self, 'sprint_stats') and len(self.sprint_stats) > 0:
            report += f"""
        • 冲刺次数: {len(self.sprint_stats)}
        • 总冲刺距离: {self.sprint_stats['distance'].sum():.1f} 米
        • 冲刺平均速度: {self.sprint_stats['avg_speed'].mean():.2f} m/s"""
        # 各速度区间占比
        report += "\n\n💨 速度区间分析"
        speed_dist = self.df.groupby('speed_category')['distance'].sum()
        total = speed_dist.sum()
        report += "\n─────────────────────────────────"
        for category, distance in speed_dist.items():
            percentage = (distance / total * 100)
            bar_length = int(percentage / 2)
            bar = '█' * bar_length + '░' * (50 - bar_length)
            report += f"\n{category:8s} |{bar}| {distance:6.1f}m ({percentage:5.1f}%)"
        report += f"""
        ⏱️ 恢复情况
        ─────────────────────────────────
        • 平均心率(模拟): {np.random.randint(120, 145)} bpm
        • 最高心率(模拟): {np.random.randint(180, 195)} bpm
        • 恢复时间(模拟): {np.random.randint(2, 8)} 分钟
        💡 建议{self.suggestions()}
        """
        return report
    def suggestions(self):
        """生成建议"""
        if self.df is None:
            return ""
        high_speed_ratio = self.df[self.df['is_high_speed']]['distance'].sum() / self.df['distance'].sum()
        if high_speed_ratio < 0.1:
            return "\n1. 增加高速跑训练比例\n2. 加入间歇性冲刺训练\n3. 提高训练强度"
        elif high_speed_ratio > 0.3:
            return "\n1. 注意控制训练负荷\n2. 加强恢复和预防措施\n3. 适量减少冲刺训练"
        else:
            return "\n1. 继续保持当前训练结构\n2. 适当增加冲刺多样性\n3. 关注速度变化规律"
def main():
    """主函数"""
    print("🚀 高速跑动距离对比分析系统")
    print("="*50)
    # 创建分析器
    analyzer = SprintAnalyzer(player_name="测试运动员", sampling_rate=10)
    # 生成训练数据（3节训练课，每节30分钟）
    print("\n📊 正在生成模拟训练数据...")
    data = analyzer.generate_training_data(sessions=3, minutes=30)
    # 速度分类和距离计算
    print("\n🔍 正在进行速度分类和距离计算...")
    analyzer.classify_speed()
    analyzer.calculate_distance()
    # 计算冲刺统计
    analyzer.calculate_high_speed_metrics()
    # 绘制可视化图表
    print("\n📈 正在生成可视化图表...")
    analyzer.plot_speed_profile()
    # 生成报告
    report = analyzer.generate_report()
    print(report)
    # 导出数据到CSV
    try:
        analyzer.df.to_csv('sprint_data.csv', index=False)
        print("\n💾 详细数据已保存到 'sprint_data.csv'")
        print("📄 数据文件包含速度、距离、位置等详细记录")
    except Exception as e:
        print(f"⚠️ 保存数据失败: {e}")
if __name__ == "__main__":
    main()
这个Python案例提供了完整的高速跑动距离分析系统，主要功能包括：