When you analyze product-level summaries, you gain a powerful lens into your business's performance. By aggregating sales data for each product, you can quickly identify which items are driving the most revenue and which ones may be underperforming. This insight enables you to make data-driven decisions, such as focusing marketing efforts on bestsellers, reconsidering inventory for slow movers, or adjusting pricing strategies. Summaries like these are foundational for business analysts aiming to optimize product portfolios and maximize profitability.


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

class TestTask(unittest.TestCase):
    def test_correct_summary_multiple_products(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {'product': 'Widget', 'units_sold': 10, 'revenue': 250},
            {'product': 'Gadget', 'units_sold': 5, 'revenue': 150},
            {'product': 'Widget', 'units_sold': 7, 'revenue': 175},
            {'product': 'Gizmo', 'units_sold': 3, 'revenue': 90},
            {'product': 'Gadget', 'units_sold': 2, 'revenue': 60}
        ]
        result = user_code.summarize_products(records)
        expected = {
            'Widget': {'units_sold': 17, 'revenue': 425},
            'Gadget': {'units_sold': 7, 'revenue': 210},
            'Gizmo': {'units_sold': 3, 'revenue': 90}
        }
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Returns correct summary for multiple products",
            f"Expected summary {expected}, got {result}",
        )

    def test_units_sold_aggregation(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {'product': 'Alpha', 'units_sold': 1, 'revenue': 10},
            {'product': 'Alpha', 'units_sold': 2, 'revenue': 20},
            {'product': 'Alpha', 'units_sold': 3, 'revenue': 30}
        ]
        result = user_code.summarize_products(records)
        _dynamic_test(
            self,
            'Alpha' in result and result['Alpha']['units_sold'] == 6,
            "Correctly sums 'units_sold' for repeated product",
            f"Expected units_sold=6 for 'Alpha', got {result.get('Alpha', {}).get('units_sold', None)}",
        )

    def test_revenue_aggregation(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {'product': 'Beta', 'units_sold': 1, 'revenue': 100},
            {'product': 'Beta', 'units_sold': 2, 'revenue': 200},
            {'product': 'Beta', 'units_sold': 3, 'revenue': 300}
        ]
        result = user_code.summarize_products(records)
        _dynamic_test(
            self,
            'Beta' in result and result['Beta']['revenue'] == 600,
            "Correctly sums 'revenue' for repeated product",
            f"Expected revenue=600 for 'Beta', got {result.get('Beta', {}).get('revenue', None)}",
        )

    def test_single_product(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {'product': 'Solo', 'units_sold': 4, 'revenue': 40}
        ]
        result = user_code.summarize_products(records)
        expected = {'Solo': {'units_sold': 4, 'revenue': 40}}
        _dynamic_test(
            self,
            isinstance(result, dict) and result == expected,
            "Handles single product correctly",
            f"Expected {expected}, got {result}",
        )

    def test_empty_input(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.summarize_products([])
        _dynamic_test(
            self,
            isinstance(result, dict) and result == {},
            "Returns empty dict for empty input list",
            f"Expected empty dict, got {result}",
        )

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: Summarize Product Performance

Solution