0Pricing
Pandas & NumPy Academy · Lektion

Trichteranalyse

Verfolgen Sie, wie viele Benutzer jede Stufe eines mehrstufigen Trichters erreichen, und berechnen Sie die Konversionsraten zwischen aufeinanderfolgenden Stufen.

Trichteranalyse ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Conversion-Funnel?

Ein Conversion-Funnel bildet die Reise eines Nutzers durch eine Abfolge erforderlicher Schritte ab, beispielsweise Startseite → Produktseite → In den Warenkorb → Checkout → Kauf. Bei jedem Schritt springen einige Nutzer ab und erreichen den nächsten Schritt nicht. Eine Funnel-Analyse quantifiziert diese Abbrüche, damit Teams priorisieren können, welchen Schritt sie zuerst verbessern sollten. Das Ergebnis ist eine Tabelle mit der Nutzeranzahl und der Conversion-Rate für jeden Schritt.

import pandas as pd

FUNNEL_STEPS = [
    'homepage',
    'product_page',
    'add_to_cart',
    'checkout',
    'purchase'
]

df = pd.read_csv('clickstream.csv', parse_dates=['timestamp'])
print(df['event_type'].value_counts())

Eindeutige Nutzer an jedem Schritt zählen

Zählen Sie für jeden Funnel-Schritt die Anzahl der eindeutigen Nutzer, die dieses Ereignis mindestens einmal ausgelöst haben. Verwenden Sie innerhalb einer Schleife df[df['event_type'] == step]['user_id'].nunique() und sammeln Sie die Ergebnisse in einem Dictionary. Durch die Umwandlung in eine Series werden anschließende Prozentberechnungen mit einer einzigen Division unkompliziert.

step_counts = {}
for step in FUNNEL_STEPS:
    users = df[df['event_type'] == step]['user_id'].nunique()
    step_counts[step] = users

funnel = pd.Series(step_counts, name='users')
print(funnel)

Conversion-Raten von Schritt zu Schritt berechnen

Die Conversion-Rate von Schritt zu Schritt zeigt, welcher Anteil der Nutzer, die Schritt N abgeschlossen haben, auch Schritt N+1 abgeschlossen hat. Berechnen Sie sie mit funnel.shift(1), das die Anzahl des vorherigen Schritts liefert, und führen Sie die Division durch: funnel / funnel.shift(1) * 100. Für den ersten Schritt gibt es keinen vorherigen Schritt. Je nach Definition der Basis beträgt die Rate daher NaN oder 100 %.

funnel_df = funnel.to_frame()
funnel_df['prev_users'] = funnel_df['users'].shift(1)
funnel_df['step_conversion_%'] = (funnel_df['users'] / funnel_df['prev_users'] * 100).round(1)
print(funnel_df)

Gesamte Conversion-Rate berechnen

Die gesamte Conversion-Rate misst, welcher Anteil aller Nutzer, die den Funnel bei Schritt 1 betreten haben, letztendlich den letzten Schritt abgeschlossen hat. Teilen Sie die Nutzeranzahl des letzten Schritts durch die Anzahl des ersten Schritts. Eine gesamte Conversion-Rate von 2–5 % von der Startseite bis zum Kauf ist im E-Commerce typisch; niedrigere Werte weisen auf einen kritischen Abbruch an einer Stelle des Funnels hin.

overall_rate = funnel.iloc[-1] / funnel.iloc[0] * 100
print(f'Overall conversion rate: {overall_rate:.1f}%')

funnel_df['overall_conversion_%'] = (funnel_df['users'] / funnel_df['users'].iloc[0] * 100).round(1)
print(funnel_df[['users', 'overall_conversion_%']])

Geordneter Funnel: Schrittfolge voraussetzen

Eine einfache Zählung eindeutiger Nutzer behandelt Nutzer, die direkt zum Checkout gesprungen sind, ohne die Produktseite zu besuchen, als gültige Funnel-Einstiege. Dadurch wird die Conversion an den frühen Schritten überhöht. Um die Reihenfolge zu erzwingen, prüfen Sie, ob jeder Nutzer Schritt N erst nach Schritt N-1 erreicht hat. Dazu müssen Sie die Zeitstempel vergleichen: Das Ereignis product_page muss beim Nutzer vor dem Ereignis add_to_cart liegen.

# Get first occurrence of each step per user
first_events = df.groupby(['user_id', 'event_type'])['timestamp'].min().unstack('event_type')

# Enforce ordering: each step must come after the previous
first_events['valid_to_cart'] = first_events['add_to_cart'] > first_events['product_page']
print(first_events[['product_page', 'add_to_cart', 'valid_to_cart']].head())

Funnel nach Segment: Gerätetyp

Unterschiedliche Nutzersegmente können sehr unterschiedliche Conversion-Raten aufweisen. Führen Sie dieselbe Funnel-Berechnung mithilfe von groupby('device_type') getrennt für Desktop- und Mobilnutzer durch. Wenn Mobilnutzer beim Checkout stark abspringen, weist die Checkout-Seite auf kleinen Bildschirmen wahrscheinlich ein Usability-Problem auf. Segmentierte Funnels zeigen gezielte Optimierungsmöglichkeiten.

def funnel_for_group(group_df):
    counts = {}
    for step in FUNNEL_STEPS:
        counts[step] = group_df[group_df['event_type'] == step]['user_id'].nunique()
    return pd.Series(counts)

segmented_funnel = df.groupby('device_type').apply(funnel_for_group)
print(segmented_funnel)

Den Schritt mit dem größten Abbruch identifizieren

Der Schritt mit dem größten absoluten Nutzerverlust hat höchste Priorität für die Optimierung. Ermitteln Sie ihn, indem Sie mit funnel.diff() die Differenz zwischen den Nutzerzahlen aufeinanderfolgender Schritte berechnen. Der negativste Wert entspricht dabei dem größten Abbruch. Stellen Sie diese Erkenntnis sowohl numerisch als auch visuell für die Stakeholder dar.

dropoffs = funnel.diff().abs()
biggest_drop = dropoffs.idxmax()
biggest_drop_count = dropoffs.max()

print(f'Biggest drop-off: {biggest_drop} ({biggest_drop_count:.0f} users lost)')

Zeit zwischen Funnel-Schritten

Die Zeit, die Nutzer für den Wechsel von einem Schritt zum nächsten benötigen, zeigt Reibungspunkte auf. Wenn Nutzer zwischen dem Hinzufügen eines Artikels zum Warenkorb und dem Checkout mehrere Stunden warten, könnte eine E-Mail zu einem abgebrochenen Warenkorb sie zurückgewinnen. Berechnen Sie die mediane Zeit zwischen jedem Schritt-Paar mithilfe des DataFrames first_events, indem Sie benachbarte Zeitstempelspalten voneinander abziehen und über alle Nutzer den Median bilden.

for i in range(1, len(FUNNEL_STEPS)):
    prev = FUNNEL_STEPS[i-1]
    curr = FUNNEL_STEPS[i]
    delta = (first_events[curr] - first_events[prev]).dt.total_seconds() / 60
    print(f'{prev} -> {curr}: median {delta.median():.1f} min, 90th pct {delta.quantile(0.9):.1f} min')

Wöchentlicher Funnel-Trend

Verfolgen Sie, ob sich die Conversion-Raten von Woche zu Woche verbessern oder verschlechtern, indem Sie den Funnel für jede Woche separat berechnen. Gruppieren Sie die Tabelle mit den ersten Ereignissen nach Woche mithilfe von first_events['homepage'].dt.isocalendar().week und berechnen Sie die gesamte Conversion-Rate pro Woche. Ein plötzlicher Rückgang in einer bestimmten Woche kann mit einer Produktveröffentlichung oder einer Marketingänderung zusammenfallen.

df['week'] = df['timestamp'].dt.isocalendar().week

weekly_conv = []
for week, wdf in df.groupby('week'):
    top = wdf[wdf['event_type'] == FUNNEL_STEPS[0]]['user_id'].nunique()
    bot = wdf[wdf['event_type'] == FUNNEL_STEPS[-1]]['user_id'].nunique()
    weekly_conv.append({'week': week, 'conversion_%': bot/top*100 if top else 0})

print(pd.DataFrame(weekly_conv))

Den Funnel-Zusammenfassungs-DataFrame erstellen

Fassen Sie alle Funnel-Kennzahlen in einem übersichtlichen DataFrame zusammen, der in einen Bericht exportiert oder einer Visualisierung zugeführt werden kann. Fügen Sie Spalten für den Schrittnamen, die Nutzeranzahl, die Conversion von Schritt zu Schritt, die gesamte Conversion und die verlorenen Nutzer hinzu. Dieser einzelne DataFrame sollte das Ergebnis der Funnel-Analyse sein und sowohl für Entwickler als auch für Product Manager verständlich bleiben.

summary = pd.DataFrame({
    'step': FUNNEL_STEPS,
    'users': [step_counts[s] for s in FUNNEL_STEPS]
})
summary['users_lost'] = summary['users'].shift(-1).rsub(summary['users'])
summary['step_conv_%'] = (summary['users'] / summary['users'].shift(1) * 100).round(1)
summary['overall_conv_%'] = (summary['users'] / summary['users'].iloc[0] * 100).round(1)
print(summary)

Den Funnel als Balkendiagramm visualisieren

Stellen Sie den Trichter als horizontales Balkendiagramm dar, wobei die Länge jedes Balkens die Anzahl der Nutzer in diesem Schritt repräsentiert. Eine Trichterform entsteht automatisch, wenn die Balken von oben (meiste Nutzer) nach unten (wenigste Nutzer) sortiert werden. Beschriften Sie jeden Balken mit dem prozentualen Übergang zum jeweils nächsten Schritt, damit das Diagramm eigenständig verständlich ist und keine separate Datentabelle zur Interpretation benötigt wird.

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
ax.barh(summary['step'][::-1], summary['users'][::-1], color='steelblue')
for i, row in summary[::-1].iterrows():
    ax.text(row['users'], i - summary.index[0], f'  {row['step_conv_%']}%', va='center')
ax.set_xlabel('Unique Users')
ax.set_title('Conversion Funnel')
plt.tight_layout()
plt.show()

Kurztest

Testen Sie Ihr Verständnis der Konzepte der Datenanalyse aus dieser Lektion.

Lektionsrückblick

In dieser Lektion haben Sie Folgendes gelernt: eindeutige Nutzer in jedem Trichterschritt zählen, Übergangs- und Gesamtkonversionsraten berechnen sowie Trichter nach Gerätetyp segmentieren und wöchentliche Konversionstrends verfolgen. Als Nächstes sehen wir uns Kohorten-Retentionstabellen an, mit denen sich verfolgen lässt, wie viele Nutzer Woche für Woche zurückkehren.

Häufig gestellte Fragen

Ist die Lektion „Trichteranalyse“ kostenlos?

Ja — der vollständige Text von „Trichteranalyse“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Trichteranalyse“?

Verfolgen Sie, wie viele Benutzer jede Stufe eines mehrstufigen Trichters erreichen, und berechnen Sie die Konversionsraten zwischen aufeinanderfolgenden Stufen. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Trichteranalyse“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Sessionisierung und Ereignisabfolge
  2. Trichteranalyse
  3. Kohorten-Retention-Tabelle
  4. Nutzerreisen visualisieren
← Zurück zu Pandas & NumPy Academy