Histogramme Seaborn : Créer des graphiques de distribution en Python

Name

Soren Atelier

Updated on 09/02/2026

Comprendre la distribution de vos données est essentiel pour l'analyse statistique et la prise de décision. Pourtant, de nombreux professionnels des données ont du mal à créer des graphiques de distribution clairs et informatifs qui révèlent les motifs et les valeurs aberrantes. Les outils de traçage génériques nécessitent souvent une personnalisation extensive et produisent des résultats visuellement peu attrayants.

Les fonctions d'histogramme de Seaborn résolvent ce problème en fournissant une interface de haut niveau pour créer de beaux graphiques de distribution avec un code minimal. La bibliothèque sélectionne automatiquement des valeurs par défaut appropriées pour les tailles de bins, les couleurs et le style, tout en vous donnant un contrôle précis lorsque nécessaire.

Ce guide couvre tout ce dont vous avez besoin pour maîtriser les histogrammes dans seaborn, des graphiques de base aux techniques de personnalisation avancées. Vous apprendrez à utiliser sns.histplot() et sns.displot(), contrôler les stratégies de regroupement, superposer des courbes KDE, comparer plusieurs distributions et éviter les pièges courants.

Qu'est-ce qu'un histogramme ?

Un histogramme affiche la distribution d'une variable continue en divisant la plage de données en bins et en comptant le nombre d'observations dans chaque bin. La hauteur de chaque barre représente la fréquence ou la densité des points de données dans cette plage de bin.

Les histogrammes vous aident à identifier :

• La tendance centrale (où se regroupent la plupart des valeurs)
• La dispersion et la variabilité des données
• L'asymétrie et les valeurs aberrantes
• Les distributions multimodales (plusieurs pics)

Seaborn fournit deux fonctions principales pour créer des histogrammes : histplot() pour les graphiques au niveau des axes et displot() pour les graphiques au niveau de la figure avec support de facettage automatique.

Histogramme de base avec sns.histplot()

La fonction histplot() est l'outil principal pour créer des histogrammes dans seaborn. Elle offre une interface simple avec de puissantes options de personnalisation.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Générer des données d'exemple
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
 
# Créer un histogramme de base
sns.histplot(data=data)
plt.title('Histogramme Seaborn de base')
plt.xlabel('Valeur')
plt.ylabel('Compte')
plt.show()

Cela crée un histogramme avec des tailles de bin déterminées automatiquement selon la règle de Freedman-Diaconis, qui équilibre détail et bruit.

Pour les données dans un DataFrame :

import pandas as pd
 
# Créer un DataFrame
df = pd.DataFrame({
    'values': np.random.normal(100, 15, 1000),
    'category': np.random.choice(['A', 'B', 'C'], 1000)
})
 
# Tracer l'histogramme à partir du DataFrame
sns.histplot(data=df, x='values')
plt.show()

Contrôle des bins : taille, nombre et plage

La sélection des bins affecte considérablement la façon dont votre histogramme révèle les motifs. Trop peu de bins simplifient trop la distribution, tandis que trop de bins créent du bruit.

Spécifier le nombre de bins

# Créer un histogramme avec 30 bins
sns.histplot(data=data, bins=30)
plt.title('Histogramme avec 30 bins')
plt.show()

Définir la largeur de bin

# Définir une largeur de bin spécifique
sns.histplot(data=data, binwidth=5)
plt.title('Histogramme avec largeur de bin = 5')
plt.show()

Définir les bords de bin

# Bords de bin personnalisés
bin_edges = [70, 80, 90, 100, 110, 120, 130]
sns.histplot(data=data, bins=bin_edges)
plt.title('Histogramme avec bords de bin personnalisés')
plt.show()

Contrôler la plage de bin

# Limiter la plage de l'histogramme
sns.histplot(data=data, binrange=(80, 120))
plt.title('Histogramme avec plage limitée (80-120)')
plt.show()

Ajouter une superposition KDE

L'estimation de densité de noyau (KDE) fournit une estimation lisse de la fonction de densité de probabilité, vous aidant à voir la forme globale de la distribution.

# Histogramme avec superposition KDE
sns.histplot(data=data, kde=True)
plt.title('Histogramme avec superposition KDE')
plt.show()

Vous pouvez également afficher uniquement la courbe KDE :

# KDE uniquement (pas de barres d'histogramme)
sns.kdeplot(data=data)
plt.title('Courbe KDE uniquement')
plt.show()

Ou combiner plusieurs visualisations :

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Histogramme uniquement
sns.histplot(data=data, ax=axes[0])
axes[0].set_title('Histogramme uniquement')
 
# KDE uniquement
sns.kdeplot(data=data, ax=axes[1])
axes[1].set_title('KDE uniquement')
 
# Les deux combinés
sns.histplot(data=data, kde=True, ax=axes[2])
axes[2].set_title('Histogramme + KDE')
 
plt.tight_layout()
plt.show()

Comprendre le paramètre stat

Le paramètre stat contrôle quelle statistique est calculée pour chaque bin, affectant l'interprétation de l'axe y.

fig, axes = plt.subplots(2, 3, figsize=(15, 8))
 
stats = ['count', 'frequency', 'density', 'probability', 'percent']
 
for idx, stat_type in enumerate(stats):
    ax = axes[idx // 3, idx % 3]
    sns.histplot(data=data, stat=stat_type, kde=True, ax=ax)
    ax.set_title(f'stat="{stat_type}"')
 
# Supprimer le sous-graphique supplémentaire
fig.delaxes(axes[1, 2])
 
plt.tight_layout()
plt.show()

Utilisez density lors de la comparaison de distributions avec différentes tailles d'échantillon, car cela normalise l'histogramme pour que l'aire totale soit égale à 1.

Comparer plusieurs distributions avec hue

Le paramètre hue vous permet de comparer des distributions à travers différentes catégories dans un seul graphique.

# Créer des données multi-catégories
df = pd.DataFrame({
    'values': np.concatenate([
        np.random.normal(90, 10, 500),
        np.random.normal(105, 12, 500),
        np.random.normal(100, 8, 500)
    ]),
    'group': ['A'] * 500 + ['B'] * 500 + ['C'] * 500
})
 
# Tracer avec hue
sns.histplot(data=df, x='values', hue='group', kde=True)
plt.title('Distributions multiples par groupe')
plt.show()

Contrôler le comportement de superposition avec multiple

Le paramètre multiple détermine comment plusieurs distributions sont affichées :

fig, axes = plt.subplots(2, 2, figsize=(12, 10))
 
multiple_types = ['layer', 'dodge', 'stack', 'fill']
 
for idx, mult_type in enumerate(multiple_types):
    ax = axes[idx // 2, idx % 2]
    sns.histplot(data=df, x='values', hue='group',
                 multiple=mult_type, ax=ax)
    ax.set_title(f'multiple="{mult_type}"')
 
plt.tight_layout()
plt.show()

Utilisation de sns.displot() pour les graphiques au niveau de la figure

Alors que histplot() est une fonction au niveau des axes, displot() est une fonction au niveau de la figure qui fournit des capacités supplémentaires comme le facettage automatique.

# Displot de base (crée une figure entière)
sns.displot(data=df, x='values', hue='group', kde=True)
plt.show()

Avantages de displot()

1. Facettage automatique avec les paramètres col et row
2. Dimensionnement cohérent à travers les sous-graphiques
3. Légende en dehors du graphique par défaut
4. Changement facile entre histogramme, KDE et ECDF

# Ajouter une dimension de facettage
df['dataset'] = np.random.choice(['Train', 'Test'], len(df))
 
# Créer un graphique facetté
sns.displot(data=df, x='values', hue='group',
            col='dataset', kde=True, height=4, aspect=1.2)
plt.show()

Changer de types de graphiques avec kind

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Histogramme
sns.displot(data=df, x='values', kind='hist', kde=True)
plt.title('kind="hist"')
 
# KDE
sns.displot(data=df, x='values', kind='kde')
plt.title('kind="kde"')
 
# ECDF (Fonction de distribution cumulative empirique)
sns.displot(data=df, x='values', kind='ecdf')
plt.title('kind="ecdf"')
 
plt.tight_layout()
plt.show()

Tableau de comparaison des fonctions

Recommandation : Utilisez histplot() lors de la création de plusieurs sous-graphiques avec plt.subplots(). Utilisez displot() pour des visualisations autonomes ou lorsque vous avez besoin de facettage.

Référence des paramètres de histplot()

Personnalisation avancée

Couleurs et style personnalisés

# Couleurs personnalisées pour chaque catégorie
custom_palette = {'A': '#FF6B6B', 'B': '#4ECDC4', 'C': '#45B7D1'}
 
sns.histplot(data=df, x='values', hue='group',
             palette=custom_palette, alpha=0.6,
             edgecolor='black', linewidth=1.5)
plt.title('Histogramme aux couleurs personnalisées')
plt.show()

Couleurs de bord et transparence

# Mettre l'accent sur les bords de bin
sns.histplot(data=data, bins=20, edgecolor='black',
             linewidth=2, alpha=0.7, color='skyblue')
plt.title('Histogramme avec bords proéminents')
plt.show()

Échelle logarithmique

Pour les données couvrant plusieurs ordres de grandeur, utilisez des échelles logarithmiques :

# Générer des données log-normales
log_data = np.random.lognormal(3, 1, 1000)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Échelle linéaire
sns.histplot(data=log_data, ax=axes[0])
axes[0].set_title('Échelle linéaire')
 
# Échelle logarithmique
sns.histplot(data=log_data, log_scale=True, ax=axes[1])
axes[1].set_title('Échelle logarithmique')
 
plt.tight_layout()
plt.show()

Distributions cumulatives

Les histogrammes cumulatifs montrent le total cumulé des observations jusqu'à chaque bin :

# Histogramme cumulatif
sns.histplot(data=data, cumulative=True, stat='density',
             element='step', fill=False)
plt.title('Distribution cumulative')
plt.ylabel('Densité cumulative')
plt.show()

Ceci est utile pour déterminer les percentiles et comparer les distributions.

Changer l'élément visuel

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
elements = ['bars', 'step', 'poly']
 
for ax, elem in zip(axes, elements):
    sns.histplot(data=data, element=elem, kde=True, ax=ax)
    ax.set_title(f'element="{elem}"')
 
plt.tight_layout()
plt.show()

Histogrammes bivariés (histogrammes 2D)

Seaborn peut créer des histogrammes 2D pour visualiser la distribution conjointe de deux variables :

# Générer des données 2D corrélées
np.random.seed(42)
x = np.random.normal(100, 15, 1000)
y = x + np.random.normal(0, 10, 1000)
 
# Histogramme 2D
sns.histplot(x=x, y=y, bins=30, cbar=True)
plt.title('Histogramme 2D (distribution bivariée)')
plt.show()

Combiner avec KDE pour une analyse bivariée

fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
# Histogramme 2D
sns.histplot(x=x, y=y, bins=30, cbar=True, ax=axes[0])
axes[0].set_title('Histogramme 2D')
 
# Graphique de contour KDE
sns.kdeplot(x=x, y=y, fill=True, cmap='viridis', ax=axes[1])
axes[1].set_title('Graphique KDE 2D')
 
plt.tight_layout()
plt.show()

Bivarié avec Hue

# Ajouter une catégorie
categories = np.random.choice(['Groupe 1', 'Groupe 2'], 1000)
 
sns.histplot(x=x, y=y, hue=categories, bins=20)
plt.title('Histogramme 2D avec Hue')
plt.show()

Erreurs courantes et comment les éviter

Erreur 1 : Utiliser trop ou trop peu de bins

Problème : Le lissage excessif masque les motifs, tandis que trop de bins créent du bruit.

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Trop peu de bins
sns.histplot(data=data, bins=5, ax=axes[0])
axes[0].set_title('Trop peu de bins (5) - Sur-lissé')
 
# Bon nombre
sns.histplot(data=data, bins=30, ax=axes[1])
axes[1].set_title('Bins appropriés (30)')
 
# Trop de bins
sns.histplot(data=data, bins=100, ax=axes[2])
axes[2].set_title('Trop de bins (100) - Bruyant')
 
plt.tight_layout()
plt.show()

Solution : Commencez par la sélection automatique des bins, puis ajustez en fonction des caractéristiques de vos données. Utilisez la règle de Sturges (bins = log2(n) + 1) pour les distributions normales ou la règle de Freedman-Diaconis pour les données asymétriques.

Erreur 2 : Comparer des distributions avec différentes tailles d'échantillon

Problème : Les comptes bruts rendent difficile la comparaison de distributions avec différentes observations totales.

# Différentes tailles d'échantillon
small_sample = np.random.normal(100, 15, 200)
large_sample = np.random.normal(100, 15, 2000)
 
df_samples = pd.DataFrame({
    'value': np.concatenate([small_sample, large_sample]),
    'sample': ['Petit (n=200)'] * 200 + ['Grand (n=2000)'] * 2000
})
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Incorrect : utiliser count
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='count', ax=axes[0])
axes[0].set_title('Incorrect : Count (difficile à comparer)')
 
# Correct : utiliser density
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='density', common_norm=False, ax=axes[1])
axes[1].set_title('Correct : Density (facile à comparer)')
 
plt.tight_layout()
plt.show()

Solution : Utilisez stat='density' ou stat='probability' et définissez common_norm=False.

Erreur 3 : Ignorer les distributions qui se chevauchent

Problème : Le mode de couche par défaut avec une opacité élevée rend les chevauchements invisibles.

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Mauvais : les barres opaques cachent le chevauchement
sns.histplot(data=df, x='values', hue='group',
             alpha=1.0, ax=axes[0])
axes[0].set_title('Mauvais : Barres opaques')
 
# Bon : la transparence montre le chevauchement
sns.histplot(data=df, x='values', hue='group',
             alpha=0.5, ax=axes[1])
axes[1].set_title('Bon : Barres transparentes')
 
plt.tight_layout()
plt.show()

Solution : Utilisez alpha=0.5 pour la transparence ou multiple='dodge' pour placer les barres côte à côte.

Erreur 4 : Ne pas étiqueter correctement les axes

Problème : Pas clair ce que représente l'axe y, en particulier lors de l'utilisation de différentes valeurs stat.

# Bonne pratique : étiquettes claires
sns.histplot(data=data, stat='density', kde=True)
plt.title('Distribution des valeurs')
plt.xlabel('Valeur')
plt.ylabel('Densité')
plt.show()

Solution : Étiquetez toujours les axes clairement, en particulier l'axe y lors de l'utilisation de stat='density' ou stat='probability'.

Erreur 5 : Utiliser distplot() obsolète

Problème : L'ancien code utilise distplot(), qui est obsolète et moins flexible.

# Ancienne méthode (obsolète)
# sns.distplot(data)  # N'utilisez pas ceci
 
# Nouvelle méthode
sns.histplot(data=data, kde=True)
plt.show()

Solution : Migrez vers histplot() pour les histogrammes ou kdeplot() pour les courbes KDE.

Visualiser les données de manière interactive avec PyGWalker

Alors que seaborn fournit d'excellentes visualisations d'histogrammes statiques, PyGWalker offre une alternative interactive qui vous permet d'explorer dynamiquement les distributions. PyGWalker transforme votre DataFrame pandas en une interface interactive de type Tableau où vous pouvez créer des histogrammes, ajuster le regroupement et basculer entre les types de visualisation sans écrire de code.

import pygwalker as pyg
import pandas as pd
import numpy as np
 
# Créer des données d'exemple
df = pd.DataFrame({
    'values': np.random.normal(100, 15, 1000),
    'category': np.random.choice(['A', 'B', 'C'], 1000),
    'score': np.random.uniform(0, 100, 1000)
})
 
# Lancer l'explorateur interactif
pyg.walk(df)

Avantages de PyGWalker pour l'analyse d'histogrammes :

• Interface glisser-déposer : Créez des histogrammes en faisant glisser des variables vers des étagères
• Regroupement dynamique : Ajustez le nombre de bins de manière interactive avec des curseurs
• Exploration multi-variables : Passez rapidement d'une variable à l'autre pour comparer les distributions
• Capacités d'exportation : Enregistrez des informations sous forme d'images ou partagez des rapports interactifs
• Aucun codage requis : Les membres de l'équipe non techniques peuvent explorer les données de manière indépendante

Visitez github.com/Kanaries/pygwalker (opens in a new tab) pour commencer avec la visualisation de données interactive.

Exemple concret : Analyser les notes d'examen

Appliquons les techniques d'histogramme pour analyser les distributions de notes d'examen dans différentes classes :

# Générer des données d'examen réalistes
np.random.seed(42)
n_students = 500
 
exam_data = pd.DataFrame({
    'score': np.concatenate([
        np.random.normal(75, 10, 200),  # Classe A
        np.random.normal(68, 15, 150),  # Classe B
        np.random.normal(82, 8, 150)    # Classe C
    ]),
    'class': ['Classe A'] * 200 + ['Classe B'] * 150 + ['Classe C'] * 150,
    'study_hours': np.random.uniform(0, 40, n_students)
})
 
# Limiter les scores à une plage valide
exam_data['score'] = exam_data['score'].clip(0, 100)
 
# Créer une visualisation complète
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Distribution globale avec KDE
sns.histplot(data=exam_data, x='score', kde=True,
             bins=30, ax=axes[0, 0])
axes[0, 0].set_title('Distribution globale des scores')
axes[0, 0].axvline(exam_data['score'].mean(), color='red',
                    linestyle='--', label=f'Moyenne : {exam_data["score"].mean():.1f}')
axes[0, 0].legend()
 
# Comparer les classes
sns.histplot(data=exam_data, x='score', hue='class',
             stat='density', common_norm=False,
             alpha=0.5, bins=25, ax=axes[0, 1])
axes[0, 1].set_title('Distribution des scores par classe')
 
# Vue empilée pour les proportions
sns.histplot(data=exam_data, x='score', hue='class',
             multiple='stack', bins=25, ax=axes[1, 0])
axes[1, 0].set_title('Distribution empilée (totaux)')
 
# Distributions cumulatives
sns.histplot(data=exam_data, x='score', hue='class',
             stat='density', element='step', fill=False,
             cumulative=True, common_norm=False, ax=axes[1, 1])
axes[1, 1].set_title('Distribution cumulative par classe')
 
plt.tight_layout()
plt.show()
 
# Imprimer les statistiques récapitulatives
print(exam_data.groupby('class')['score'].describe())

Cet exemple démontre :

• Analyse de distribution globale avec ligne de référence moyenne
• Comparaison de densité normalisée pour différentes tailles de classe
• Visualisation empilée montrant la contribution de chaque classe
• Distributions cumulatives pour l'analyse des percentiles

FAQ

Comment choisir le bon nombre de bins pour mon histogramme ?

Le nombre optimal de bins dépend de la taille et de la distribution de vos données. La sélection automatique de bins de Seaborn (basée sur la règle de Freedman-Diaconis) fonctionne bien pour la plupart des cas. Pour une sélection manuelle, utilisez la règle de Sturges : bins = log2(n) + 1 pour les distributions normales (typiquement 10-20 bins pour 1000 échantillons), ou règle de racine carrée : bins = sqrt(n) pour les données générales. Expérimentez avec différentes valeurs et choisissez celle qui révèle les motifs sans créer un bruit excessif. Utilisez binwidth au lieu de bins lorsque vous avez besoin de tailles de bin cohérentes sur plusieurs graphiques pour la comparaison.

Quelle est la différence entre histplot et displot dans seaborn ?

histplot() est une fonction au niveau des axes qui trace sur un objet axes matplotlib spécifique, ce qui la rend adaptée à la création de figures multi-graphiques complexes avec plt.subplots(). displot() est une fonction au niveau de la figure qui crée une figure entière et prend en charge le facettage automatique avec les paramètres col et row. Utilisez histplot() lors de l'intégration d'histogrammes dans des figures matplotlib existantes avec plusieurs sous-graphiques. Utilisez displot() pour des visualisations autonomes ou lorsque vous devez créer des graphiques facettés sur plusieurs variables catégorielles. Les deux fonctions prennent en charge les mêmes paramètres de base pour contrôler les bins, KDE, hue et les statistiques.

Dois-je utiliser stat='density' ou stat='probability' pour mon histogramme ?

Utilisez stat='density' lorsque vous avez besoin que l'aire de l'histogramme soit égale à 1, ce qui le rend comparable aux fonctions de densité de probabilité et idéal pour superposer des distributions théoriques. Utilisez stat='probability' (ou stat='percent') lorsque vous souhaitez interpréter l'axe y comme la proportion de données dans chaque bin, avec toutes les hauteurs de bin totalisant 1 (ou 100%). Choisissez stat='density' pour comparer des distributions avec différentes tailles d'échantillon ou lors de l'analyse statistique. Choisissez stat='probability' pour une interprétation plus intuitive dans les présentations ou lors de l'explication de résultats à des publics non techniques.

Comment créer un histogramme avec plusieurs distributions qui se chevauchent ?

Utilisez le paramètre hue pour spécifier une variable catégorielle qui divise vos données en groupes. Contrôlez le comportement de superposition avec le paramètre multiple : utilisez 'layer' (par défaut) pour des barres transparentes qui se chevauchent, 'dodge' pour des barres côte à côte, 'stack' pour des barres empilées verticalement montrant les totaux, ou 'fill' pour des barres empilées normalisées montrant les proportions. Définissez alpha=0.5 pour rendre visibles les régions de chevauchement. Lors de la comparaison de distributions avec différentes tailles d'échantillon, utilisez toujours stat='density' ou stat='probability' avec common_norm=False pour garantir une comparaison équitable. Ajoutez des courbes KDE avec kde=True pour mettre en évidence la forme globale de chaque distribution.

Pourquoi distplot de seaborn est-il obsolète et que dois-je utiliser à la place ?

Seaborn a rendu distplot() obsolète dans la version 0.11.0 car il combinait plusieurs fonctionnalités dans une seule fonction avec une nomenclature de paramètres incohérente. Les fonctions de remplacement fournissent des interfaces plus claires et plus de flexibilité : utilisez histplot() pour les histogrammes, kdeplot() pour l'estimation de densité de noyau, ecdfplot() pour les fonctions de distribution cumulative empirique et rugplot() pour les graphiques de tapis. Ces nouvelles fonctions offrent de meilleurs noms de paramètres, plus d'options de personnalisation, une prise en charge native du regroupement basé sur la teinte et un comportement cohérent avec les autres fonctions seaborn. Pour migrer l'ancien code, remplacez sns.distplot(data) par sns.histplot(data, kde=True) pour le cas d'utilisation le plus courant.

Conclusion

Les histogrammes Seaborn offrent un moyen puissant et flexible de visualiser les distributions de données avec un code minimal. La fonction histplot() offre un contrôle précis sur le regroupement, les statistiques et le regroupement, tandis que displot() simplifie les visualisations facettées. En maîtrisant les paramètres comme bins, stat, hue et multiple, vous pouvez créer des graphiques de distribution de qualité publication qui révèlent les motifs, les valeurs aberrantes et les différences entre les groupes.

Points clés à retenir :

• Utilisez la sélection automatique de bins pour l'exploration initiale, puis ajustez pour plus de clarté
• Appliquez stat='density' lors de la comparaison de distributions avec différentes tailles d'échantillon
• Exploitez les paramètres hue et multiple pour comparer efficacement plusieurs distributions
• Ajoutez des superpositions KDE pour montrer des formes de distribution lisses
• Choisissez histplot() pour l'intégration avec les sous-graphiques matplotlib et displot() pour les graphiques facettés autonomes

Que vous analysiez des notes d'examen, des mesures scientifiques ou des métriques commerciales, les histogrammes seaborn vous aident à comprendre la distribution de vos données et à communiquer efficacement les informations. Combinez ces techniques avec des outils interactifs comme PyGWalker pour une analyse exploratoire complète des données.