Daily Active Users (DAU) and churn rate are two essential metrics for any product manager tracking user engagement and retention. **DAU** indicates the number of unique users interacting with your product each day, providing a snapshot of daily engagement. A higher DAU often signals a healthy, active user base. **Churn rate**, on the other hand, measures the percentage of users who stop using your product over a certain period. Monitoring churn helps you understand retention challenges and identify when users are leaving, which is crucial for improving your product and maintaining growth.

# Example of printing formatted product metrics

average_dau = 2450
churn_rate = 0.08

print(f"Product Metrics Report")
print(f"----------------------")
print(f"Average DAU for the month: {average_dau}")
print(f"Churn Rate: {churn_rate:.2%}")


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_calculation(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_and_print_metrics([
                1000, 2000, 3000, 4000
            ], [0, 1, 0, 1])
        output = normalize_text(f.getvalue())
        expected_dau = 2500  # (1000+2000+3000+4000)/4
        _dynamic_test(
            self,
            f"average dau for the month: {expected_dau}" in output,
            f"Correctly prints average DAU as {expected_dau}",
            f"Expected average DAU {expected_dau} in output, got: {output}",
        )

    def test_churn_rate_calculation(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_and_print_metrics([10, 10, 10, 10], [1, 0, 1, 0])
        output = normalize_text(f.getvalue())
        expected_churn = "churn rate: 50.00%"
        _dynamic_test(
            self,
            expected_churn in output,
            "Correctly prints churn rate as 50.00%",
            f"Expected churn rate '50.00%' in output, got: {output}",
        )

    def test_report_labels_and_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.calculate_and_print_metrics([100, 100], [0, 0])
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "product metrics report" in output and "average dau for the month" in output and "churn rate" in output,
            "Report contains all required labels",
            f"Missing required labels in output: {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

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: Calculate Key Metrics

解答