
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        data = {
            "Game": [1, 2, 3, 4, 5],
            "Points": [22, 18, 30, 25, 27],
            "Assists": [5, 7, 6, 8, 7],
            "Rebounds": [10, 9, 12, 11, 13]
        }
        self.df = pd.DataFrame(data)
        # Patch plt.show to not block
        self._original_show = plt.show
        plt.show = lambda *a, **kw: None

    def tearDown(self):
        plt.show = self._original_show
        plt.close('all')

    def test_three_lines_plotted(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_player_performance(self.df)
        lines = [l for l in plt.gca().get_lines()]
        _dynamic_test(
            self,
            len(lines) == 3,
            "Three lines are plotted for 'Points', 'Assists', and 'Rebounds'",
            f"Expected 3 lines, found {len(lines)}."
        )

    def test_distinct_markers(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_player_performance(self.df)
        lines = [l for l in plt.gca().get_lines()]
        markers = set([l.get_marker() for l in lines])
        _dynamic_test(
            self,
            len(markers) == 3 and all(m != "None" for m in markers),
            "Each line has a distinct marker",
            f"Expected 3 distinct markers, got {markers}."
        )

    def test_labels_and_title(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_player_performance(self.df)
        ax = plt.gca()
        title = ax.get_title()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        legend = ax.get_legend()
        _dynamic_test(
            self,
            title != '' and xlabel != '' and ylabel != '' and legend is not None,
            "Plot includes title, x-axis label, y-axis label, and legend",
            f"Missing plot title, axis labels, or legend."
        )

    def test_data_points_correct(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_player_performance(self.df)
        ax = plt.gca()
        lines = ax.get_lines()
        # Map line label to y-data
        line_dict = {l.get_label(): l.get_ydata() for l in lines}
        points = tuple(self.df["Points"])
        assists = tuple(self.df["Assists"])
        rebounds = tuple(self.df["Rebounds"])
        _dynamic_test(
            self,
            tuple(line_dict.get("Points", ())) == points and tuple(line_dict.get("Assists", ())) == assists and tuple(line_dict.get("Rebounds", ())) == rebounds,
            "Plot lines show correct data from DataFrame",
            f"Data on plot does not match DataFrame. Got: {line_dict}"
        )

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: Creating a Sports Visualization

解答