As a product manager, you often need to present a snapshot of key product metrics—such as **feature adoption rates**, **churn**, and **daily active users (DAU)**—in a clear, visual format. Python, combined with the `matplotlib` library, enables you to quickly generate summary charts that can be embedded in reports or shared with stakeholders. Recapping what you have learned so far, visualizing multiple metrics in a single chart helps you compare trends at a glance and communicate results effectively. Saving these charts as image files ensures you have ready-to-use visuals for product documentation or presentations.

import matplotlib.pyplot as plt

# Hardcoded product metrics
metrics = {
    "Feature Adoption Rate": 0.67,
    "Churn Rate": 0.13,
    "DAU": 3200
}

# Prepare data for the bar chart
labels = list(metrics.keys())
values = list(metrics.values())

# Create the bar chart
plt.figure(figsize=(8, 5))
bars = plt.bar(labels, values, color=['skyblue', 'salmon', 'lightgreen'])

# Add labels and title
plt.ylabel("Value")
plt.title("Product Metrics Overview")

# Add value labels above bars
for bar in bars:
    height = bar.get_height()
    plt.annotate(f"{height}", xy=(bar.get_x() + bar.get_width() / 2, height),
                 xytext=(0, 3), textcoords="offset points", ha='center', va='bottom')

# Save the chart as an image file
plt.tight_layout()
plt.savefig("product_metrics_overview.png")
plt.close()


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import os
from PIL import Image
import matplotlib
matplotlib.use('Agg')

class TestTask(unittest.TestCase):
    def setUp(self):
        # Remove the file if it exists before running tests
        self.img_file = "summary_product_metrics.png"
        if os.path.exists(self.img_file):
            os.remove(self.img_file)

    def tearDown(self):
        # Clean up the image file after test
        if os.path.exists(self.img_file):
            os.remove(self.img_file)

    def test_chart_file_created(self):
        import user_code
        importlib.reload(user_code)
        _dynamic_test(
            self,
            os.path.exists(self.img_file),
            "Image file 'summary_product_metrics.png' was created.",
            "Image file 'summary_product_metrics.png' was not created."
        )

    def test_chart_file_is_image(self):
        import user_code
        importlib.reload(user_code)
        if not os.path.exists(self.img_file):
            self.fail("Image file 'summary_product_metrics.png' was not created.")
        try:
            img = Image.open(self.img_file)
            img.verify()
            _dynamic_test(
                self,
                True,
                "Image file is a valid PNG image.",
                "Image file is not a valid PNG image."
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "Image file is a valid PNG image.",
                f"Image file is not a valid PNG image: {e}"
            )

    def test_function_creates_chart_with_three_bars(self):
        # Patch plt.savefig to intercept and analyze the figure
        import user_code
        import matplotlib.pyplot as plt
        import types
        img_path = self.img_file
        metrics = {
            "Feature Adoption Rate": 0.72,
            "Churn Rate": 0.09,
            "DAU": 4100
        }
        # Remove file if exists
        if os.path.exists(img_path):
            os.remove(img_path)
        # Call the function directly
        user_code.visualize_and_save_metrics(metrics)
        _dynamic_test(
            self,
            os.path.exists(img_path),
            "Function saves the chart as 'summary_product_metrics.png'.",
            "Function did not save the chart as 'summary_product_metrics.png'."
        )

    def test_function_works_with_different_metrics(self):
        import user_code
        import os
        img_path = self.img_file
        metrics = {
            "Feature Adoption Rate": 0.55,
            "Churn Rate": 0.12,
            "DAU": 5000
        }
        if os.path.exists(img_path):
            os.remove(img_path)
        user_code.visualize_and_save_metrics(metrics)
        _dynamic_test(
            self,
            os.path.exists(img_path),
            "Function works with different values for metrics.",
            "Function did not create image file with different metrics."
        )

    def test_function_signature(self):
        import user_code
        func = getattr(user_code, 'visualize_and_save_metrics', None)
        _dynamic_test(
            self,
            callable(func),
            "visualize_and_save_metrics is defined as a function.",
            "visualize_and_save_metrics is not defined as a function."
        )

    def test_function_does_not_return_anything(self):
        import user_code
        importlib.reload(user_code)
        metrics = {
            "Feature Adoption Rate": 0.72,
            "Churn Rate": 0.09,
            "DAU": 4100
        }
        result = user_code.visualize_and_save_metrics(metrics)
        _dynamic_test(
            self,
            result is None,
            "Function does not return any value.",
            f"Function should not return anything, 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

A hands-on course designed for Product Managers to leverage Python for data-driven decision making, product analytics, and business insights. Learn how to use Python to analyze product metrics, visualize trends, and automate reporting, all without prior data science experience.

Learn how to use Python to explore, summarize, and interpret key product metrics. This section focuses on understanding user data, product usage, and basic analytics relevant to product management.

Explore how Python can be used to design, analyze, and interpret product experiments, including A/B testing and hypothesis validation.

Master Python techniques to automate repetitive product management tasks, generate reports, and streamline product operations.

Challenge: Visualize Automated Metrics

解答