
import unittest
import user_code
import ast
import re   
import unittest
import importlib
from scipy import stats

class TestTask(unittest.TestCase):
    def test_performs_ttest(self):
        import user_code
        importlib.reload(user_code)
        team_a = [15, 18, 21, 17, 19, 20, 16, 18, 22, 20]
        team_b = [12, 14, 15, 13, 16, 15, 14, 13, 16, 15]
        result = user_code.compare_player_scores(team_a, team_b)
        t_stat, p_val = stats.ttest_ind(team_a, team_b)
        _dynamic_test(
            self,
            isinstance(result, tuple) and len(result) == 3,
            "Function returns a tuple of three elements (t-statistic, p-value, interpretation)",
            f"Function did not return a tuple of three elements. Got: {result}"
        )
        returned_t = result[0]
        returned_p = result[1]
        _dynamic_test(
            self,
            abs(returned_t - t_stat) < 1e-6,
            f"Returned t-statistic is correct: {returned_t}",
            f"Expected t-statistic: {t_stat}, got: {returned_t}"
        )
        _dynamic_test(
            self,
            abs(returned_p - p_val) < 1e-6,
            f"Returned p-value is correct: {returned_p}",
            f"Expected p-value: {p_val}, got: {returned_p}"
        )
    def test_interpretation_significant(self):
        import user_code
        importlib.reload(user_code)
        # These two lists are different enough for p < 0.05
        a = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
        b = [20, 20, 20, 20, 20, 20, 20, 20, 20, 20]
        result = user_code.compare_player_scores(a, b)
        p = result[1]
        interp = result[2]
        _dynamic_test(
            self,
            p < 0.05,
            "p-value is less than 0.05 for clearly different groups",
            f"Expected p < 0.05, got {p}"
        )
        _dynamic_test(
            self,
            "statistically significant difference" in interp.lower(),
            "Interpretation string indicates significant difference",
            f"Interpretation string did not indicate significant difference: {interp}"
        )
    def test_interpretation_not_significant(self):
        import user_code
        importlib.reload(user_code)
        # These two lists are similar, p > 0.05
        a = [10, 12, 11, 13, 12, 11, 12, 12, 13, 11]
        b = [11, 12, 10, 13, 11, 12, 13, 10, 12, 11]
        result = user_code.compare_player_scores(a, b)
        p = result[1]
        interp = result[2]
        _dynamic_test(
            self,
            p >= 0.05,
            "p-value is 0.05 or greater for similar groups",
            f"Expected p >= 0.05, got {p}"
        )
        _dynamic_test(
            self,
            "no statistically significant difference" in interp.lower(),
            "Interpretation string indicates no significant difference",
            f"Interpretation string did not indicate no significant difference: {interp}"
        )

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

Explore the core concepts and practical techniques of sports analytics using Python. This course covers essential data analysis, visualization, and machine learning methods tailored for sports data, empowering you to extract insights and make data-driven decisions in the sports domain.

Gain foundational knowledge of sports analytics, explore common data sources, and learn how to handle and visualize sports data using Python.

Delve into statistical methods for analyzing sports data, including descriptive statistics, correlation, and hypothesis testing.

Learn to build and evaluate predictive models for sports outcomes using machine learning techniques.

Challenge: Hypothesis Testing with Sports Data

Løsning