Automating regional analysis is a powerful way to ensure that every part of your business benefits from timely, consistent insights. When you automate the process of cleaning, summarizing, and reporting on sales data from different regions, you eliminate manual errors and delays, making it possible to compare performance quickly and fairly. This allows business leaders to spot trends, identify top products, and make informed decisions for each region without waiting for ad hoc reports or risking inconsistencies in analysis. By standardizing the workflow, you also free up valuable analyst time to focus on higher-level strategy rather than repetitive data tasks.


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

class TestTask(unittest.TestCase):
    def test_returns_dict_with_region_keys(self):
        import user_code
        importlib.reload(user_code)
        res = user_code.automate_regional_analysis([], [])
        _dynamic_test(
            self,
            isinstance(res, dict) and set(res.keys()) == {"North", "South"},
            "Function returns dictionary with 'North' and 'South' keys",
            f"Expected keys 'North' and 'South', got {list(res.keys()) if isinstance(res, dict) else res}",
        )

    def test_report_values_are_strings(self):
        import user_code
        importlib.reload(user_code)
        res = user_code.automate_regional_analysis([], [])
        _dynamic_test(
            self,
            isinstance(res["North"], str) and isinstance(res["South"], str),
            "Both region reports are strings",
            f"Expected string values for both regions, got {type(res['North'])} and {type(res['South'])}",
        )

    def test_cleans_invalid_records(self):
        import user_code
        importlib.reload(user_code)
        data = [
            {"product": None, "sales": 10},
            {"product": "Widget", "sales": None},
            {"product": "Widget", "sales": "bad"},
            "not a dict",
            {"product": "Widget", "sales": 20}
        ]
        res = user_code.automate_regional_analysis(data, [])
        report = res["North"]
        _dynamic_test(
            self,
            "Widget: 20.00" in report and "not a dict" not in report,
            "Cleans invalid records and only valid sales are included",
            f"Expected only valid 'Widget: 20.00' in report, got: {report}",
        )

    def test_sums_sales_per_product_and_formats(self):
        import user_code
        importlib.reload(user_code)
        data = [
            {"product": "Widget", "sales": "10.1"},
            {"product": "Widget", "sales": 5.2},
            {"product": "Gadget", "sales": 3},
            {"product": "Gadget", "sales": "7.5"},
        ]
        res = user_code.automate_regional_analysis(data, [])
        report = res["North"]
        _dynamic_test(
            self,
            "Widget: 15.30" in report and "Gadget: 10.50" in report,
            "Report sums sales per product and formats to two decimals",
            f"Expected 'Widget: 15.30' and 'Gadget: 10.50' in report, got: {report}",
        )

    def test_empty_or_fully_invalid_lists(self):
        import user_code
        importlib.reload(user_code)
        res = user_code.automate_regional_analysis([], [])
        _dynamic_test(
            self,
            "No valid sales data." in res["North"] and "No valid sales data." in res["South"],
            "Handles empty input lists by reporting no valid sales data",
            f"Expected report with 'No valid sales data.', got: {res}",
        )
        # All invalid
        data = [
            {"product": None, "sales": None},
            "not a dict"
        ]
        res = user_code.automate_regional_analysis(data, data)
        _dynamic_test(
            self,
            "No valid sales data." in res["North"] and "No valid sales data." in res["South"],
            "Handles fully invalid lists by reporting no valid sales data",
            f"Expected report with 'No valid sales data.', got: {res}",
        )

    def test_sample_data(self):
        import user_code
        importlib.reload(user_code)
        north_sales = [
            {"product": "Widget", "sales": "100.5"},
            {"product": "Gadget", "sales": 85},
            {"product": "Widget", "sales": "invalid"},
            {"product": "Gizmo", "sales": 50},
            {"product": None, "sales": 30},
            "not a dict",
            {"product": "Widget", "sales": 25.0}
        ]
        south_sales = [
            {"product": "Widget", "sales": "75"},
            {"product": "Gadget", "sales": 95.5},
            {"product": "", "sales": 20},
            {"product": "Gizmo", "sales": None},
            {"product": "Gadget", "sales": "10"},
            {"product": "Widget", "sales": 40}
        ]
        res = user_code.automate_regional_analysis(north_sales, south_sales)
        north = res["North"]
        south = res["South"]
        _dynamic_test(
            self,
            "Widget: 125.50" in north and "Gadget: 85.00" in north and "Gizmo: 50.00" in north,
            "North region report includes correct product totals",
            f"Expected correct product totals in North report, got: {north}",
        )
        _dynamic_test(
            self,
            "Widget: 115.00" in south and "Gadget: 105.50" in south,
            "South region report includes correct product totals",
            f"Expected correct product totals in South report, got: {south}",
        )

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: Automate Regional Sales Analysis

解答