Clear visualizations are essential for helping stakeholders quickly understand business performance. By transforming raw data into well-designed charts, you enable decision-makers to instantly spot trends, compare product results, and identify opportunities or issues. A good chart can reveal insights at a glance, making complex information accessible and actionable for everyone in your organization.


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
import sys

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show to prevent window popup
        self._original_show = plt.show
        plt.show = lambda *a, **kw: None

    def tearDown(self):
        plt.show = self._original_show
        plt.close('all')

    def test_bars_and_labels(self):
        import user_code
        importlib.reload(user_code)
        summary_dict = {"Widget": 15000, "Gadget": 12000, "Doohickey": 9000}

        plt.close('all')
        user_code.plot_sales_performance(summary_dict)
        fig = plt.gcf()
        ax = fig.axes[0] if fig.axes else None
        _dynamic_test(
            self,
            ax is not None,
            "Figure and axes created.",
            "No axes found in figure.",
        )
        bars = [rect for rect in ax.patches if rect.get_width() > 0]
        _dynamic_test(
            self,
            len(bars) == len(summary_dict),
            f"Chart displays {len(summary_dict)} bars.",
            f"Expected {len(summary_dict)} bars, found {len(bars)}.",
        )
        xlabels = [tick.get_text() for tick in ax.get_xticklabels()]
        for prod in summary_dict:
            _dynamic_test(
                self,
                prod in xlabels,
                f"Product '{prod}' is shown on x-axis.",
                f"Product '{prod}' not found in x-axis labels: {xlabels}",
            )
        ylabel = ax.get_ylabel()
        _dynamic_test(
            self,
            ylabel and ("revenue" in ylabel.lower()),
            f"Y-axis labeled for revenue.",
            f"Y-axis label missing or incorrect: '{ylabel}'",
        )
        title = ax.get_title()
        _dynamic_test(
            self,
            title and ("sales" in title.lower()),
            f"Chart includes a title.",
            f"Chart title missing or incorrect: '{title}'",
        )
        # Check for value labels above bars
        found_labels = [t.get_text() for t in ax.texts if t.get_text().isdigit()]
        for revenue in summary_dict.values():
            _dynamic_test(
                self,
                str(revenue) in found_labels,
                f"Revenue value label '{revenue}' displayed above bar.",
                f"Revenue value label '{revenue}' not found among: {found_labels}",
            )

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: Visualize Sales Performance

Solution