实用脚本统计冲刺跑次数谁更多？

本文目录导读：

1. 场景一：你有 GPS 轨迹数据（GPX/CSV）—— 最准确
2. 场景二：你有列表数据（如 Python 列表或 Excel）—— 最简单
3. 场景三：你有运动 App 的原始训练记录（如 Strava API）
4. 如何选择“冲刺”阈值？（关键参数）
5. 如果数据是“手动计时”的表格
6. 总结使用步骤：

要统计冲刺跑（Sprint）次数谁更多，通常需要依赖可穿戴设备（如手表、心率带）或运动App（如Strava、佳明Connect、Keep）的原始数据。

由于我无法直接访问你的设备，我将为你提供三种不同场景的实用脚本（Python）,你可以根据自己手头的数据格式选择使用。

你有 GPS 轨迹数据（GPX/CSV）—— 最准确

适用对象：跑表导出的 .gpx 或 .csv 文件。 判断逻辑：计算两个GPS点之间的瞬时速度，如果速度超过某一阈值（如 25 km/h），且持续超过N秒,标记为一次冲刺。

Python 脚本（处理 CSV 导出数据）

假设你的CSV文件包含 time（秒）、lat（纬度）、lon（经度）列。

import csv
import math
from datetime import datetime
def haversine(lat1, lon1, lat2, lon2):
    """计算两点间距离（米）"""
    R = 6371000
    phi1, phi2 = math.radians(lat1), math.radians(lat2)
    dphi = math.radians(lat2 - lat1)
    dlambda = math.radians(lon2 - lon1)
    a = math.sin(dphi/2)**2 + math.cos(phi1)*math.cos(phi2)*math.sin(dlambda/2)**2
    return 2 * R * math.asin(math.sqrt(a))
def count_sprints_v2(csv_file, speed_threshold_kmh=20.0, min_duration_s=3):
    """
    统计冲刺跑次数
    :param csv_file: CSV 文件路径
    :param speed_threshold_kmh: 速度阈值 (km/h)
    :param min_duration_s: 达到阈值的最小持续时间（秒）
    """
    sprints = []
    current_sprint_start = None
    in_sprint = False
    prev_point = None
    prev_time = None
    with open(csv_file, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            # 解析时间和坐标
            try:
                # 如果时间是字符串，请根据格式修改
                t = float(row['time'])
                lat = float(row['lat'])
                lon = float(row['lon'])
            except ValueError:
                continue
            if prev_point is not None:
                # 计算距离和速度
                dt = t - prev_time
                if dt > 0:
                    dist = haversine(prev_point[0], prev_point[1], lat, lon)
                    speed_ms = dist / dt
                    speed_kmh = speed_ms * 3.6
                    # 判断是否达到冲刺阈值
                    if speed_kmh >= speed_threshold_kmh:
                        if not in_sprint:
                            # 冲刺开始
                            current_sprint_start = t
                            in_sprint = True
                        # 检查是否达到最小持续时间
                        elif t - current_sprint_start >= min_duration_s:
                            # 如果尚未记录这次冲刺，则打标记
                            if current_sprint_start not in sprints:
                                sprints.append(current_sprint_start)
                    else:
                        # 速度下降，冲刺结束
                        if in_sprint and (t - current_sprint_start) >= min_duration_s:
                            # 如果冲刺在之前没有记录（这里做个防重复处理）
                            pass
                        in_sprint = False
                        current_sprint_start = None
            prev_point = (lat, lon)
            prev_time = t
    # 清理：处理文件结束时的最后冲刺
    if in_sprint and current_sprint_start is not None:
        # 确保持续时间达标（假设文件最后时间足够长）
        pass
    # 返回唯一冲刺数（基于开始时间）
    return len(sprints) if sprints else 0
# 使用示例（将文件路径替换为你的文件）
# 假设你有两个文件：player_a.csv 和 player_b.csv
# count_a = count_sprints_v2('player_a.csv')
# count_b = count_sprints_v2('player_b.csv')
# print(f"玩家A冲刺次数: {count_a}，玩家B冲刺次数: {count_b}")
# 如果比较结果：
# if count_a > count_b:
#     print("A 更多")
# elif count_b > count_a:
#     print("B 更多")
# else:
#     print("平局")

你有列表数据（如 Python 列表或 Excel）—— 最简单

适用对象：假设你有一个包含“每秒速度”的序列，或者一个“冲刺/非冲刺”的布尔列表。

Python 脚本（统计连续 True 的数量）

def count_sprints_from_bool(list_of_bool, min_streak=2):
    """
    统计连续为 True 的段数（代表一次冲刺）
    :param list_of_bool: [True, False, True, True, True, False]
    :param min_streak: 至少连续几秒算一次冲刺
    """
    count = 0
    streak = 0
    for val in list_of_bool:
        if val:
            streak += 1
        else:
            if streak >= min_streak:
                count += 1
            streak = 0
    # 处理末尾
    if streak >= min_streak:
        count += 1
    return count
# 示例数据（假设这是传感器数据，True表示速度超过阈值）
data_a = [True, False, True, True, True, False, False, True]
data_b = [True, True, True, True, False, True]
sprints_a = count_sprints_from_bool(data_a)
sprints_b = count_sprints_from_bool(data_b)
print(f"A: {sprints_a}次, B: {sprints_b}次")
if sprints_a > sprints_b:
    print("A 更多")
else:
    print("B 更多")

你有运动 App 的原始训练记录（如 Strava API）

思路：使用 Python 请求 Strava API，将活动数据拉下来，使用上述算法计算，但由于需要 OAuth 授权，属于高级用法,这里提供简化版逻辑：

1. 安装库：pip install stravalib
2. 获取活动数据流（速度流），然后套用场景二的逻辑。

如何选择“冲刺”阈值？（关键参数）

在足球、篮球等运动中,通常定义：

• 阈值速度：远高于慢跑速度，一般在 20-25 km/h（非职业）或 >25 km/h（职业）。
• 持续时间：至少要持续 1-3秒 才定义为一次冲刺,避免停顿瞬间的误判。
• 恢复时间：如果两次冲刺间隔小于 5秒，可合并为同一次冲刺（连续冲刺），上面的脚本没有合并逻辑,如需要可以增加。

如果数据是“手动计时”的表格

如果你是用秒表手动记录的冲刺次数（比如A有5次，B有4次），那直接用 Excel 公式 =COUNTIF 即可：

=COUNTIF(A1:A10, "冲刺")

总结使用步骤：

1. 提取数据：导出你的跑步机/手表/手机软件的数据，转成 CSV。
2. 调整参数：修改脚本中的 speed_threshold_kmh 和 min_duration_s 适配你的运动水平。
3. 运行比较：对两个文件/数组运行,输出结果。

如果你有具体的数据文件格式（Excel 表头或 GPX 文件），可以发给我,我帮你写一个针对性更强的解析版本。