Automating report generation is a powerful way to streamline business analysis. By letting Python handle the repetitive task of formatting and compiling product summaries, you can focus on interpreting results and making strategic decisions. Automated reports not only save time but also ensure that every report follows a consistent structure, reducing errors and making it easier for stakeholders to understand key metrics at a glance.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_report_multiple_products(self):
        import user_code
        importlib.reload(user_code)
        summary = {
            "Widget": {"units_sold": 120, "revenue": 2400.00},
            "Gadget": {"units_sold": 75, "revenue": 1500.50},
            "Thingamajig": {"units_sold": 200, "revenue": 5000.00}
        }
        report = user_code.generate_product_report(summary)
        _dynamic_test(
            self,
            isinstance(report, str),
            "Report is a string for multiple products",
            f"Expected string, got {type(report)}"
        )
        # Check all products are present with correct formatting
        for product, data in summary.items():
            expected_line = f"Product: {product}, Units Sold: {data['units_sold']}, Revenue: ${data['revenue']:.2f}"
            _dynamic_test(
                self,
                expected_line in report,
                f"Report contains correct line for {product}",
                f"Missing or incorrect line for {product}: {expected_line}"
            )
        # Check total revenue line
        total_revenue = sum(d['revenue'] for d in summary.values())
        expected_total = f"Total Revenue: ${total_revenue:.2f}"
        _dynamic_test(
            self,
            expected_total in report,
            "Report contains correct total revenue line",
            f"Missing or incorrect total revenue line: {expected_total}"
        )

    def test_report_empty_summary(self):
        import user_code
        importlib.reload(user_code)
        summary = {}
        report = user_code.generate_product_report(summary)
        _dynamic_test(
            self,
            isinstance(report, str),
            "Report is a string for empty summary",
            f"Expected string, got {type(report)}"
        )
        expected_total = "Total Revenue: $0.00"
        _dynamic_test(
            self,
            report.strip() == expected_total,
            "Report for empty summary only includes total revenue line",
            f"Expected only '{expected_total}', got '{report.strip()}'"
        )

    def test_report_single_product(self):
        import user_code
        importlib.reload(user_code)
        summary = {"Gizmo": {"units_sold": 10, "revenue": 123.45}}
        report = user_code.generate_product_report(summary)
        _dynamic_test(
            self,
            isinstance(report, str),
            "Report is a string for single product",
            f"Expected string, got {type(report)}"
        )
        expected_line = "Product: Gizmo, Units Sold: 10, Revenue: $123.45"
        expected_total = "Total Revenue: $123.45"
        _dynamic_test(
            self,
            expected_line in report,
            "Report contains correct line for single product",
            f"Missing or incorrect line for Gizmo: {expected_line}"
        )
        _dynamic_test(
            self,
            expected_total in report,
            "Report contains correct total revenue line for single product",
            f"Missing or incorrect total revenue line: {expected_total}"
        )

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

Unlock the power of Python to solve real-world business analysis problems. This course guides business analysts through practical Python applications, from data wrangling and visualization to automating reports and uncovering insights. Each section blends engaging theory with hands-on challenges inspired by business scenarios.

Learn how to use Python to clean, transform, and summarize business data for analysis. This section focuses on practical data wrangling skills essential for business analysts.

Discover how to use Python to create compelling visualizations that help communicate business insights effectively.

Harness Python to automate repetitive business analysis tasks, from generating reports to extracting actionable insights.

Challenge: Generate Product Summary Report

解答