In product management, automating the creation of weekly reports saves time, reduces manual errors, and ensures stakeholders receive consistent updates. When generating such reports, follow best practices: organize your metrics clearly, use meaningful labels, and format the output for easy reading. Summarizing key data points like **Daily Active Users (DAU)**, **churn rate**, and **feature usage** gives your team a quick snapshot of product health and engagement. Python makes this process straightforward by allowing you to calculate summaries and print well-formatted reports with minimal code.

# Hardcoded weekly metrics
weekly_metrics = {
    "DAU": [120, 135, 140, 125, 150, 160, 155],
    "churn_rate": [0.02, 0.025, 0.018, 0.022, 0.019, 0.021, 0.02],
    "feature_A_usage": [50, 60, 55, 53, 65, 70, 68]
}

# Summarize metrics
average_dau = sum(weekly_metrics["DAU"]) / len(weekly_metrics["DAU"])
average_churn = sum(weekly_metrics["churn_rate"]) / len(weekly_metrics["churn_rate"])
total_feature_a_usage = sum(weekly_metrics["feature_A_usage"])

# Format and print report
report = (
    "Weekly Product Metrics Report\n"
    "----------------------------\n"
    f"Average DAU: {average_dau:.1f}\n"
    f"Average Churn Rate: {average_churn:.2%}\n"
    f"Total Feature A Usage: {total_feature_a_usage}\n"
)

print(report)


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_average_dau_in_report(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.create_weekly_report(user_code.metrics)
        expected_avg = sum(user_code.metrics["DAU"]) / len(user_code.metrics["DAU"])
        _dynamic_test(
            self,
            report is not None and f"Average DAU: {expected_avg:.1f}" in report,
            "Report includes correct average DAU to one decimal place",
            f"Expected 'Average DAU: {expected_avg:.1f}' in report, got: {report}"
        )

    def test_average_churn_in_report(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.create_weekly_report(user_code.metrics)
        expected_avg = sum(user_code.metrics["churn"]) / len(user_code.metrics["churn"])
        _dynamic_test(
            self,
            report is not None and f"Average Churn Rate: {expected_avg:.2%}" in report,
            "Report includes correct average churn rate as percent with two decimals",
            f"Expected 'Average Churn Rate: {expected_avg:.2%}' in report, got: {report}"
        )

    def test_total_feature_b_usage_in_report(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.create_weekly_report(user_code.metrics)
        expected_total = sum(user_code.metrics["feature_B_usage"])
        _dynamic_test(
            self,
            report is not None and f"Total Feature B Usage: {expected_total}" in report,
            "Report includes correct total Feature B usage as integer",
            f"Expected 'Total Feature B Usage: {expected_total}' in report, got: {report}"
        )

    def test_required_labels_present(self):
        import user_code
        importlib.reload(user_code)
        report = user_code.create_weekly_report(user_code.metrics)
        _dynamic_test(
            self,
            report is not None and all(label in report for label in ["Average DAU:", "Average Churn Rate:", "Total Feature B Usage:"] ),
            "Report includes all required labeled lines",
            f"Report missing one or more required labels: {report}"
        )

    def test_correct_keys_used(self):
        import user_code
        importlib.reload(user_code)
        # change keys and expect function to break or return None
        wrong_metrics = {
            "DAU_WRONG": [1, 2, 3],
            "churn_WRONG": [0.1, 0.2, 0.3],
            "feature_B_usage_WRONG": [4, 5, 6]
        }
        try:
            report = user_code.create_weekly_report(wrong_metrics)
        except Exception:
            report = None
        _dynamic_test(
            self,
            report is None or not isinstance(report, str) or ("Average DAU:" not in report and "Average Churn Rate:" not in report and "Total Feature B Usage:" not in report),
            "Function uses only correct keys from metrics dictionary",
            f"Function should not work with incorrect metric keys, got: {report}"
        )

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: Automate a Product Report

Oplossing