As an operations manager, you have learned how to use **pandas** to organize and analyze your operational data, and **matplotlib** to visualize key metrics for better decision making. In this challenge, you will apply these skills to a typical scenario: analyzing a week's worth of sales data to extract actionable insights. By leveraging `pandas` for data aggregation and `matplotlib` for visualization, you can quickly summarize performance, identify top-selling products, and communicate findings clearly to your team.

import pandas as pd

# Example DataFrame for a week's sales
data = {
    'day': ['Mon', 'Mon', 'Tue', 'Tue', 'Wed', 'Wed', 'Thu', 'Thu', 'Fri', 'Fri', 'Sat', 'Sat', 'Sun', 'Sun'],
    'item': ['Widget', 'Gadget', 'Widget', 'Gadget', 'Widget', 'Gadget', 'Widget', 'Gadget', 'Widget', 'Gadget', 'Widget', 'Gadget', 'Widget', 'Gadget'],
    'units_sold': [10, 5, 12, 8, 7, 6, 15, 9, 14, 7, 13, 8, 11, 6],
    'revenue': [100, 75, 120, 120, 70, 90, 150, 135, 140, 105, 130, 120, 110, 90]
}
df = pd.DataFrame(data)

# Example summary calculations
total_revenue = df['revenue'].sum()
best_selling_item = df.groupby('item')['units_sold'].sum().idxmax()

print(f"Weekly Sales Summary")
print(f"---------------------")
print(f"Total Revenue: ${total_revenue}")
print(f"Best-Selling Item: {best_selling_item}")

When working with sales data for operational decisions, it is important to aggregate key metrics such as **total revenue** and **units sold by item**. Using `pandas`, you can easily group and sum data to pinpoint **top performers**. Visualizations like **bar charts** created with `matplotlib` make it easier to spot trends and communicate results to stakeholders. Always ensure your summary reports are **clear**, **concise**, and tailored to the needs of your audience.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = user_code.df.copy()

    def test_total_revenue(self):
        # Patch print to capture output
        buffer = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = buffer
        plt.close('all')
        importlib.reload(user_code)
        user_code.analyze_weekly_sales(self.df)
        sys.stdout = sys_stdout
        output = buffer.getvalue()
        expected_revenue = self.df['revenue'].sum()
        _dynamic_test(
            self,
            f"Total Revenue: ${expected_revenue}" in output,
            "Correct total revenue is printed in the summary report",
            f"Total revenue line not found or incorrect in output: {output}",
        )

    def test_best_selling_item(self):
        buffer = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = buffer
        plt.close('all')
        importlib.reload(user_code)
        user_code.analyze_weekly_sales(self.df)
        sys.stdout = sys_stdout
        output = buffer.getvalue()
        best_item = self.df.groupby('item')['units_sold'].sum().idxmax()
        _dynamic_test(
            self,
            f"Best-Selling Item: {best_item}" in output,
            "Correct best-selling item is printed in the summary report",
            f"Best-selling item line not found or incorrect in output: {output}",
        )

    def test_bar_chart_units_sold(self):
        # Patch plt.show to test if bar chart is plotted
        called = {'show': False, 'kind': None, 'xlabels': None, 'ylabels': None, 'title': None}
        orig_show = plt.show
        orig_plot = plt.Axes.bar
        orig_title = plt.Axes.set_title
        orig_xlabel = plt.Axes.set_xlabel
        orig_ylabel = plt.Axes.set_ylabel
        def fake_show(*args, **kwargs):
            called['show'] = True
        plt.show = fake_show
        # We'll check if a bar plot is created by intercepting plt.Axes.bar
        def fake_title(self, title, *args, **kwargs):
            called['title'] = title
            return orig_title(self, title, *args, **kwargs)
        def fake_xlabel(self, label, *args, **kwargs):
            called['xlabels'] = label
            return orig_xlabel(self, label, *args, **kwargs)
        def fake_ylabel(self, label, *args, **kwargs):
            called['ylabels'] = label
            return orig_ylabel(self, label, *args, **kwargs)
        plt.Axes.set_title = fake_title
        plt.Axes.set_xlabel = fake_xlabel
        plt.Axes.set_ylabel = fake_ylabel
        importlib.reload(user_code)
        user_code.analyze_weekly_sales(self.df)
        plt.show = orig_show
        plt.Axes.set_title = orig_title
        plt.Axes.set_xlabel = orig_xlabel
        plt.Axes.set_ylabel = orig_ylabel
        _dynamic_test(
            self,
            called['show'] and called['title'] is not None and 'Units Sold' in called['ylabels'] and 'Item' in called['xlabels'],
            "Bar chart of units sold per item is plotted with correct labels and title",
            "Bar chart was not shown, or axis labels/title are not set correctly.",
        )

    def test_summary_report_format(self):
        buffer = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = buffer
        plt.close('all')
        importlib.reload(user_code)
        user_code.analyze_weekly_sales(self.df)
        sys.stdout = sys_stdout
        output = buffer.getvalue()
        _dynamic_test(
            self,
            "Weekly Sales Summary" in output and "Total Revenue:" in output and "Best-Selling Item:" in output,
            "Summary report contains required headings and lines",
            f"Summary report format is missing required lines: {output}",
        )

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

This course empowers operations managers to leverage Python for streamlining workflows, analyzing operational data, and making data-driven decisions. Through practical examples and real-world challenges, you'll learn how to automate repetitive tasks, visualize key metrics, and optimize processes using Python's powerful libraries.

Learn how to use Python to automate repetitive tasks, streamline data handling, and improve efficiency in daily operations management.

Master the use of Python for analyzing operational data, identifying trends, and supporting data-driven decision-making.

Apply Python to solve classic operations management problems such as process optimization, demand forecasting, and resource allocation.

Challenge: Analyze Weekly Sales Data

解答