In this challenge, you will apply your understanding of **kinematics** to real-world data by analyzing a runner's sprint. You are given a CSV file containing `time` (in seconds) and `position` (in meters) of a runner at various points during a sprint. Your task is to load this data, compute the runner's **average speed** and **acceleration** over specific intervals, and visualize the results using plots. This exercise will help you connect the mathematical concepts of motion to practical data analysis and visualization in Python.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import os
import csv
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        # Create a test CSV file with time and position columns
        self.test_file = "sprint_data.csv"
        self.test_data = [
            ["time","position"],
            [0, 0],
            [1, 2],
            [2, 6],
            [3, 12],
            [4, 20],
            [5, 30],
        ]
        with open(self.test_file, "w", newline="") as f:
            writer = csv.writer(f)
            writer.writerows(self.test_data)

    def tearDown(self):
        if os.path.exists(self.test_file):
            os.remove(self.test_file)

    def test_average_speed(self):
        import user_code
        importlib.reload(user_code)
        avg_speed, _ = user_code.analyze_sprint(self.test_file)
        expected_speed = (30 - 0) / (5 - 0)
        _dynamic_test(
            self,
            avg_speed is not None and abs(avg_speed - expected_speed) < 1e-6,
            f"Average speed correctly calculated as {expected_speed}",
            f"Expected average speed {expected_speed}, got {avg_speed}"
        )

    def test_average_acceleration(self):
        import user_code
        importlib.reload(user_code)
        _, avg_acceleration = user_code.analyze_sprint(self.test_file)
        # Speeds (delta position / delta time): [nan, 2, 4, 6, 8, 10] (time steps = 1s)
        # avg acceleration: (10 - 2) / (5 - 0) = 8 / 5 = 1.6
        expected_acceleration = (10 - 2) / 5
        _dynamic_test(
            self,
            avg_acceleration is not None and abs(avg_acceleration - expected_acceleration) < 1e-6,
            f"Average acceleration correctly calculated as {expected_acceleration}",
            f"Expected average acceleration {expected_acceleration}, got {avg_acceleration}"
        )

    def test_plot_generation(self):
        import user_code
        importlib.reload(user_code)
        import matplotlib.pyplot as plt
        plt.close("all")
        # Capture the number of figures before
        num_figs_before = len(plt.get_fignums())
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.analyze_sprint(self.test_file)
        # Check that a new figure was created
        num_figs_after = len(plt.get_fignums())
        _dynamic_test(
            self,
            num_figs_after > num_figs_before,
            "Function generates at least one plot (figure)",
            "Expected at least one plot to be generated, but none was detected."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A hands-on Python course designed specifically for physics students, focusing on applying Python programming to solve real-world physics problems. Each section blends engaging theory with practical challenges, covering topics from kinematics to data analysis and visualization.

Explore the fundamentals of motion using Python, from basic displacement calculations to simulating projectile trajectories and analyzing real-world movement data.

Dive into the world of forces and energy, using Python to model Newton's laws, simulate collisions, and analyze energy transformations.

Master the use of Python for analyzing, interpreting, and visualizing experimental and simulated physics data.

Challenge: Analyze a Runner's Sprint

Løsning