Seaborn Barplot : Le guide complet des graphiques en barres en Python

Name

Soren Atelier

Updated on 09/02/2026

Vous devez comparer des moyennes entre catégories. Peut-être s'agit-il du revenu moyen par région, des scores moyens aux tests par classe ou du temps de réponse médian par serveur. Un tableau brut de chiffres vous oblige à parcourir les lignes et à faire du calcul mental. Un graphique en barres bien construit rend la réponse évidente d'un seul coup d'oeil -- et la bibliothèque seaborn de Python vous permet d'en créer un avec un seul appel de fonction.

Le problème est que sns.barplot() possède un ensemble de paramètres étonnamment vaste. Le regroupement avec hue, le contrôle des barres d'erreur, la réorganisation des catégories, le choix des palettes, l'orientation horizontale -- chacun de ces aspects fait trébucher les débutants et même les utilisateurs expérimentés qui n'ont pas touché à la fonction depuis un moment. Des graphiques en barres mal configurés induisent les lecteurs en erreur ou sont tout simplement laids.

Ce guide couvre chaque cas d'utilisation pratique de sns.barplot(). Chaque bloc de code est prêt à copier-coller, utilise des jeux de données réels ou réalistes et produit une sortie propre. À la fin, vous saurez comment créer des graphiques en barres de qualité publication, comprendre la différence entre barplot et countplot, et aurez un chemin rapide vers l'exploration interactive avec PyGWalker.

Ce que fait sns.barplot()

sns.barplot() dessine un graphique en barres où la hauteur (ou la longueur) de chaque barre représente la tendance centrale d'une variable numérique pour chaque catégorie. Par défaut, il calcule la moyenne et dessine un intervalle de confiance à 95% sous forme de barre d'erreur au-dessus de chaque barre.

Cela le rend différent d'un simple graphique en barres basé sur le comptage. C'est une visualisation statistique : il agrège vos données avant de les tracer.

Syntaxe de base

import seaborn as sns
import matplotlib.pyplot as plt
 
sns.barplot(data=df, x="category_column", y="numeric_column")
plt.show()

Paramètres clés en un coup d'oeil :

Graphique en barres vertical simple

Commencez avec le jeu de données intégré tips. Ce DataFrame enregistre les additions de restaurant, les pourboires et les attributs des clients.

import seaborn as sns
import matplotlib.pyplot as plt
 
tips = sns.load_dataset("tips")
 
plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill")
plt.title("Average Total Bill by Day")
plt.ylabel("Average Total Bill ($)")
plt.xlabel("Day of Week")
plt.tight_layout()
plt.show()

Chaque barre montre la moyenne de total_bill pour ce jour. Les lignes noires au-dessus sont des intervalles de confiance à 95%, vous donnant une idée de la variation possible de la moyenne. Le jeudi a l'addition moyenne la plus basse, tandis que le dimanche tend à être plus élevé.

Pour changer la fonction d'agrégation, passez estimator :

import numpy as np
 
sns.barplot(data=tips, x="day", y="total_bill", estimator=np.median)
plt.title("Median Total Bill by Day")
plt.show()

Graphique en barres horizontal

Les barres horizontales fonctionnent mieux lorsque les étiquettes de catégorie sont longues ou lorsque vous avez de nombreuses catégories. Il existe deux façons de créer un barplot horizontal.

Option 1 : Intervertir x et y.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="total_bill", y="day")
plt.title("Average Total Bill by Day (Horizontal)")
plt.xlabel("Average Total Bill ($)")
plt.ylabel("")
plt.tight_layout()
plt.show()

Lorsque la colonne numérique est sur x et la colonne catégorielle sur y, seaborn dessine automatiquement des barres horizontales.

Option 2 : Utiliser le paramètre orient.

sns.barplot(data=tips, x="total_bill", y="day", orient="h")
plt.show()

Les deux approches produisent le même résultat. L'interversion de x et y est le modèle le plus courant.

Graphique en barres groupé (Hue)

Le paramètre hue divise chaque barre de catégorie en sous-barres basées sur une seconde variable catégorielle. C'est essentiel pour comparer des sous-groupes côte à côte.

plt.figure(figsize=(9, 5))
sns.barplot(data=tips, x="day", y="total_bill", hue="sex")
plt.title("Average Total Bill by Day and Gender")
plt.ylabel("Average Total Bill ($)")
plt.legend(title="Gender")
plt.tight_layout()
plt.show()

Chaque jour affiche maintenant deux barres -- une pour les hommes, une pour les femmes. La légende associe les couleurs aux groupes. Vous pouvez immédiatement voir que les clients masculins ont tendance à avoir des additions moyennes légèrement plus élevées la plupart des jours.

Pour trois niveaux de hue ou plus, les barres deviennent plus étroites. Si la lisibilité en souffre, envisagez une approche facettée avec sns.catplot() :

g = sns.catplot(data=tips, x="day", y="total_bill", hue="sex",
                col="time", kind="bar", height=4, aspect=1.2)
g.set_axis_labels("Day", "Average Total Bill ($)")
g.set_titles("{col_name}")
plt.tight_layout()
plt.show()

Cela crée des panneaux séparés pour le Déjeuner et le Dîner, chacun avec des barres groupées par genre -- beaucoup plus facile à lire lorsque vous avez plusieurs dimensions de regroupement.

Personnaliser les couleurs avec Palette

Le paramètre palette contrôle le schéma de couleurs. Seaborn est livré avec de nombreuses palettes intégrées.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill", hue="sex",
            palette="Set2")
plt.title("Custom Palette: Set2")
plt.tight_layout()
plt.show()

Choix de palettes populaires :

Vous pouvez aussi passer une liste de couleurs hexadécimales spécifiques :

sns.barplot(data=tips, x="day", y="total_bill",
            palette=["#2ecc71", "#e74c3c", "#3498db", "#f39c12"])
plt.show()

Ou utiliser un dictionnaire pour associer des catégories spécifiques à des couleurs :

day_colors = {"Thur": "#636e72", "Fri": "#e17055",
              "Sat": "#0984e3", "Sun": "#6c5ce7"}
sns.barplot(data=tips, x="day", y="total_bill", palette=day_colors)
plt.show()

Barres d'erreur et intervalles de confiance

Par défaut, sns.barplot() affiche un intervalle de confiance à 95%. Il s'agit de l'IC bootstrappé autour de la moyenne. Vous avez un contrôle total sur ce qui est affiché.

import matplotlib.pyplot as plt
import seaborn as sns
 
tips = sns.load_dataset("tips")
 
fig, axes = plt.subplots(1, 4, figsize=(18, 4), sharey=True)
 
# 95% CI (default)
sns.barplot(data=tips, x="day", y="total_bill", errorbar=("ci", 95), ax=axes[0])
axes[0].set_title("95% CI (default)")
 
# Standard deviation
sns.barplot(data=tips, x="day", y="total_bill", errorbar="sd", ax=axes[1])
axes[1].set_title("Standard Deviation")
 
# Standard error
sns.barplot(data=tips, x="day", y="total_bill", errorbar="se", ax=axes[2])
axes[2].set_title("Standard Error")
 
# No error bars
sns.barplot(data=tips, x="day", y="total_bill", errorbar=None, ax=axes[3])
axes[3].set_title("No Error Bars")
 
plt.tight_layout()
plt.show()

Note : Dans les anciennes versions de seaborn (avant 0.12), le paramètre s'appelait ci au lieu de errorbar. Si vous voyez ci=95 dans du code hérité, cela fait la même chose. Le seaborn moderne utilise errorbar pour plus de flexibilité.

Ordonner les barres

Par défaut, les barres apparaissent dans l'ordre où les catégories apparaissent dans vos données. Utilisez le paramètre order pour contrôler cela explicitement.

plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill",
            order=["Thur", "Fri", "Sat", "Sun"])
plt.title("Bars in Chronological Order")
plt.tight_layout()
plt.show()

Pour ordonner les barres par leur valeur (du plus grand au plus petit), calculez d'abord les moyennes :

day_order = tips.groupby("day")["total_bill"].mean().sort_values(ascending=False).index
 
plt.figure(figsize=(8, 5))
sns.barplot(data=tips, x="day", y="total_bill", order=day_order)
plt.title("Days Ordered by Average Bill (Descending)")
plt.tight_layout()
plt.show()

Ce modèle -- trier par la métrique agrégée -- est l'une des façons les plus courantes de rendre les graphiques en barres immédiatement informatifs.

sns.barplot() vs sns.countplot() -- Quand utiliser lequel

Ces deux fonctions se ressemblent mais servent des objectifs différents. Choisir la mauvaise est une source courante de confusion.

Règle générale : Si vous avez une colonne numérique que vous voulez agréger, utilisez barplot. Si vous voulez simplement compter combien de lignes tombent dans chaque catégorie, utilisez countplot.

fig, axes = plt.subplots(1, 2, figsize=(14, 5))
 
# barplot: average tip per day
sns.barplot(data=tips, x="day", y="tip", ax=axes[0])
axes[0].set_title("sns.barplot() -- Average Tip by Day")
axes[0].set_ylabel("Average Tip ($)")
 
# countplot: number of records per day
sns.countplot(data=tips, x="day", ax=axes[1])
axes[1].set_title("sns.countplot() -- Meals per Day")
axes[1].set_ylabel("Count")
 
plt.tight_layout()
plt.show()

Personnalisation avec Matplotlib

Puisque seaborn s'appuie sur matplotlib, vous avez un accès complet à la couche de personnalisation de matplotlib. C'est ainsi que vous ajoutez des titres, faites pivoter les étiquettes, ajustez les polices et annotez les barres.

Titres, étiquettes et rotation

plt.figure(figsize=(8, 5))
ax = sns.barplot(data=tips, x="day", y="total_bill", palette="muted")
 
ax.set_title("Average Total Bill by Day", fontsize=16, fontweight="bold")
ax.set_xlabel("Day of the Week", fontsize=12)
ax.set_ylabel("Average Bill ($)", fontsize=12)
ax.tick_params(axis='x', rotation=45)
 
plt.tight_layout()
plt.show()

Ajouter des étiquettes de valeur sur les barres

plt.figure(figsize=(8, 5))
ax = sns.barplot(data=tips, x="day", y="total_bill", errorbar=None,
                 palette="Blues_d",
                 order=["Thur", "Fri", "Sat", "Sun"])
 
# Annotate each bar with its value
for container in ax.containers:
    ax.bar_label(container, fmt="%.1f", fontsize=11, padding=3)
 
ax.set_title("Average Total Bill by Day")
ax.set_ylabel("Average Bill ($)")
ax.set_ylim(0, 25)
plt.tight_layout()
plt.show()

La méthode ax.bar_label() (ajoutée dans matplotlib 3.4) est la façon la plus propre d'ajouter des annotations de valeur. L'argument padding contrôle la distance par rapport au sommet de la barre.

Barres empilées (Solution de contournement)

Seaborn ne prend pas nativement en charge les graphiques en barres empilées. C'est un choix de conception délibéré -- les barres empilées rendent plus difficile la comparaison des tailles de segments individuels. Cependant, si votre cas d'utilisation les nécessite, vous pouvez obtenir l'effet avec le traçage pandas ou une approche manuelle matplotlib.

Avec Pandas .plot(kind="bar", stacked=True)

import pandas as pd
import matplotlib.pyplot as plt
 
tips = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv")
 
# Pivot to get counts per day and time
pivot = tips.groupby(["day", "time"]).size().unstack(fill_value=0)
 
# Reorder days
pivot = pivot.loc[["Thur", "Fri", "Sat", "Sun"]]
 
pivot.plot(kind="bar", stacked=True, figsize=(8, 5),
           color=["#3498db", "#e74c3c"], edgecolor="white")
plt.title("Meal Count by Day (Stacked by Lunch/Dinner)")
plt.ylabel("Number of Meals")
plt.xlabel("Day")
plt.xticks(rotation=0)
plt.legend(title="Time")
plt.tight_layout()
plt.show()

Empilement manuel avec Matplotlib

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
tips = sns.load_dataset("tips")
pivot = tips.groupby(["day", "time"])["total_bill"].mean().unstack(fill_value=0)
pivot = pivot.loc[["Thur", "Fri", "Sat", "Sun"]]
 
days = pivot.index
lunch = pivot["Lunch"].values
dinner = pivot["Dinner"].values
 
x = np.arange(len(days))
width = 0.6
 
fig, ax = plt.subplots(figsize=(8, 5))
ax.bar(x, lunch, width, label="Lunch", color="#3498db")
ax.bar(x, dinner, width, bottom=lunch, label="Dinner", color="#e74c3c")
 
ax.set_xticks(x)
ax.set_xticklabels(days)
ax.set_ylabel("Average Total Bill ($)")
ax.set_title("Average Bill by Day (Stacked: Lunch + Dinner)")
ax.legend()
plt.tight_layout()
plt.show()

Les deux approches fonctionnent. La méthode pandas est plus concise ; la méthode matplotlib vous donne plus de contrôle sur le positionnement et le style.

Créer des graphiques en barres interactifs avec PyGWalker

Les graphiques en barres statiques sont parfaits pour les rapports et les articles. Mais pendant l'analyse exploratoire, vous voulez souvent changer les axes, essayer différentes agrégations, filtrer les données et comparer les types de graphiques -- le tout sans réécrire du code à chaque fois.

PyGWalker (opens in a new tab) (liaison Python de Graphic Walker) transforme n'importe quel DataFrame pandas en une interface de visualisation interactive de type Tableau directement dans Jupyter Notebook. Vous pouvez construire des graphiques en barres, des graphiques en barres groupés et des dizaines d'autres types de graphiques en glissant-déposant des champs.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
tips = pd.read_csv("https://raw.githubusercontent.com/mwaskom/seaborn-data/master/tips.csv")
walker = pyg.walk(tips)

Une fois l'interface chargée, vous pouvez :

• Glisser day sur l'axe X et total_bill sur l'axe Y pour créer un graphique en barres instantanément.
• Déposer sex ou time dans le canal Couleur pour obtenir un graphique en barres groupé.
• Changer l'agrégation de moyenne à somme, médiane ou comptage en un seul clic.
• Appliquer des filtres (par exemple, seulement samedi et dimanche) sans écrire de code pandas.
• Exporter la configuration de votre graphique pour la reproductibilité.

C'est particulièrement utile pendant la phase d'exploration -- testez rapidement quels regroupements et agrégations révèlent le plus d'informations, puis verrouillez votre visualisation statique finale avec sns.barplot() pour le partage.

Questions fréquemment posées

Comment changer la couleur de barres individuelles dans sns.barplot() ?

Passez une liste de couleurs au paramètre palette. La longueur de la liste doit correspondre au nombre de catégories. Par exemple : sns.barplot(data=tips, x="day", y="total_bill", palette=["#e74c3c", "#3498db", "#2ecc71", "#f39c12"]). Vous pouvez aussi passer un dictionnaire associant des noms de catégories à des couleurs pour un contrôle explicite.

Quelle est la différence entre sns.barplot() et plt.bar() ?

sns.barplot() fonctionne directement avec les DataFrames, calcule automatiquement une statistique agrégée (par défaut : moyenne) et dessine des intervalles de confiance. plt.bar() de matplotlib nécessite des hauteurs et positions de barre précalculées -- il dessine exactement ce que vous lui donnez sans agrégation. Utilisez sns.barplot() pour des résumés statistiques rapides et plt.bar() pour un contrôle manuel complet.

Comment supprimer les barres d'erreur d'un barplot seaborn ?

Définissez errorbar=None dans l'appel de fonction : sns.barplot(data=tips, x="day", y="total_bill", errorbar=None). Dans les versions de seaborn antérieures à 0.12, utilisez ci=None à la place.

sns.barplot() peut-il afficher la somme au lieu de la moyenne ?

Oui. Passez estimator=sum à la fonction : sns.barplot(data=tips, x="day", y="total_bill", estimator=sum). Vous pouvez utiliser n'importe quelle fonction qui prend un tableau et retourne un scalaire, y compris numpy.median, numpy.std ou un lambda personnalisé.

Comment créer un barplot horizontal dans seaborn ?

Placez la colonne numérique sur l'axe x et la colonne catégorielle sur y : sns.barplot(data=tips, x="total_bill", y="day"). Seaborn détecte automatiquement l'orientation. Vous pouvez aussi définir explicitement orient="h".

Conclusion

Le barplot seaborn est le moyen le plus rapide de visualiser des métriques agrégées entre catégories en Python. D'une seule ligne montrant les valeurs moyennes avec des intervalles de confiance, aux comparaisons groupées avec hue, en passant par des graphiques entièrement stylisés avec des annotations de valeur -- sns.barplot() couvre toute la gamme des besoins en graphiques en barres.

Commencez simplement : passez votre DataFrame, choisissez vos colonnes x et y, et laissez seaborn gérer l'agrégation et le style. Puis ajoutez des personnalisations selon les besoins -- réorganisez les barres par valeur, passez à une disposition horizontale pour les longues étiquettes ou désactivez les barres d'erreur pour des diapositives de présentation plus propres.

Quand vous avez besoin de barres empilées, tournez-vous vers pandas ou matplotlib directement. Quand vous voulez explorer vos données de manière interactive avant de vous engager sur une configuration de graphique spécifique, PyGWalker (opens in a new tab) vous offre une interface glisser-déposer qui fonctionne dans Jupyter sans code supplémentaire.

Tous les exemples de code de ce guide sont prêts à copier et exécuter. Choisissez le modèle le plus proche de votre cas d'utilisation, substituez vos données, et vous aurez un graphique en barres clair et informatif en moins d'une minute.