In growth hacking, understanding how users engage with your product is crucial for tailoring marketing strategies. Segmenting users based on their activity helps you identify who is highly engaged, who might need a nudge, and who has stopped interacting altogether. You will now create a script to automate this segmentation process using **Python** and `pandas`. The goal is to write a function that categorizes users into three segments based on their activity counts: `active` for those with 10 or more activities, `dormant` for those with 1 to 9, and `churned` for those with zero activity. This approach lets you quickly spot trends and target users with the right messaging.

import pandas as pd

def segment_users():
    # Hardcoded user activity data
    data = {
        "user_id": ["u1", "u2", "u3", "u4", "u5", "u6"],
        "activity_count": [12, 0, 7, 3, 0, 15]
    }
    df = pd.DataFrame(data)
    
    # Function to assign segment
    def assign_segment(activity):
        if activity >= 10:
            return "active"
        elif activity >= 1:
            return "dormant"
        else:
            return "churned"
    
    df["segment"] = df["activity_count"].apply(assign_segment)
    return df[["user_id", "segment"]]

# Run the function and display the result
segmented_df = segment_users()
print(segmented_df)

This script uses a hardcoded DataFrame to simulate real user data. Each user is assigned a segment based on their activity count. The segmentation logic is handled by the `assign_segment` function, which is applied to each user's activity value. The resulting DataFrame gives you a clear view of which users are **"active"**, **"dormant"**, or **"churned"**, making it easier to plan your next growth move.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")

    def test_function_exists(self):
        segment_func = getattr(self.user_code, "segment_users", None)
        _dynamic_test(
            self,
            callable(segment_func),
            "Function 'segment_users' is defined.",
            "Function 'segment_users' is not defined.",
        )

    def test_result_is_dataframe(self):
        result = self.user_code.segment_users()
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "Returned object is a pandas DataFrame.",
            f"Expected a pandas DataFrame, got {type(result)}.",
        )

    def test_columns(self):
        result = self.user_code.segment_users()
        expected_cols = ["user_id", "segment"]
        _dynamic_test(
            self,
            list(result.columns) == expected_cols,
            "DataFrame columns are correct.",
            f"Expected columns {expected_cols}, got {list(result.columns)}.",
        )

    def test_segments_present(self):
        result = self.user_code.segment_users()
        segments = set(result["segment"].unique())
        required_segments = {"active", "dormant", "churned"}
        _dynamic_test(
            self,
            required_segments.issubset(segments),
            "All required segments are present.",
            f"Missing segment(s): {required_segments - segments}.",
        )

    def test_segment_logic(self):
        result = self.user_code.segment_users()
        # Check at least one user with each segment
        found_active = any((row["segment"] == "active") and (row["user_id"]) for _, row in result.iterrows())
        found_dormant = any((row["segment"] == "dormant") and (row["user_id"]) for _, row in result.iterrows())
        found_churned = any((row["segment"] == "churned") and (row["user_id"]) for _, row in result.iterrows())
        _dynamic_test(
            self,
            found_active and found_dormant and found_churned,
            "DataFrame includes at least one user from each segment.",
            "Missing at least one segment in the DataFrame.",
        )

    def test_segment_assignment(self):
        result = self.user_code.segment_users()
        # Create a mapping from user_id to segment for expected data
        expected = {
            "user1": "churned",
            "user2": "dormant",
            "user3": "active",
            "user4": "dormant",
            "user5": "dormant"
        }
        for user_id, segment in expected.items():
            user_row = result[result["user_id"] == user_id]
            exists = not user_row.empty
            correct = exists and user_row.iloc[0]["segment"] == segment
            _dynamic_test(
                self,
                correct,
                f"User {user_id} correctly assigned to segment '{segment}'.",
                f"User {user_id} not correctly assigned to segment '{segment}'.",
            )

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

Unlock the power of Python to automate, analyze, and optimize growth strategies. This course is designed for growth hackers who want to leverage Python for data-driven marketing, user acquisition, and rapid experimentation. Learn to automate repetitive tasks, analyze user behavior, and extract actionable insights—all without prior data science experience.

Learn how to use Python to automate repetitive growth hacking tasks, from data cleaning to campaign reporting.

Use Python to analyze user engagement, retention, and behavior patterns to inform growth strategies.

Apply Python to design, analyze, and optimize growth experiments such as A/B tests and campaign performance evaluations.

Challenge: User Segmentation Script

Lösung