Comparing sales and profit side by side is essential for business analysis because it reveals products that may generate high revenue but yield low profit. By visualizing both metrics together, you can quickly spot items that, despite strong sales, might have high costs or low margins, as well as products that are both strong sellers and highly profitable. This insight helps you identify where to focus efforts to improve profitability and avoid relying solely on revenue figures when making strategic decisions.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Reload user_code before each test
        import user_code
        importlib.reload(user_code)

    def test_two_subplots_created(self):
        import user_code
        plt.close('all')
        sales = [10, 20, 30]
        profits = [1, 2, 3]
        products = ['X', 'Y', 'Z']
        user_code.compare_sales_profit(sales, profits, products)
        figs = list(map(plt.figure, plt.get_fignums()))
        _dynamic_test(
            self,
            len(figs) > 0,
            "A matplotlib figure is created.",
            "No matplotlib figure was created."
        )
        if len(figs) > 0:
            fig = figs[-1]
            axes = fig.get_axes()
            _dynamic_test(
                self,
                len(axes) == 2,
                "Figure has exactly two subplots.",
                f"Expected 2 subplots, found {len(axes)}."
            )

    def test_sales_subplot_bar_chart(self):
        import user_code
        plt.close('all')
        sales = [100, 200, 300]
        profits = [10, 20, 30]
        products = ['A', 'B', 'C']
        user_code.compare_sales_profit(sales, profits, products)
        fig = plt.gcf()
        axes = fig.get_axes()
        ax0 = axes[0] if len(axes) > 0 else None
        _dynamic_test(
            self,
            ax0 is not None,
            "First subplot exists.",
            "First subplot does not exist."
        )
        if ax0:
            bars = [rect.get_height() for rect in ax0.patches]
            _dynamic_test(
                self,
                bars == sales,
                "First subplot displays correct sales bar heights.",
                f"Expected sales bars {sales}, got {bars}."
            )
            labels = [tick.get_text() for tick in ax0.get_xticklabels()]
            # xticklabels may be empty if not rendered, so fallback to tick labels
            if not any(labels):
                labels = [tick.get_text() for tick in ax0.get_xticklabels(minor=False)]
            _dynamic_test(
                self,
                all(p in labels for p in products),
                "First subplot uses correct product labels.",
                f"Product labels for sales subplot incorrect: {labels}"
            )
            _dynamic_test(
                self,
                ax0.get_title() == 'Sales by Product',
                "First subplot has correct title.",
                f"First subplot title is '{ax0.get_title()}'; expected 'Sales by Product'."
            )
            _dynamic_test(
                self,
                ax0.get_xlabel() == 'Product',
                "First subplot has correct x-axis label.",
                f"Expected x-axis label 'Product', got '{ax0.get_xlabel()}'."
            )
            _dynamic_test(
                self,
                ax0.get_ylabel() == 'Sales',
                "First subplot has correct y-axis label.",
                f"Expected y-axis label 'Sales', got '{ax0.get_ylabel()}'."
            )

    def test_profit_subplot_bar_chart(self):
        import user_code
        plt.close('all')
        sales = [50, 60, 70]
        profits = [5, 6, 7]
        products = ['P', 'Q', 'R']
        user_code.compare_sales_profit(sales, profits, products)
        fig = plt.gcf()
        axes = fig.get_axes()
        ax1 = axes[1] if len(axes) > 1 else None
        _dynamic_test(
            self,
            ax1 is not None,
            "Second subplot exists.",
            "Second subplot does not exist."
        )
        if ax1:
            bars = [rect.get_height() for rect in ax1.patches]
            _dynamic_test(
                self,
                bars == profits,
                "Second subplot displays correct profit bar heights.",
                f"Expected profit bars {profits}, got {bars}."
            )
            labels = [tick.get_text() for tick in ax1.get_xticklabels()]
            if not any(labels):
                labels = [tick.get_text() for tick in ax1.get_xticklabels(minor=False)]
            _dynamic_test(
                self,
                all(p in labels for p in products),
                "Second subplot uses correct product labels.",
                f"Product labels for profit subplot incorrect: {labels}"
            )
            _dynamic_test(
                self,
                ax1.get_title() == 'Profit by Product',
                "Second subplot has correct title.",
                f"Second subplot title is '{ax1.get_title()}'; expected 'Profit by Product'."
            )
            _dynamic_test(
                self,
                ax1.get_xlabel() == 'Product',
                "Second subplot has correct x-axis label.",
                f"Expected x-axis label 'Product', got '{ax1.get_xlabel()}'."
            )
            _dynamic_test(
                self,
                ax1.get_ylabel() == 'Profit',
                "Second subplot has correct y-axis label.",
                f"Expected y-axis label 'Profit', got '{ax1.get_ylabel()}'."
            )

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: Compare Sales and Profit

Oplossing