As you continue to automate your product management workflows, understanding and communicating **feature adoption metrics** becomes increasingly important. **Feature adoption** refers to how many users are actually using a specific feature within your product. This metric helps you identify which features are gaining traction and which may need further promotion or improvement. When reporting these metrics, especially in a product update email, it's crucial to present the data clearly and concisely so that stakeholders can quickly grasp the impact and make informed decisions.

# Sample user data: each user has a list of features they've used
user_data = [
    {"user_id": 1, "features": ["Search", "Export", "Dashboard"]},
    {"user_id": 2, "features": ["Search", "Dashboard"]},
    {"user_id": 3, "features": ["Export"]},
    {"user_id": 4, "features": ["Search", "Export"]},
    {"user_id": 5, "features": ["Dashboard"]},
]

# Count the number of users for each feature
feature_counts = {}
for user in user_data:
    for feature in user["features"]:
        feature_counts[feature] = feature_counts.get(feature, 0) + 1

total_users = len(user_data)

# Calculate adoption rate for each feature
feature_adoption = {}
for feature, count in feature_counts.items():
    adoption_rate = count / total_users
    feature_adoption[feature] = adoption_rate

# Format results for a product update email
for feature, rate in feature_adoption.items():
    percent = round(rate * 100, 1)
    print(f"Feature '{feature}': {feature_counts[feature]} users ({percent}% adoption)")

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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_data = [
            {"user_id": 101, "features": ["Chat", "Notifications", "Analytics"]},
            {"user_id": 102, "features": ["Chat", "Analytics"]},
            {"user_id": 103, "features": ["Notifications"]},
            {"user_id": 104, "features": ["Chat", "Notifications"]},
            {"user_id": 105, "features": ["Analytics"]},
            {"user_id": 106, "features": ["Chat"]},
        ]

    def test_feature_counts(self):
        import user_code
        importlib.reload(user_code)
        # We'll inspect the printed output to check counts
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.report_feature_adoption(self.user_data)
        output = f.getvalue()
        normalized = normalize_text(output)
        # Check for correct counts in output
        expected_counts = {"chat": 4, "notifications": 3, "analytics": 3}
        for feature, count in expected_counts.items():
            pattern = rf"feature '{feature}': {count} users"
            _dynamic_test(
                self,
                re.search(pattern, normalized) is not None,
                f"Output includes correct user count for '{feature}'",
                f"Expected count for '{feature}' not found in output: {normalized}"
            )

    def test_adoption_rates(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.report_feature_adoption(self.user_data)
        output = f.getvalue()
        normalized = normalize_text(output)
        total_users = 6
        expected_rates = {"chat": 66.7, "notifications": 50.0, "analytics": 50.0}
        for feature, percent in expected_rates.items():
            pattern = rf"feature '{feature}': [0-9]+ users \\({percent}% adoption\\)"
            _dynamic_test(
                self,
                re.search(pattern, normalized) is not None,
                f"Output includes correct adoption rate for '{feature}'",
                f"Expected adoption rate for '{feature}' not found in output: {normalized}"
            )

    def test_printed_format_and_content(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.report_feature_adoption(self.user_data)
        output = f.getvalue()
        normalized = normalize_text(output)
        lines = normalized.strip().split('\\n')
        features = {"chat": 4, "notifications": 3, "analytics": 3}
        total_users = 6
        expected_lines = []
        for feature, count in features.items():
            percent = round(count / total_users * 100, 1)
            expected_lines.append(f"feature '{feature}': {count} users ({percent}% adoption)")
        # Check that all expected lines are present
        for expected in expected_lines:
            _dynamic_test(
                self,
                expected in lines,
                f"Output includes line: {expected}",
                f"Expected output: '{expected}' not found in: {lines}"
            )
        # Should be exactly three lines
        _dynamic_test(
            self,
            len(lines) == 3,
            "Three features reported in output.",
            f"Expected 3 output lines, got {len(lines)}: {lines}"
        )

    def test_handles_all_features(self):
        import user_code
        importlib.reload(user_code)
        # Add a new feature to user_data
        test_data = self.user_data + [{"user_id": 107, "features": ["Reports"]}]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.report_feature_adoption(test_data)
        output = f.getvalue()
        normalized = normalize_text(output)
        # Should include the new feature
        _dynamic_test(
            self,
            "feature 'reports': 1 users (14.3% adoption)" in normalized,
            "Handles new feature 'Reports' correctly.",
            f"Expected output for new feature missing: {normalized}"
        )

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: Track Feature Adoption

Solução