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.

Die multidimensionale Kohortensegmentierung ermöglicht es, Nutzer anhand mehrerer Merkmale zu gruppieren, beispielsweise sowohl nach dem Monat der Anmeldung als auch nach dem Akquisitionskanal. Während sich die traditionelle Kohortenanalyse meist auf einen einzelnen Faktor – wie das Anmeldedatum – konzentriert, erlaubt die multidimensionale Segmentierung die Beantwortung komplexerer Fragestellungen. So lässt sich etwa erkennen, ob sich Nutzer aus einer bestimmten Marketingkampagne in einem bestimmten Monat anders verhalten als solche aus einem anderen Kanal oder einer anderen Region. Dieser Ansatz ist für Unternehmen wertvoll, da er Muster und Trends sichtbar macht, die bei der Analyse nur einer Dimension verborgen bleiben. Durch die Segmentierung von Kohorten anhand mehrerer Faktoren können Marketingstrategien gezielter ausgerichtet, die Kundenbindung verbessert und Ressourcen effektiver eingesetzt werden.

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)

Durch die Segmentierung von Kohorten nach sowohl `signup_month` als auch `acquisition_channel` lassen sich verborgene Trends erkennen, die bei einer eindimensionalen Analyse übersehen werden könnten. Beispielsweise kann festgestellt werden, dass Nutzer, die im Januar über **„Email“** gewonnen wurden, stärker engagiert sind oder eine höhere Bindung aufweisen als solche, die im selben Monat über **„Ad“** akquiriert wurden. Dieses Detailniveau ermöglicht datenbasierte Entscheidungen darüber, in welche Marketingkanäle investiert, wie Onboarding-Erfahrungen personalisiert und welche Kanäle die wertvollsten Kunden liefern. **Multidimensionale Segmentierung** ist ein leistungsstarkes Werkzeug, um Erkenntnisse zu gewinnen, die das Unternehmenswachstum fördern.


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

Beherrschung von Kohortenanalysetechniken mit Python. Dieser Kurs behandelt die Strukturierung von Kohortendaten, fortgeschrittene Segmentierung, Retentionsanalysen und umsetzbare Geschäftseinblicke mit praxisnahen Herausforderungen in jedem Abschnitt.

Erfahren Sie, wie Sie Daten für fortgeschrittene Kohortenanalysen strukturieren, vorverarbeiten und vorbereiten, einschließlich Kohortenzuordnung und Feature Engineering.

Tauchen Sie ein in fortgeschrittene Segmentierungsstrategien und die Berechnung von Retentionsmetriken, um tiefere Einblicke aus Kohortendaten zu gewinnen.

Visualisierung von Kohortendaten und Gewinnung umsetzbarer geschäftlicher Erkenntnisse mithilfe fortgeschrittener Visualisierungs- und Interpretationstechniken.

Mehrdimensionale Kohortensegmentierung

Lösung