Seaborn Barplot: La guía completa de gráficos de barras en Python

Name

Soren Atelier

Updated on 9/2/2026

Necesita comparar promedios entre categorías. Quizás sea el ingreso promedio por región, las puntuaciones medias de exámenes por aula o el tiempo de respuesta mediano por servidor. Una tabla de números en bruto le obliga a escanear filas y hacer cálculos mentales. Un gráfico de barras bien construido hace que la respuesta sea obvia de un vistazo -- y la biblioteca seaborn de Python le permite crear uno con una sola llamada a función.

El problema es que sns.barplot() tiene un conjunto de parámetros sorprendentemente profundo. Agrupar con hue, controlar las barras de error, reordenar categorías, elegir paletas, orientar horizontalmente -- cada uno de estos aspectos confunde a principiantes e incluso a usuarios experimentados que no han tocado la función en un tiempo. Los gráficos de barras mal configurados engañan a los lectores o simplemente se ven mal.

Esta guía cubre cada caso de uso práctico para sns.barplot(). Cada bloque de código está listo para copiar y pegar, usa conjuntos de datos reales o realistas y produce una salida limpia. Al final, sabrá cómo crear gráficos de barras con calidad de publicación, entenderá la diferencia entre barplot y countplot, y tendrá un camino rápido a la exploración interactiva con PyGWalker.

Qué hace sns.barplot()

sns.barplot() dibuja un gráfico de barras donde la altura (o longitud) de cada barra representa la tendencia central de una variable numérica para cada categoría. Por defecto, calcula la media y dibuja un intervalo de confianza del 95% como barra de error encima de cada barra.

Esto lo hace diferente de un gráfico de barras simple basado en conteo. Es una visualización estadística: agrega sus datos antes de graficar.

Sintaxis básica

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

Parámetros clave de un vistazo:

Gráfico de barras vertical simple

Comience con el conjunto de datos integrado tips. Este DataFrame registra cuentas de restaurante, propinas y atributos de los clientes.

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()

Cada barra muestra la media de total_bill para ese día. Las líneas negras en la parte superior son intervalos de confianza del 95%, que le dan una idea de cuánto podría variar la media. El jueves tiene la cuenta promedio más baja, mientras que el domingo tiende a ser más alta.

Para cambiar la función de agregación, pase 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()

Gráfico de barras horizontal

Las barras horizontales funcionan mejor cuando las etiquetas de categoría son largas o cuando tiene muchas categorías. Hay dos formas de crear un barplot horizontal.

Opción 1: Intercambiar x e 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()

Cuando la columna numérica está en x y la columna categórica en y, seaborn dibuja automáticamente barras horizontales.

Opción 2: Usar el parámetro orient.

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

Ambos enfoques producen el mismo resultado. Intercambiar x e y es el patrón más común.

Gráfico de barras agrupado (Hue)

El parámetro hue divide cada barra de categoría en sub-barras basadas en una segunda variable categórica. Esto es esencial para comparar subgrupos lado a lado.

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()

Cada día ahora muestra dos barras -- una para masculino, una para femenino. La leyenda mapea colores a grupos. Puede ver inmediatamente que los clientes masculinos tienden a tener cuentas promedio ligeramente más altas en la mayoría de los días.

Para tres o más niveles de hue, las barras se vuelven más estrechas. Si la legibilidad se ve afectada, considere un enfoque facetado con 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()

Esto crea paneles separados para Almuerzo y Cena, cada uno con barras agrupadas por género -- mucho más fácil de leer cuando tiene múltiples dimensiones de agrupación.

Personalizar colores con Palette

El parámetro palette controla el esquema de colores. Seaborn viene con muchas paletas integradas.

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()

Opciones de paleta populares:

También puede pasar una lista de colores hexadecimales específicos:

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

O usar un diccionario para mapear categorías específicas a colores:

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

Barras de error e intervalos de confianza

Por defecto, sns.barplot() muestra un intervalo de confianza del 95%. Este es el CI bootstrapped alrededor de la media. Tiene control total sobre lo que se muestra.

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()

Nota: En versiones anteriores de seaborn (antes de 0.12), el parámetro se llamaba ci en lugar de errorbar. Si ve ci=95 en código heredado, hace lo mismo. El seaborn moderno usa errorbar para mayor flexibilidad.

Ordenar barras

Por defecto, las barras aparecen en el orden en que las categorías aparecen en sus datos. Use el parámetro order para controlar esto explícitamente.

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()

Para ordenar barras por su valor (de mayor a menor), calcule primero las medias:

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()

Este patrón -- ordenar por la métrica agregada -- es una de las formas más comunes de hacer que los gráficos de barras sean inmediatamente informativos.

sns.barplot() vs sns.countplot() -- Cuándo usar cuál

Estas dos funciones se ven similares pero sirven para propósitos diferentes. Elegir la incorrecta es una fuente común de confusión.

Regla general: Si tiene una columna numérica que desea agregar, use barplot. Si solo quiere contar cuántas filas caen en cada categoría, use 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()

Personalización con Matplotlib

Como seaborn se construye sobre matplotlib, tiene acceso completo a la capa de personalización de matplotlib. Así es como añade títulos, rota etiquetas, ajusta fuentes y anota barras.

Títulos, etiquetas y rotación

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()

Añadir etiquetas de valor en las barras

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()

El método ax.bar_label() (añadido en matplotlib 3.4) es la forma más limpia de agregar anotaciones de valor. El argumento padding controla la distancia desde la parte superior de la barra.

Barras apiladas (Solución alternativa)

Seaborn no soporta nativamente gráficos de barras apiladas. Esta es una decisión de diseño deliberada -- las barras apiladas dificultan la comparación de tamaños de segmentos individuales. Sin embargo, si su caso de uso las requiere, puede lograr el efecto con el plotting de pandas o un enfoque manual de matplotlib.

Usando 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()

Apilamiento manual con 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()

Ambos enfoques funcionan. El método de pandas es más conciso; el método de matplotlib le da más control sobre el posicionamiento y el estilo.

Crear gráficos de barras interactivos con PyGWalker

Los gráficos de barras estáticos son geniales para informes y artículos. Pero durante el análisis exploratorio, a menudo quiere cambiar ejes, probar diferentes agregaciones, filtrar datos y comparar tipos de gráficos -- todo sin reescribir código cada vez.

PyGWalker (opens in a new tab) (enlace Python de Graphic Walker) convierte cualquier DataFrame de pandas en una interfaz de visualización interactiva similar a Tableau directamente dentro de Jupyter Notebook. Puede construir gráficos de barras, gráficos de barras agrupados y docenas de otros tipos de gráficos arrastrando y soltando campos.

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)

Una vez que la interfaz se carga, puede:

• Arrastrar day al eje X y total_bill al eje Y para crear un gráfico de barras instantáneamente.
• Soltar sex o time en el canal de Color para obtener un gráfico de barras agrupado.
• Cambiar la agregación de media a suma, mediana o conteo con un solo clic.
• Aplicar filtros (por ejemplo, solo sábado y domingo) sin escribir código pandas.
• Exportar la configuración de su gráfico para reproducibilidad.

Esto es particularmente útil durante la fase de exploración -- pruebe rápidamente qué agrupaciones y agregaciones revelan más información, luego fije su visualización estática final con sns.barplot() para compartir.

Preguntas frecuentes

¿Cómo cambio el color de barras individuales en sns.barplot()?

Pase una lista de colores al parámetro palette. La longitud de la lista debe coincidir con el número de categorías. Por ejemplo: sns.barplot(data=tips, x="day", y="total_bill", palette=["#e74c3c", "#3498db", "#2ecc71", "#f39c12"]). También puede pasar un diccionario que mapee nombres de categorías a colores para un control explícito.

¿Cuál es la diferencia entre sns.barplot() y plt.bar()?

sns.barplot() trabaja directamente con DataFrames, calcula automáticamente una estadística agregada (predeterminado: media) y dibuja intervalos de confianza. plt.bar() de matplotlib requiere alturas y posiciones de barra precalculadas -- dibuja exactamente lo que le da sin agregación. Use sns.barplot() para resúmenes estadísticos rápidos y plt.bar() para control manual completo.

¿Cómo elimino las barras de error de un barplot de seaborn?

Establezca errorbar=None en la llamada a la función: sns.barplot(data=tips, x="day", y="total_bill", errorbar=None). En versiones de seaborn anteriores a 0.12, use ci=None en su lugar.

¿Puede sns.barplot() mostrar la suma en lugar de la media?

Sí. Pase estimator=sum a la función: sns.barplot(data=tips, x="day", y="total_bill", estimator=sum). Puede usar cualquier función que tome un array y devuelva un escalar, incluyendo numpy.median, numpy.std o un lambda personalizado.

¿Cómo hago un barplot horizontal en seaborn?

Coloque la columna numérica en el eje x y la columna categórica en y: sns.barplot(data=tips, x="total_bill", y="day"). Seaborn detecta la orientación automáticamente. También puede establecer explícitamente orient="h".

Conclusión

El barplot de seaborn es la forma más rápida de visualizar métricas agregadas entre categorías en Python. Desde una sola línea que muestra valores medios con intervalos de confianza, hasta comparaciones agrupadas con hue, hasta gráficos completamente estilizados con anotaciones de valor -- sns.barplot() cubre toda la gama de necesidades de gráficos de barras.

Comience simple: pase su DataFrame, elija sus columnas x e y, y deje que seaborn maneje la agregación y el estilo. Luego añada personalizaciones según sea necesario -- reordene barras por valor, cambie a un diseño horizontal para etiquetas largas o desactive las barras de error para diapositivas de presentación más limpias.

Cuando necesite barras apiladas, recurra directamente a pandas o matplotlib. Cuando quiera explorar sus datos de forma interactiva antes de comprometerse con una configuración de gráfico específica, PyGWalker (opens in a new tab) le ofrece una interfaz de arrastrar y soltar que funciona dentro de Jupyter sin código adicional.

Todos los ejemplos de código en esta guía están listos para copiar y ejecutar. Elija el patrón más cercano a su caso de uso, sustituya sus datos, y tendrá un gráfico de barras claro e informativo en menos de un minuto.