Pandas & NumPy Academy · Leçon

Visualiser les parcours des utilisateurs

Représentez l’entonnoir sous forme de graphique en barres horizontal et la matrice de rétention sous forme de carte thermique afin de communiquer les résultats aux parties prenantes.

Leçon 4 sur 413 étapes

Visualiser les parcours des utilisateurs est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Pourquoi visualiser les parcours utilisateurs ?

Les tableaux bruts d'événements et les taux de conversion exprimés sous forme de nombres sont difficiles à communiquer à des parties prenantes non techniques. Les représentations visuelles des parcours utilisateurs — graphiques en entonnoir, heatmaps de rétention et diagrammes de Sankey — rendent les tendances immédiatement visibles. L'objectif n'est pas de remplacer les nombres, mais de les présenter sous une forme où les informations clés apparaissent d'elles-mêmes en un coup d'œil, ce qui réduit l'effort de compréhension demandé au public.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Assume funnel_summary and retention_pct are already computed
print('Visualisation libraries loaded')

Graphique à barres horizontales pour l'entonnoir

Le graphique à barres horizontales est la visualisation d'entonnoir la plus simple et la plus largement comprise. Chaque barre représente une étape de l'entonnoir ; sa longueur représente le nombre d'utilisateurs. Triez les étapes de haut en bas dans l'ordre de l'entonnoir afin que le graphique soit lu comme un entonnoir qui s'élargit. Utilisez une seule couleur contrastée pour toutes les barres afin que l'attention porte sur les valeurs et non sur la variété des couleurs.

FUNNEL_STEPS = ['homepage', 'product_page', 'add_to_cart', 'checkout', 'purchase']
users = [10000, 7200, 4100, 2300, 980]

fig, ax = plt.subplots(figsize=(9, 5))
bars = ax.barh(FUNNEL_STEPS[::-1], users[::-1], color='steelblue', height=0.6)
ax.set_xlabel('Unique Users')
ax.set_title('Conversion Funnel')
plt.tight_layout()
plt.show()

Annoter les taux de conversion sur le graphique

Ajoutez les annotations des taux de conversion à l'extrémité droite de chaque barre avec ax.text(). Affichez à la fois le nombre absolu d'utilisateurs et le pourcentage de conversion d'une étape à l'autre afin que le graphique contienne toutes les informations nécessaires sans tableau de données distinct. Placez le texte légèrement à l'extérieur de l'extrémité de la barre, avec un petit décalage horizontal, pour éviter qu'il ne chevauche son remplissage.

conversions = [None, 72.0, 56.9, 56.1, 42.6]

for i, (u, c) in enumerate(zip(users[::-1], conversions[::-1])):
    label = f'{u:,} users'
    if c is not None:
        label += f'  ({c}% conv)'
    ax.text(u + 100, i, label, va='center', fontsize=9)

plt.tight_layout()
plt.show()

Revisiter la heatmap de rétention

La heatmap de rétention est le résultat standard d'une analyse par cohorte. Chaque ligne correspond à une cohorte, chaque colonne à un décalage en semaines et chaque cellule est colorée selon le pourcentage de rétention. Utilisez la palette RdYlGn (rouge = faible, vert = élevé) avec vmin=0, vmax=100 explicites afin que l'échelle de couleurs reste cohérente entre les présentations et ne soit pas recalculée pour chaque heatmap.

import numpy as np

# Simulated retention data for illustration
data = [[100, 55, 42, 38, 35, 33],
        [100, 52, 40, 36, 33, 0],
        [100, 58, 45, 41, 0, 0],
        [100, 60, 48, 0, 0, 0]]
retention_pct = pd.DataFrame(data, columns=range(6),
                             index=['Wk1', 'Wk2', 'Wk3', 'Wk4'])

fig, ax = plt.subplots(figsize=(10, 4))
sns.heatmap(retention_pct, annot=True, fmt='.0f', cmap='RdYlGn',
            vmin=0, vmax=100, linewidths=0.5, ax=ax)
ax.set_title('Cohort Retention Heatmap')
plt.tight_layout()
plt.show()

Masquer les cellules incomplètes des cohortes

Les cohortes les plus récentes n'ont pas encore eu le temps d'atteindre tous les décalages en semaines. Ces cellules doivent apparaître vides plutôt qu'avec la valeur 0 %, afin que les lecteurs ne confondent pas l'absence de données avec une rétention nulle. Créez un masque booléen lorsque la valeur de la cellule est 0 et que l'indice de colonne dépasse le nombre de semaines écoulées depuis la création de la cohorte, puis transmettez-le à sns.heatmap(mask=...).

mask = retention_pct == 0  # cells with no data yet

fig, ax = plt.subplots(figsize=(10, 4))
sns.heatmap(retention_pct, annot=True, fmt='.0f', cmap='RdYlGn',
            vmin=0, vmax=100, linewidths=0.5,
            mask=mask, ax=ax)
ax.set_title('Cohort Retention (incomplete cells masked)')
plt.tight_layout()
plt.show()

Tracer la courbe de rétention moyenne

Visualisez la courbe de rétention moyenne en traçant les moyennes des colonnes de la matrice de rétention. Cette ligne unique résume le profil global de rétention du produit. Ajoutez une bande ombrée correspondant à ±1 écart type pour montrer la variabilité entre les cohortes. Une bande étroite signifie que les cohortes se comportent de manière similaire ; une bande large suggère des différences importantes entre cohortes qui méritent d'être étudiées.

avg = retention_pct.mean(axis=0)
std = retention_pct.std(axis=0)

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(avg.index, avg, marker='o', color='steelblue', linewidth=2)
ax.fill_between(avg.index, avg - std, avg + std, alpha=0.2, color='steelblue')
ax.set_xlabel('Week Number')
ax.set_ylabel('Avg Retention %')
ax.set_title('Average Cohort Retention Curve')
plt.tight_layout()
plt.show()

Entonnoir segmenté : ordinateur et mobile

Tracer côte à côte les entonnoirs de différents segments permet de déterminer si les problèmes du produit sont généraux ou spécifiques à un appareil. Créez un graphique à barres groupées avec deux groupes de barres par étape de l'entonnoir, en utilisant ax.bar() avec un décalage sur l'axe horizontal. Vous pouvez également dessiner deux graphiques d'entonnoir distincts dans une grille de sous-graphiques 1×2 avec plt.subplots(1, 2) pour faciliter la comparaison.

steps = ['Homepage', 'Product', 'Cart', 'Checkout', 'Purchase']
desktop = [5000, 3800, 2300, 1500, 700]
mobile = [5000, 3400, 1800, 900, 280]

x = range(len(steps))
fig, ax = plt.subplots(figsize=(10, 5))
ax.bar([i - 0.2 for i in x], desktop, width=0.4, label='Desktop', color='steelblue')
ax.bar([i + 0.2 for i in x], mobile, width=0.4, label='Mobile', color='darkorange')
ax.set_xticks(list(x))
ax.set_xticklabels(steps)
ax.legend()
ax.set_title('Funnel by Device Type')
plt.tight_layout()
plt.show()

Distribution de la fréquence des événements

Visualiser la distribution du nombre d'événements par session permet de déterminer si les sessions se concentrent autour d'un petit nombre d'événements (ce qui suggère que les utilisateurs atteignent rapidement leur objectif) ou couvrent une large plage (ce qui suggère des parcours complexes ou de la confusion). Tracez cette distribution avec ax.hist() sur la colonne event_count, en utilisant une échelle logarithmique sur l'axe vertical si la distribution est fortement asymétrique vers la droite.

import numpy as np

event_counts = pd.Series([3, 5, 2, 8, 1, 12, 3, 4, 6, 20, 2, 3, 1, 7, 5])

fig, ax = plt.subplots(figsize=(8, 4))
ax.hist(event_counts, bins=15, color='steelblue', edgecolor='white')
ax.set_xlabel('Events per Session')
ax.set_ylabel('Number of Sessions')
ax.set_title('Session Event Frequency Distribution')
plt.tight_layout()
plt.show()

Séquences d'événements les plus fréquentes

Affichez les séquences de deux événements (bigrammes) les plus fréquentes dans le flux de clics afin de comprendre les parcours utilisateurs typiques. Regroupez les événements par session, triez-les selon event_rank et extrayez les paires consécutives avec zip(events, events[1:]). Comptez la fréquence des paires avec un compteur et représentez les 10 premières sous forme de graphique à barres horizontales. Vous découvrirez ainsi quels parcours de navigation dominent le comportement des utilisateurs.

from collections import Counter

events_per_session = [['homepage', 'product_page', 'add_to_cart'],
                       ['homepage', 'search', 'product_page'],
                       ['homepage', 'product_page', 'purchase']]

bigrams = Counter()
for session in events_per_session:
    for pair in zip(session, session[1:]):
        bigrams[pair] += 1

print(bigrams.most_common(5))

Distribution de la durée des sessions

Un histogramme des durées de session montre si les utilisateurs s'engagent brièvement (moins de 2 minutes), modérément ou longuement. Utilisez une échelle logarithmique sur l'axe horizontal si un petit nombre de sessions très longues risque de concentrer la majorité des données dans la barre la plus à gauche. Superposez une ligne verticale à la médiane avec ax.axvline() pour guider l'interprétation de la durée de session « typique » par le public.

durations = pd.Series([1.2, 3.5, 0.5, 12.3, 2.1, 8.7, 1.8, 0.3, 45.1, 4.6])

fig, ax = plt.subplots(figsize=(8, 4))
ax.hist(durations, bins=20, color='steelblue', edgecolor='white')
ax.axvline(durations.median(), color='red', linestyle='--', label=f'Median: {durations.median():.1f} min')
ax.set_xlabel('Session Duration (min)')
ax.set_ylabel('Sessions')
ax.legend()
plt.tight_layout()
plt.show()

Enregistrer la figure du tableau de bord

Combinez plusieurs visualisations dans une seule figure de tableau de bord à l'aide d'une grille de sous-graphiques avec plt.subplots(2, 2, figsize=(14, 10)). Attribuez à chaque panneau le graphique à barres de l'entonnoir, la heatmap de rétention, la courbe de rétention moyenne et la distribution des événements. Enregistrez la figure au format PNG pour une diffusion sur le Web ou au format PDF pour des rapports imprimables. Une figure unifiée est plus facile à partager que quatre fichiers distincts.

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Panel 1: funnel
axes[0, 0].barh(FUNNEL_STEPS[::-1], users[::-1], color='steelblue')
axes[0, 0].set_title('Funnel')

# Panel 2: retention heatmap
sns.heatmap(retention_pct, ax=axes[0, 1], cmap='RdYlGn', annot=True, fmt='.0f', vmin=0, vmax=100)
axes[0, 1].set_title('Cohort Retention')

fig.suptitle('User Journey Dashboard', fontsize=16)
plt.tight_layout()
fig.savefig('user_journey_dashboard.png', dpi=150, bbox_inches='tight')
print('Dashboard saved')

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 à : créer des graphiques à barres d'entonnoir annotés et des heatmaps de rétention, tracer des courbes de rétention moyenne avec des bandes de variabilité, et combiner plusieurs graphiques dans une seule figure de tableau de bord enregistrée au format PNG. Nous allons maintenant étudier la détection et la suppression des enregistrements en double dans le nettoyage avancé des données.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Visualiser les parcours des utilisateurs » est-elle gratuite ?

Oui — le texte complet de « Visualiser les parcours des utilisateurs » 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 « Visualiser les parcours des utilisateurs » ?

Représentez l’entonnoir sous forme de graphique en barres horizontal et la matrice de rétention sous forme de carte thermique afin de communiquer les résultats aux parties prenantes. 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 4 sur 4.

Combien de temps prend la leçon « Visualiser les parcours des utilisateurs » ?

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

  1. Sessionisation et séquencement des événements
  2. Analyse de l’entonnoir
  3. Tableau de rétention par cohorte
  4. Visualiser les parcours des utilisateurs
← Retour à Pandas & NumPy Academy