Summary  
This chapter explains how to group tabular data by multiple dimensions using pandas’ groupby and perform aggregations such as counts and averages to uncover deeper patterns.  

General domain of usage  
Marketing analytics

This video introduces multi-dimensional cohort segmentation, explaining how you can analyze user behavior across more than one attribute—such as combining signup month with acquisition channel or geography. You'll see why adding extra dimensions uncovers deeper business insights, and you'll walk through a practical example using Python and pandas to segment users by both when they signed up and how they were acquired. Real-world cases show how companies use this approach to discover patterns that single-dimensional analysis might miss. Each code sample in video should include no more than 10 lines of code.

Multidimensionell kohortsegmentering gör det möjligt att gruppera användare efter mer än en attribut, såsom både månaden de registrerade sig och kanalen genom vilken de förvärvades. Medan traditionell kohortanalys kan fokusera på en enskild faktor – som registreringsdatum – hjälper multidimensionell segmentering dig att besvara mer komplexa frågor. Till exempel kan du se om användare från en specifik marknadsföringskampanj under en viss månad beter sig annorlunda än de från en annan kanal eller region. Detta tillvägagångssätt är värdefullt för företag eftersom det lyfter fram mönster och trender som inte är synliga vid analys av endast en dimension. Genom att segmentera kohorter med flera faktorer kan du anpassa marknadsföringsstrategier, förbättra kundlojalitet och fördela resurser mer effektivt.

import pandas as pd

# Sample data
data = {
    "user_id": [1, 2, 3, 4, 5, 6],
    "signup_date": [
        "2023-01-15", "2023-01-15", "2023-02-10",
        "2023-02-15", "2023-01-25", "2023-02-18"
    ],
    "acquisition_channel": [
        "Email", "Email", "Social", "Ad", "Ad", "Social"
    ]
}

df = pd.DataFrame(data)
df["signup_month"] = pd.to_datetime(df["signup_date"]).dt.to_period("M")

# Multi-dimensional cohort segmentation by signup_month and acquisition_channel
cohorts = df.groupby(["signup_month", "acquisition_channel"])["user_id"].nunique().reset_index()
cohorts = cohorts.rename(columns={"user_id": "num_users"})

print(cohorts)

Genom att segmentera kohorter med både `signup_month` och `acquisition_channel` kan du upptäcka dolda trender som en endimensionell analys kan missa. Du kan till exempel finna att användare som förvärvats via **"Email"** i januari är mer engagerade eller har högre kvarhållning än de som förvärvats via **"Ad"** under samma månad. Denna detaljnivå gör det möjligt att fatta datadrivna beslut om var marknadsföringsbudgeten ska investeras, hur onboardingupplevelser kan personaliseras och vilka kanaler som ger de mest värdefulla kunderna. **Multidimensionell segmentering** är ett kraftfullt verktyg för att upptäcka insikter som driver affärstillväxt.


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.expected = pd.DataFrame({
            'signup_month': [pd.Period('2023-01'), pd.Period('2023-01'), pd.Period('2023-01'), pd.Period('2023-02'), pd.Period('2023-02'), pd.Period('2023-02')],
            'acquisition_channel': ['Ad', 'Email', 'Social', 'Ad', 'Email', 'Social'],
            'num_users': [1, 1, 1, 1, 1, 1]
        })
        # Sort for comparison
        self.expected = self.expected.sort_values(['signup_month', 'acquisition_channel']).reset_index(drop=True)

    def test_cohorts_exists_and_type(self):
        import user_code
        importlib.reload(user_code)
        cohorts = getattr(user_code, 'cohorts', None)
        _dynamic_test(
            self,
            cohorts is not None and isinstance(cohorts, pd.DataFrame),
            "The 'cohorts' DataFrame exists and is a pandas DataFrame.",
            "The 'cohorts' DataFrame is missing or not a pandas DataFrame."
        )

    def test_cohorts_columns(self):
        import user_code
        importlib.reload(user_code)
        cohorts = getattr(user_code, 'cohorts', None)
        expected_cols = ['signup_month', 'acquisition_channel', 'num_users']
        _dynamic_test(
            self,
            cohorts is not None and list(cohorts.columns) == expected_cols,
            f"The 'cohorts' DataFrame has correct columns: {expected_cols}.",
            f"The 'cohorts' DataFrame columns are incorrect. Got: {list(cohorts.columns)}"
        )

    def test_cohorts_values(self):
        import user_code
        importlib.reload(user_code)
        cohorts = getattr(user_code, 'cohorts', None)
        # Sort both DataFrames for comparison
        if cohorts is not None:
            cohorts_sorted = cohorts.sort_values(['signup_month', 'acquisition_channel']).reset_index(drop=True)
            # Compare values
            same_shape = cohorts_sorted.shape == self.expected.shape
            same_cols = list(cohorts_sorted.columns) == list(self.expected.columns)
            same_values = cohorts_sorted.equals(self.expected)
            _dynamic_test(
                self,
                same_shape and same_cols and same_values,
                "The 'cohorts' DataFrame has the correct grouped values.",
                f"The grouped values in 'cohorts' are incorrect.\\nExpected:\\n{self.expected}\\nGot:\\n{cohorts_sorted}"
            )
        else:
            _dynamic_test(
                self,
                False,
                "The 'cohorts' DataFrame has the correct grouped values.",
                "The 'cohorts' DataFrame is missing."
            )

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

Behärska kohortanalystekniker med Python. Denna kurs täcker strukturering av kohortdata, avancerad segmentering, retentionsanalys och handlingsbara affärsinsikter, med praktiska utmaningar i varje avsnitt.

Lär dig hur du strukturerar, förbehandlar och förbereder data för avancerad kohortanalys, inklusive kohorttilldelning och feature engineering.

Fördjupa dig i avancerade segmenteringsstrategier och beräkningar av retentionsmått för att upptäcka djupare insikter från kohortdata.

Visualisera kohortdata och extrahera handlingsbara affärsinsikter med hjälp av avancerade plottningstekniker och tolkning.

Multidimensionell Kohortsegmentering

Lösning