Segmenting users by their activity levels is a powerful way to interpret product engagement and tailor strategies for different user groups. By grouping users into categories such as **"high"**, **"medium"**, and **"low"** activity, you can quickly assess which segments are most engaged, spot opportunities for growth, and present clear, actionable insights on a product dashboard. This approach helps you prioritize feature development, retention efforts, and marketing strategies by focusing on the needs of each segment.

# Example: Categorizing users by session activity

user_activity = [
    {"user_id": 1, "sessions": 22},
    {"user_id": 2, "sessions": 5},
    {"user_id": 3, "sessions": 12},
    {"user_id": 4, "sessions": 30},
    {"user_id": 5, "sessions": 8},
]

def categorize_user(sessions):
    if sessions >= 20:
        return "high"
    elif sessions >= 10:
        return "medium"
    else:
        return "low"

for user in user_activity:
    segment = categorize_user(user["sessions"])
    print(f"User {user['user_id']} is in the '{segment}' activity group.")


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_returns_dict_with_keys(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.segment_users([])
        _dynamic_test(
            self,
            isinstance(result, dict) and all(k in result for k in ["high", "medium", "low"]),
            "Returns dictionary with all required keys.",
            f"Returned keys: {list(result.keys()) if isinstance(result, dict) else type(result)}"
        )

    def test_high_group_count(self):
        import user_code
        importlib.reload(user_code)
        logs = [
            {"user_id": 1, "sessions": 20},
            {"user_id": 2, "sessions": 21},
            {"user_id": 3, "sessions": 19}
        ]
        result = user_code.segment_users(logs)
        _dynamic_test(
            self,
            result is not None and result.get("high", -1) == 2,
            "Correctly counts high activity users.",
            f"Expected 2 high, got {result.get('high', None) if result else None}"
        )

    def test_medium_group_count(self):
        import user_code
        importlib.reload(user_code)
        logs = [
            {"user_id": 1, "sessions": 10},
            {"user_id": 2, "sessions": 19},
            {"user_id": 3, "sessions": 20}
        ]
        result = user_code.segment_users(logs)
        _dynamic_test(
            self,
            result is not None and result.get("medium", -1) == 2,
            "Correctly counts medium activity users.",
            f"Expected 2 medium, got {result.get('medium', None) if result else None}"
        )

    def test_low_group_count(self):
        import user_code
        importlib.reload(user_code)
        logs = [
            {"user_id": 1, "sessions": 0},
            {"user_id": 2, "sessions": 9},
            {"user_id": 3, "sessions": 10}
        ]
        result = user_code.segment_users(logs)
        _dynamic_test(
            self,
            result is not None and result.get("low", -1) == 2,
            "Correctly counts low activity users.",
            f"Expected 2 low, got {result.get('low', None) if result else None}"
        )

    def test_empty_input(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.segment_users([])
        _dynamic_test(
            self,
            result is not None and result.get("high", -1) == 0 and result.get("medium", -1) == 0 and result.get("low", -1) == 0,
            "Handles empty input with zero counts.",
            f"Expected all counts zero, got {result if result else None}"
        )

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: Segment Users by Activity

Lösung