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.

Multi-dimensjonal kohortsegmentering lar deg gruppere brukere etter mer enn én egenskap, for eksempel både måneden de registrerte seg og kanalen de ble anskaffet gjennom. Mens tradisjonell kohortanalyse ofte fokuserer på én enkelt faktor – som registreringsdato – hjelper multi-dimensjonal segmentering deg med å besvare mer komplekse spørsmål. For eksempel kan du undersøke om brukere fra en bestemt markedsføringskampanje i en gitt måned oppfører seg annerledes enn de fra en annen kanal eller region. Denne tilnærmingen er verdifull for virksomheter fordi den fremhever mønstre og trender som ikke er synlige når man kun analyserer én dimensjon. Ved å segmentere kohorter etter flere faktorer kan du tilpasse markedsføringsstrategier, forbedre kundeopplevelse og fordele ressurser 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)

Ved å segmentere kohorter etter både `signup_month` og `acquisition_channel`, kan du oppdage skjulte trender som en-dimensjonal analyse kan overse. For eksempel kan du finne ut at brukere anskaffet via **"Email"** i januar er mer engasjerte eller har høyere lojalitet enn de som ble anskaffet via **"Ad"** samme måned. Dette detaljnivået gir mulighet for datadrevne beslutninger om hvor markedsføringsbudsjettet bør investeres, hvordan onboarding-opplevelser kan tilpasses, og hvilke kanaler som gir de mest verdifulle kundene. **Multi-dimensjonal segmentering** er et kraftig verktøy for å avdekke innsikt som driver forretningsvekst.


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

Bli ekspert på kohortanalyse-teknikker ved bruk av Python. Dette kurset dekker strukturering av kohortdata, avansert segmentering, retensjonsanalyse og handlingsrettede forretningsinnsikter, med praktiske utfordringer i hver seksjon.

Lær hvordan du strukturerer, forbehandler og klargjør data for avansert kohortanalyse, inkludert kohorttilordning og feature engineering.

Fordyp deg i avanserte segmenteringsstrategier og beregning av retensjonsmetrikker for å avdekke dypere innsikt fra kohortdata.

Visualiser kohortdata og hent ut handlingsrettede forretningsinnsikter ved hjelp av avanserte plotte- og tolkningsteknikker.

Multidimensjonal kohortsegmentering

Løsning