Histograma de Seaborn: Crear gráficos de distribución en Python

Name

Soren Atelier

Updated on 9/2/2026

Comprender la distribución de sus datos es fundamental para el análisis estadístico y la toma de decisiones. Sin embargo, muchos profesionales de datos tienen dificultades para crear gráficos de distribución claros e informativos que revelen patrones y valores atípicos. Las herramientas de trazado genéricas a menudo requieren una personalización extensa y producen resultados visualmente poco atractivos.

Las funciones de histograma de Seaborn resuelven este problema al proporcionar una interfaz de alto nivel para crear hermosos gráficos de distribución con un código mínimo. La biblioteca selecciona automáticamente valores predeterminados apropiados para tamaños de bins, colores y estilos, mientras le brinda un control detallado cuando sea necesario.

Esta guía cubre todo lo que necesita para dominar los histogramas en seaborn, desde gráficos básicos hasta técnicas avanzadas de personalización. Aprenderá a usar sns.histplot() y sns.displot(), controlar estrategias de agrupamiento, superponer curvas KDE, comparar múltiples distribuciones y evitar errores comunes.

¿Qué es un histograma?

Un histograma muestra la distribución de una variable continua dividiendo el rango de datos en bins y contando el número de observaciones en cada bin. La altura de cada barra representa la frecuencia o densidad de puntos de datos dentro de ese rango de bin.

Los histogramas le ayudan a identificar:

• La tendencia central (donde se agrupan la mayoría de los valores)
• La dispersión y variabilidad de los datos
• Asimetría y valores atípicos
• Distribuciones multimodales (múltiples picos)

Seaborn proporciona dos funciones principales para crear histogramas: histplot() para gráficos a nivel de ejes y displot() para gráficos a nivel de figura con soporte de facetado automático.

Histograma básico con sns.histplot()

La función histplot() es la herramienta principal para crear histogramas en seaborn. Ofrece una interfaz simple con potentes opciones de personalización.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Generar datos de muestra
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
 
# Crear histograma básico
sns.histplot(data=data)
plt.title('Histograma básico de Seaborn')
plt.xlabel('Valor')
plt.ylabel('Conteo')
plt.show()

Esto crea un histograma con tamaños de bin determinados automáticamente según la regla de Freedman-Diaconis, que equilibra detalle y ruido.

Para datos en un DataFrame:

import pandas as pd
 
# Crear DataFrame
df = pd.DataFrame({
    'values': np.random.normal(100, 15, 1000),
    'category': np.random.choice(['A', 'B', 'C'], 1000)
})
 
# Trazar histograma desde DataFrame
sns.histplot(data=df, x='values')
plt.show()

Control de bins: tamaño, número y rango

La selección de bins afecta dramáticamente cómo su histograma revela patrones. Muy pocos bins simplifican demasiado la distribución, mientras que demasiados bins crean ruido.

Especificar número de bins

# Crear histograma con 30 bins
sns.histplot(data=data, bins=30)
plt.title('Histograma con 30 bins')
plt.show()

Establecer ancho de bin

# Establecer ancho de bin específico
sns.histplot(data=data, binwidth=5)
plt.title('Histograma con ancho de bin = 5')
plt.show()

Definir bordes de bin

# Bordes de bin personalizados
bin_edges = [70, 80, 90, 100, 110, 120, 130]
sns.histplot(data=data, bins=bin_edges)
plt.title('Histograma con bordes de bin personalizados')
plt.show()

Controlar rango de bin

# Limitar rango de histograma
sns.histplot(data=data, binrange=(80, 120))
plt.title('Histograma con rango limitado (80-120)')
plt.show()

Agregar superposición KDE

La estimación de densidad de kernel (KDE) proporciona una estimación suave de la función de densidad de probabilidad, ayudándole a ver la forma general de la distribución.

# Histograma con superposición KDE
sns.histplot(data=data, kde=True)
plt.title('Histograma con superposición KDE')
plt.show()

También puede mostrar solo la curva KDE:

# Solo KDE (sin barras de histograma)
sns.kdeplot(data=data)
plt.title('Solo curva KDE')
plt.show()

O combinar múltiples visualizaciones:

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Solo histograma
sns.histplot(data=data, ax=axes[0])
axes[0].set_title('Solo histograma')
 
# Solo KDE
sns.kdeplot(data=data, ax=axes[1])
axes[1].set_title('Solo KDE')
 
# Ambos combinados
sns.histplot(data=data, kde=True, ax=axes[2])
axes[2].set_title('Histograma + KDE')
 
plt.tight_layout()
plt.show()

Comprender el parámetro stat

El parámetro stat controla qué estadística se calcula para cada bin, afectando la interpretación del eje 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}"')
 
# Eliminar subplot adicional
fig.delaxes(axes[1, 2])
 
plt.tight_layout()
plt.show()

Use density al comparar distribuciones con diferentes tamaños de muestra, ya que normaliza el histograma para que el área total sea igual a 1.

Comparar múltiples distribuciones con hue

El parámetro hue le permite comparar distribuciones a través de diferentes categorías en un solo gráfico.

# Crear datos de múltiples categorías
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
})
 
# Trazar con hue
sns.histplot(data=df, x='values', hue='group', kde=True)
plt.title('Múltiples distribuciones por grupo')
plt.show()

Controlar comportamiento de superposición con multiple

El parámetro multiple determina cómo se muestran múltiples distribuciones:

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

Uso de sns.displot() para gráficos a nivel de figura

Mientras que histplot() es una función a nivel de ejes, displot() es una función a nivel de figura que proporciona capacidades adicionales como facetado automático.

# Displot básico (crea figura completa)
sns.displot(data=df, x='values', hue='group', kde=True)
plt.show()

Ventajas de displot()

1. Facetado automático con parámetros col y row
2. Tamaño consistente en todos los subgráficos
3. Leyenda fuera del gráfico de forma predeterminada
4. Cambio fácil entre histograma, KDE y ECDF

# Agregar dimensión de facetado
df['dataset'] = np.random.choice(['Train', 'Test'], len(df))
 
# Crear gráfico facetado
sns.displot(data=df, x='values', hue='group',
            col='dataset', kde=True, height=4, aspect=1.2)
plt.show()

Cambiar tipos de gráfico con kind

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Histograma
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 (Función de distribución acumulativa empírica)
sns.displot(data=df, x='values', kind='ecdf')
plt.title('kind="ecdf"')
 
plt.tight_layout()
plt.show()

Tabla de comparación de funciones

Recomendación: Use histplot() cuando cree múltiples subgráficos con plt.subplots(). Use displot() para visualizaciones independientes o cuando necesite facetado.

Referencia de parámetros de histplot()

Personalización avanzada

Colores y estilos personalizados

# Colores personalizados para cada categoría
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('Histograma con colores personalizados')
plt.show()

Colores de borde y transparencia

# Enfatizar bordes de bin
sns.histplot(data=data, bins=20, edgecolor='black',
             linewidth=2, alpha=0.7, color='skyblue')
plt.title('Histograma con bordes prominentes')
plt.show()

Escala logarítmica

Para datos que abarcan múltiples órdenes de magnitud, use escalas logarítmicas:

# Generar datos log-normales
log_data = np.random.lognormal(3, 1, 1000)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Escala lineal
sns.histplot(data=log_data, ax=axes[0])
axes[0].set_title('Escala lineal')
 
# Escala logarítmica
sns.histplot(data=log_data, log_scale=True, ax=axes[1])
axes[1].set_title('Escala logarítmica')
 
plt.tight_layout()
plt.show()

Distribuciones acumulativas

Los histogramas acumulativos muestran el total acumulado de observaciones hasta cada bin:

# Histograma acumulativo
sns.histplot(data=data, cumulative=True, stat='density',
             element='step', fill=False)
plt.title('Distribución acumulativa')
plt.ylabel('Densidad acumulativa')
plt.show()

Esto es útil para determinar percentiles y comparar distribuciones.

Cambiar elemento visual

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

Histogramas bivariados (histogramas 2D)

Seaborn puede crear histogramas 2D para visualizar la distribución conjunta de dos variables:

# Generar datos 2D correlacionados
np.random.seed(42)
x = np.random.normal(100, 15, 1000)
y = x + np.random.normal(0, 10, 1000)
 
# Histograma 2D
sns.histplot(x=x, y=y, bins=30, cbar=True)
plt.title('Histograma 2D (distribución bivariada)')
plt.show()

Combinar con KDE para análisis bivariado

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

Bivariado con Hue

# Agregar categoría
categories = np.random.choice(['Grupo 1', 'Grupo 2'], 1000)
 
sns.histplot(x=x, y=y, hue=categories, bins=20)
plt.title('Histograma 2D con Hue')
plt.show()

Errores comunes y cómo evitarlos

Error 1: Usar demasiados o muy pocos bins

Problema: El suavizado excesivo oculta patrones, mientras que demasiados bins crean ruido.

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Muy pocos bins
sns.histplot(data=data, bins=5, ax=axes[0])
axes[0].set_title('Muy pocos bins (5) - Sobre-suavizado')
 
# Buen número
sns.histplot(data=data, bins=30, ax=axes[1])
axes[1].set_title('Bins apropiados (30)')
 
# Demasiados bins
sns.histplot(data=data, bins=100, ax=axes[2])
axes[2].set_title('Demasiados bins (100) - Ruidoso')
 
plt.tight_layout()
plt.show()

Solución: Comience con selección automática de bins, luego ajuste según las características de sus datos. Use la regla de Sturges (bins = log2(n) + 1) para distribuciones normales o la regla de Freedman-Diaconis para datos sesgados.

Error 2: Comparar distribuciones con diferentes tamaños de muestra

Problema: Los conteos brutos dificultan la comparación de distribuciones con diferentes observaciones totales.

# Diferentes tamaños de muestra
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': ['Pequeña (n=200)'] * 200 + ['Grande (n=2000)'] * 2000
})
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Incorrecto: usar count
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='count', ax=axes[0])
axes[0].set_title('Incorrecto: Count (difícil de comparar)')
 
# Correcto: usar density
sns.histplot(data=df_samples, x='value', hue='sample',
             stat='density', common_norm=False, ax=axes[1])
axes[1].set_title('Correcto: Density (fácil de comparar)')
 
plt.tight_layout()
plt.show()

Solución: Use stat='density' o stat='probability' y establezca common_norm=False.

Error 3: Ignorar distribuciones superpuestas

Problema: El modo de capa predeterminado con alta opacidad hace invisibles las superposiciones.

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Malo: barras opacas ocultan superposición
sns.histplot(data=df, x='values', hue='group',
             alpha=1.0, ax=axes[0])
axes[0].set_title('Malo: Barras opacas')
 
# Bueno: transparencia muestra superposición
sns.histplot(data=df, x='values', hue='group',
             alpha=0.5, ax=axes[1])
axes[1].set_title('Bueno: Barras transparentes')
 
plt.tight_layout()
plt.show()

Solución: Use alpha=0.5 para transparencia o multiple='dodge' para colocar barras lado a lado.

Error 4: No etiquetar ejes correctamente

Problema: No está claro qué representa el eje y, especialmente al usar diferentes valores de stat.

# Buena práctica: etiquetas claras
sns.histplot(data=data, stat='density', kde=True)
plt.title('Distribución de valores')
plt.xlabel('Valor')
plt.ylabel('Densidad')
plt.show()

Solución: Siempre etiquete los ejes claramente, especialmente el eje y cuando use stat='density' o stat='probability'.

Error 5: Usar distplot() obsoleto

Problema: El código antiguo usa distplot(), que está obsoleto y es menos flexible.

# Forma antigua (obsoleta)
# sns.distplot(data)  # No use esto
 
# Nueva forma
sns.histplot(data=data, kde=True)
plt.show()

Solución: Migre a histplot() para histogramas o kdeplot() para curvas KDE.

Visualizar datos de forma interactiva con PyGWalker

Mientras que seaborn proporciona excelentes visualizaciones de histogramas estáticos, PyGWalker ofrece una alternativa interactiva que le permite explorar distribuciones dinámicamente. PyGWalker transforma su DataFrame de pandas en una interfaz interactiva similar a Tableau donde puede crear histogramas, ajustar el agrupamiento y cambiar entre tipos de visualización sin escribir código.

import pygwalker as pyg
import pandas as pd
import numpy as np
 
# Crear datos de muestra
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)
})
 
# Iniciar explorador interactivo
pyg.walk(df)

Ventajas de PyGWalker para análisis de histogramas:

• Interfaz de arrastrar y soltar: Cree histogramas arrastrando variables a estantes
• Agrupamiento dinámico: Ajuste el número de bins de forma interactiva con controles deslizantes
• Exploración de múltiples variables: Cambie rápidamente entre variables para comparar distribuciones
• Capacidades de exportación: Guarde información como imágenes o comparta informes interactivos
• No se requiere codificación: Los miembros del equipo no técnicos pueden explorar datos de forma independiente

Visite github.com/Kanaries/pygwalker (opens in a new tab) para comenzar con la visualización de datos interactiva.

Ejemplo del mundo real: Analizar calificaciones de exámenes

Apliquemos técnicas de histograma para analizar distribuciones de calificaciones de exámenes en diferentes clases:

# Generar datos de examen realistas
np.random.seed(42)
n_students = 500
 
exam_data = pd.DataFrame({
    'score': np.concatenate([
        np.random.normal(75, 10, 200),  # Clase A
        np.random.normal(68, 15, 150),  # Clase B
        np.random.normal(82, 8, 150)    # Clase C
    ]),
    'class': ['Clase A'] * 200 + ['Clase B'] * 150 + ['Clase C'] * 150,
    'study_hours': np.random.uniform(0, 40, n_students)
})
 
# Recortar puntuaciones a rango válido
exam_data['score'] = exam_data['score'].clip(0, 100)
 
# Crear visualización completa
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Distribución general con KDE
sns.histplot(data=exam_data, x='score', kde=True,
             bins=30, ax=axes[0, 0])
axes[0, 0].set_title('Distribución general de calificaciones')
axes[0, 0].axvline(exam_data['score'].mean(), color='red',
                    linestyle='--', label=f'Media: {exam_data["score"].mean():.1f}')
axes[0, 0].legend()
 
# Comparar clases
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('Distribución de calificaciones por clase')
 
# Vista apilada para proporciones
sns.histplot(data=exam_data, x='score', hue='class',
             multiple='stack', bins=25, ax=axes[1, 0])
axes[1, 0].set_title('Distribución apilada (conteos totales)')
 
# Distribuciones acumulativas
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('Distribución acumulativa por clase')
 
plt.tight_layout()
plt.show()
 
# Imprimir estadísticas resumidas
print(exam_data.groupby('class')['score'].describe())

Este ejemplo demuestra:

• Análisis de distribución general con línea de referencia de media
• Comparación de densidad normalizada para diferentes tamaños de clase
• Visualización apilada que muestra la contribución de cada clase
• Distribuciones acumulativas para análisis de percentiles

FAQ

¿Cómo elijo el número correcto de bins para mi histograma?

El número óptimo de bins depende del tamaño y distribución de sus datos. La selección automática de bins de Seaborn (basada en la regla de Freedman-Diaconis) funciona bien para la mayoría de los casos. Para selección manual, use la regla de Sturges: bins = log2(n) + 1 para distribuciones normales (típicamente 10-20 bins para 1000 muestras), o regla de raíz cuadrada: bins = sqrt(n) para datos generales. Experimente con diferentes valores y elija el que revele patrones sin crear ruido excesivo. Use binwidth en lugar de bins cuando necesite tamaños de bin consistentes en múltiples gráficos para comparación.

¿Cuál es la diferencia entre histplot y displot en seaborn?

histplot() es una función a nivel de ejes que traza en un objeto de ejes matplotlib específico, lo que la hace adecuada para crear figuras complejas de múltiples gráficos con plt.subplots(). displot() es una función a nivel de figura que crea una figura completa y admite facetado automático con parámetros col y row. Use histplot() al integrar histogramas en figuras matplotlib existentes con múltiples subgráficos. Use displot() para visualizaciones independientes o cuando necesite crear gráficos facetados en múltiples variables categóricas. Ambas funciones admiten los mismos parámetros principales para controlar bins, KDE, hue y estadísticas.

¿Debo usar stat='density' o stat='probability' para mi histograma?

Use stat='density' cuando necesite que el área del histograma sea igual a 1, lo que lo hace comparable con funciones de densidad de probabilidad e ideal para superponer distribuciones teóricas. Use stat='probability' (o stat='percent') cuando desee interpretar el eje y como la proporción de datos en cada bin, con todas las alturas de bin sumando 1 (o 100%). Elija stat='density' para comparar distribuciones con diferentes tamaños de muestra o al realizar análisis estadístico. Elija stat='probability' para una interpretación más intuitiva en presentaciones o al explicar resultados a audiencias no técnicas.

¿Cómo creo un histograma con múltiples distribuciones superpuestas?

Use el parámetro hue para especificar una variable categórica que divide sus datos en grupos. Controle el comportamiento de superposición con el parámetro multiple: use 'layer' (predeterminado) para barras superpuestas transparentes, 'dodge' para barras lado a lado, 'stack' para barras apiladas verticalmente que muestran totales, o 'fill' para barras apiladas normalizadas que muestran proporciones. Establezca alpha=0.5 para hacer visibles las regiones superpuestas. Al comparar distribuciones con diferentes tamaños de muestra, siempre use stat='density' o stat='probability' con common_norm=False para garantizar una comparación justa. Agregue curvas KDE con kde=True para resaltar la forma general de cada distribución.

¿Por qué está obsoleto distplot de seaborn y qué debo usar en su lugar?

Seaborn depreció distplot() en la versión 0.11.0 porque combinaba múltiples funcionalidades en una sola función con nomenclatura de parámetros inconsistente. Las funciones de reemplazo proporcionan interfaces más claras y mayor flexibilidad: use histplot() para histogramas, kdeplot() para estimación de densidad de kernel, ecdfplot() para funciones de distribución acumulativa empírica y rugplot() para gráficos de alfombra. Estas nuevas funciones ofrecen mejores nombres de parámetros, más opciones de personalización, soporte nativo para agrupación basada en hue y comportamiento consistente con otras funciones de seaborn. Para migrar código antiguo, reemplace sns.distplot(data) con sns.histplot(data, kde=True) para el caso de uso más común.

Conclusión

Los histogramas de Seaborn proporcionan una forma poderosa y flexible de visualizar distribuciones de datos con un código mínimo. La función histplot() ofrece un control detallado sobre agrupamiento, estadísticas y agrupación, mientras que displot() simplifica las visualizaciones facetadas. Al dominar parámetros como bins, stat, hue y multiple, puede crear gráficos de distribución de calidad de publicación que revelan patrones, valores atípicos y diferencias entre grupos.

Puntos clave:

• Use selección automática de bins para exploración inicial, luego ajuste para claridad
• Aplique stat='density' al comparar distribuciones con diferentes tamaños de muestra
• Aproveche los parámetros hue y multiple para comparar múltiples distribuciones de manera efectiva
• Agregue superposiciones KDE para mostrar formas de distribución suaves
• Elija histplot() para integración con subgráficos matplotlib y displot() para gráficos facetados independientes

Ya sea que esté analizando calificaciones de exámenes, mediciones científicas o métricas comerciales, los histogramas de seaborn le ayudan a comprender la distribución de sus datos y comunicar información de manera efectiva. Combine estas técnicas con herramientas interactivas como PyGWalker para un análisis exploratorio de datos completo.