import unittest
import user_code
import importlib
import io
from contextlib import redirect_stdout
import re

class TestTask(unittest.TestCase):
    def test_dataframe_shape_and_content(self):
        import pandas as pd
        importlib.reload(user_code)
        # Check that 'df' is assigned
        user_df = getattr(user_code, 'df', None)
        data = {
            "Date": ["2024-04-01", "2024-04-02", "2024-04-03", "2024-04-04", "2024-04-05"],
            "Home Team": ["Lions", "Tigers", "Bears", "Wolves", "Eagles"],
            "Away Team": ["Eagles", "Wolves", "Tigers", "Lions", "Bears"],
            "Home Score": [3, 2, 1, 0, 4],
            "Away Score": [1, 2, 2, 3, 2]
        }
        expected_df = pd.DataFrame(data)
        _dynamic_test(
            self,
            user_df is not None and hasattr(user_df, 'shape') and user_df.shape == (5, 5),
            "DataFrame variable 'df' exists and has correct shape (5 rows, 5 columns)",
            f"Expected 'df' with shape (5,5), got {None if user_df is None else user_df.shape}",
        )
        _dynamic_test(
            self,
            user_df is not None and (list(user_df.columns) == list(expected_df.columns)) and user_df.equals(expected_df),
            "DataFrame 'df' contains the correct data and columns",
            f"DataFrame 'df' content or columns incorrect.\\nExpected:\\n{expected_df}\\nGot:\\n{user_df}",
        )

    def test_output_head_and_info(self):
        import pandas as pd
        importlib.reload(user_code)
        data = {
            "Date": ["2024-04-01", "2024-04-02", "2024-04-03", "2024-04-04", "2024-04-05"],
            "Home Team": ["Lions", "Tigers", "Bears", "Wolves", "Eagles"],
            "Away Team": ["Eagles", "Wolves", "Tigers", "Lions", "Bears"],
            "Home Score": [3, 2, 1, 0, 4],
            "Away Score": [1, 2, 2, 3, 2]
        }
        df = pd.DataFrame(data)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue()
        # Check that head appears in output (ignore index, ignore spaces)
        for row in df.head().values.tolist():
            row_str = ' '.join(str(x) for x in row)
            _dynamic_test(
                self,
                normalize_text(row_str) in normalize_text(output),
                f"Row '{row_str}' from DataFrame head is displayed",
                f"Row '{row_str}' not found in output: {output}",
            )
        # Check info output
        info_capture = io.StringIO()
        df.info(buf=info_capture)
        info_text = info_capture.getvalue()
        # Check that column names and count are in output
        for col in df.columns:
            _dynamic_test(
                self,
                normalize_text(col) in normalize_text(output),
                f"Column '{col}' from DataFrame info is displayed",
                f"Column '{col}' not found in output: {output}",
            )
        # Check for '5 entries' in info
        _dynamic_test(
            self,
            "5 entries" in normalize_text(output),
            "Info about 5 entries is displayed",
            f"Expected '5 entries' in info output: {output}",
        )
        # Check for type info (object and int64)
        _dynamic_test(
            self,
            ("object" in normalize_text(output)) and ("int64" in normalize_text(output)),
            "Info about column types is displayed",
            f"Expected type info (object, int64) in info output: {output}",
        )

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:
    import ast
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    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 not assign_nodes:
        return code
    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: Exploring a Sports Dataset

解答