Analyse de l’entonnoir
Suivez le nombre d’utilisateurs atteignant chaque étape d’un entonnoir à plusieurs étapes et calculez les taux de conversion entre étapes consécutives.
Analyse de l’entonnoir est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce qu'un entonnoir de conversion ?
Un entonnoir de conversion modélise le parcours d'un utilisateur à travers une suite d'étapes obligatoires : par exemple, Page d'accueil → Page produit → Ajout au panier → Paiement → Achat. À chaque étape, certains utilisateurs abandonnent et n'atteignent jamais l'étape suivante. L'analyse des entonnoirs quantifie ces abandons afin que les équipes puissent déterminer quelle étape améliorer en priorité. Le résultat est une table présentant le nombre d'utilisateurs et le taux de conversion à chaque étape.
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())Compter les utilisateurs uniques à chaque étape
Pour chaque étape de l'entonnoir, comptez le nombre d'utilisateurs uniques ayant déclenché cet événement au moins une fois. Utilisez df[df['event_type'] == step]['user_id'].nunique() dans une boucle et rassemblez les résultats dans un dictionnaire. La conversion en Series simplifie les calculs de pourcentage ultérieurs grâce à une simple division.
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)Calculer les taux de conversion d'une étape à l'autre
Le taux de conversion d'une étape à l'autre indique quelle proportion des utilisateurs ayant terminé l'étape N a également terminé l'étape N+1. Calculez-le avec funnel.shift(1) (qui fournit le nombre de l'étape précédente), puis effectuez la division : funnel / funnel.shift(1) * 100. La première étape n'a pas d'étape précédente : son taux vaut donc NaN ou 100 %, selon la définition de la référence.
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)Calculer le taux de conversion global
Le taux de conversion global mesure la proportion de tous les utilisateurs entrés dans l'entonnoir à l'étape 1 qui ont finalement terminé la dernière étape. Divisez le nombre d'utilisateurs de la dernière étape par celui de la première. Une conversion globale de 2 à 5 % entre la page d'accueil et l'achat est courante dans le commerce en ligne ; une valeur inférieure signale un abandon critique quelque part dans l'entonnoir.
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_%']])Entonnoir ordonné : imposer une séquence d'étapes
Un simple comptage des utilisateurs uniques considère comme valides les utilisateurs qui sont passés directement au paiement sans consulter la page produit, ce qui gonfle la conversion aux premières étapes. Pour imposer un ordre, vérifiez que chaque utilisateur n'a atteint l'étape N qu'après avoir atteint l'étape N-1. Cela nécessite de comparer les horodatages : l'utilisateur doit avoir un événement product_page avant son événement add_to_cart.
# 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())Entonnoir par segment : type d'appareil
Les différents segments d'utilisateurs peuvent présenter des taux de conversion très différents. Exécutez le même calcul d'entonnoir séparément pour les utilisateurs d'ordinateurs et ceux de mobiles avec groupby('device_type'). Si les utilisateurs mobiles abandonnent massivement à l'étape du paiement, la page de paiement présente probablement un problème d'utilisabilité sur les petits écrans. Les entonnoirs segmentés révèlent des possibilités d'optimisation ciblées.
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)Identifier l'étape enregistrant le plus grand abandon
L'étape qui enregistre la plus grande perte absolue d'utilisateurs constitue la priorité d'optimisation la plus élevée. Trouvez-la en calculant la différence entre les nombres d'utilisateurs d'étapes consécutives avec funnel.diff() : la valeur la plus négative correspond au plus grand abandon. Présentez cette conclusion sous forme numérique et visuelle aux parties prenantes.
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)')Temps entre les étapes de l'entonnoir
Le temps nécessaire aux utilisateurs pour passer d'une étape à la suivante révèle les points de friction. Si les utilisateurs attendent plusieurs heures entre l'ajout au panier et le paiement, un e-mail de relance des paniers abandonnés pourrait les faire revenir. Calculez le temps médian entre chaque paire d'étapes à partir du DataFrame first_events, en soustrayant les colonnes d'horodatage adjacentes, puis en calculant la médiane sur l'ensemble des utilisateurs.
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')Tendance hebdomadaire de l'entonnoir
Suivez l'amélioration ou la dégradation des taux de conversion d'une semaine à l'autre en calculant l'entonnoir séparément pour chaque semaine. Regroupez la table des premiers événements par semaine avec first_events['homepage'].dt.isocalendar().week, puis calculez le taux de conversion global pour chaque semaine. Une baisse soudaine au cours d'une semaine donnée peut coïncider avec une mise en production ou une modification marketing.
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))Construire le DataFrame récapitulatif de l'entonnoir
Rassemblez tous les indicateurs de l'entonnoir dans un DataFrame récapitulatif propre, qui pourra être exporté dans un rapport ou transmis à un outil de visualisation. Incluez des colonnes pour le nom de l'étape, le nombre d'utilisateurs, la conversion d'une étape à l'autre, la conversion globale et le nombre d'utilisateurs perdus. Ce DataFrame unique doit constituer le livrable de l'analyse de l'entonnoir, lisible aussi bien par les ingénieurs que par les responsables produit.
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)Visualiser l'entonnoir sous forme de diagramme en barres
Représentez l'entonnoir sous forme d'un graphique à barres horizontales, où la longueur de chaque barre correspond au nombre d'utilisateurs à cette étape. Une forme d'entonnoir apparaît naturellement lorsque les barres sont triées de haut (nombre maximal d'utilisateurs) en bas (nombre minimal). Annotez chaque barre avec le pourcentage de conversion d'une étape à l'autre afin que le graphique se suffise à lui-même et ne nécessite pas de tableau de données distinct pour être interprété.
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()Vérification rapide
Testez votre compréhension des concepts d'analyse des données présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris à : compter les utilisateurs uniques à chaque étape de l'entonnoir, calculer les taux de conversion d'une étape à l'autre et le taux global, et segmenter les entonnoirs par type d'appareil et suivre les tendances hebdomadaires de conversion. Nous allons maintenant étudier les tableaux de rétention par cohorte afin de suivre le nombre d'utilisateurs qui reviennent semaine après semaine.
Questions Fréquemment Posées
La leçon « Analyse de l’entonnoir » est-elle gratuite ?
Oui — le texte complet de « Analyse de l’entonnoir » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Analyse de l’entonnoir » ?
Suivez le nombre d’utilisateurs atteignant chaque étape d’un entonnoir à plusieurs étapes et calculez les taux de conversion entre étapes consécutives. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?
Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Analyse de l’entonnoir » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?
Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Sessionisation et séquencement des événements
- Analyse de l’entonnoir
- Tableau de rétention par cohorte
- Visualiser les parcours des utilisateurs