Histograma Seaborn: Criar gráficos de distribuição em Python

Name

Soren Atelier

Updated on 09/02/2026

Compreender a distribuição dos seus dados é fundamental para análise estatística e tomada de decisões. No entanto, muitos profissionais de dados têm dificuldade em criar gráficos de distribuição claros e informativos que revelem padrões e outliers. Ferramentas de plotagem genéricas geralmente requerem personalização extensa e produzem resultados visualmente pouco atraentes.

As funções de histograma do Seaborn resolvem este problema fornecendo uma interface de alto nível para criar belos gráficos de distribuição com código mínimo. A biblioteca seleciona automaticamente padrões apropriados para tamanhos de bins, cores e estilo, ao mesmo tempo que lhe dá controle refinado quando necessário.

Este guia cobre tudo o que você precisa para dominar histogramas em seaborn, desde gráficos básicos até técnicas avançadas de personalização. Você aprenderá a usar sns.histplot() e sns.displot(), controlar estratégias de agrupamento, sobrepor curvas KDE, comparar várias distribuições e evitar armadilhas comuns.

O que é um histograma?

Um histograma exibe a distribuição de uma variável contínua dividindo o intervalo de dados em bins e contando o número de observações em cada bin. A altura de cada barra representa a frequência ou densidade de pontos de dados dentro desse intervalo de bin.

Os histogramas ajudam você a identificar:

• A tendência central (onde a maioria dos valores se agrupa)
• A dispersão e variabilidade dos dados
• Assimetria e outliers
• Distribuições multimodais (vários picos)

Seaborn fornece duas funções principais para criar histogramas: histplot() para gráficos em nível de eixos e displot() para gráficos em nível de figura com suporte automático de facetamento.

Histograma básico com sns.histplot()

A função histplot() é a ferramenta principal para criar histogramas em seaborn. Oferece uma interface simples com poderosas opções de personalização.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Gerar dados de amostra
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
 
# Criar histograma básico
sns.histplot(data=data)
plt.title('Histograma básico Seaborn')
plt.xlabel('Valor')
plt.ylabel('Contagem')
plt.show()

Isto cria um histograma com tamanhos de bin determinados automaticamente com base na regra de Freedman-Diaconis, que equilibra detalhe e ruído.

Para dados em um DataFrame:

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

Controlando bins: tamanho, número e intervalo

A seleção de bins afeta dramaticamente como seu histograma revela padrões. Poucos bins simplificam demais a distribuição, enquanto muitos bins criam ruído.

Especificar número de bins

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

Definir largura do bin

# Definir largura de bin específica
sns.histplot(data=data, binwidth=5)
plt.title('Histograma com largura de bin = 5')
plt.show()

Definir bordas do bin

# Bordas de bin personalizadas
bin_edges = [70, 80, 90, 100, 110, 120, 130]
sns.histplot(data=data, bins=bin_edges)
plt.title('Histograma com bordas de bin personalizadas')
plt.show()

Controlar intervalo de bin

# Limitar intervalo do histograma
sns.histplot(data=data, binrange=(80, 120))
plt.title('Histograma com intervalo limitado (80-120)')
plt.show()

Adicionando sobreposição KDE

A Estimativa de Densidade de Kernel (KDE) fornece uma estimativa suave da função de densidade de probabilidade, ajudando você a ver a forma geral da distribuição.

# Histograma com sobreposição KDE
sns.histplot(data=data, kde=True)
plt.title('Histograma com sobreposição KDE')
plt.show()

Você também pode mostrar apenas a curva KDE:

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

Ou combinar várias visualizações:

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

Compreendendo o parâmetro stat

O parâmetro stat controla qual estatística é calculada para cada bin, afetando a interpretação do eixo 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}"')
 
# Remover subplot extra
fig.delaxes(axes[1, 2])
 
plt.tight_layout()
plt.show()

Use density ao comparar distribuições com diferentes tamanhos de amostra, pois normaliza o histograma para que a área total seja igual a 1.

Comparando várias distribuições com hue

O parâmetro hue permite comparar distribuições em diferentes categorias em um único gráfico.

# Criar dados de múltiplas categorias
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
})
 
# Plotar com hue
sns.histplot(data=df, x='values', hue='group', kde=True)
plt.title('Múltiplas distribuições por grupo')
plt.show()

Controlar comportamento de sobreposição com multiple

O parâmetro multiple determina como várias distribuições são exibidas:

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

Usando sns.displot() para gráficos em nível de figura

Enquanto histplot() é uma função em nível de eixos, displot() é uma função em nível de figura que fornece recursos adicionais como facetamento automático.

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

Vantagens do displot()

1. Facetamento automático com parâmetros col e row
2. Dimensionamento consistente entre subgráficos
3. Legenda fora do gráfico por padrão
4. Alternância fácil entre histograma, KDE e ECDF

# Adicionar dimensão de facetamento
df['dataset'] = np.random.choice(['Train', 'Test'], len(df))
 
# Criar gráfico facetado
sns.displot(data=df, x='values', hue='group',
            col='dataset', kde=True, height=4, aspect=1.2)
plt.show()

Alternar tipos de gráfico com 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 (Função de Distribuição Cumulativa Empírica)
sns.displot(data=df, x='values', kind='ecdf')
plt.title('kind="ecdf"')
 
plt.tight_layout()
plt.show()

Tabela de comparação de funções

Recomendação: Use histplot() ao criar vários subgráficos com plt.subplots(). Use displot() para visualizações independentes ou quando precisar de facetamento.

Referência de parâmetros do histplot()

Personalização avançada

Cores e estilo personalizados

# Cores personalizadas para cada categoria
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 com cores personalizadas')
plt.show()

Cores de borda e transparência

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

Escala logarítmica

Para dados que abrangem várias ordens de magnitude, use escalas logarítmicas:

# Gerar dados log-normais
log_data = np.random.lognormal(3, 1, 1000)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Escala linear
sns.histplot(data=log_data, ax=axes[0])
axes[0].set_title('Escala linear')
 
# 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()

Distribuições cumulativas

Histogramas cumulativos mostram o total acumulado de observações até cada bin:

# Histograma cumulativo
sns.histplot(data=data, cumulative=True, stat='density',
             element='step', fill=False)
plt.title('Distribuição cumulativa')
plt.ylabel('Densidade cumulativa')
plt.show()

Isto é útil para determinar percentis e comparar distribuições.

Alterar 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 pode criar histogramas 2D para visualizar a distribuição conjunta de duas variáveis:

# Gerar dados 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 (distribuição bivariada)')
plt.show()

Combinar com KDE para análise bivariada

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 com Hue

# Adicionar categoria
categories = np.random.choice(['Grupo 1', 'Grupo 2'], 1000)
 
sns.histplot(x=x, y=y, hue=categories, bins=20)
plt.title('Histograma 2D com Hue')
plt.show()

Erros comuns e como evitá-los

Erro 1: Usar muitos ou poucos bins

Problema: Suavização excessiva oculta padrões, enquanto muitos bins criam ruído.

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# Poucos bins
sns.histplot(data=data, bins=5, ax=axes[0])
axes[0].set_title('Poucos bins (5) - Suavizado demais')
 
# Bom número
sns.histplot(data=data, bins=30, ax=axes[1])
axes[1].set_title('Bins apropriados (30)')
 
# Muitos bins
sns.histplot(data=data, bins=100, ax=axes[2])
axes[2].set_title('Muitos bins (100) - Ruidoso')
 
plt.tight_layout()
plt.show()

Solução: Comece com seleção automática de bins, depois ajuste com base nas características dos seus dados. Use a regra de Sturges (bins = log2(n) + 1) para distribuições normais ou a regra de Freedman-Diaconis para dados assimétricos.

Erro 2: Comparar distribuições com diferentes tamanhos de amostra

Problema: Contagens brutas tornam difícil comparar distribuições com diferentes observações totais.

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

Solução: Use stat='density' ou stat='probability' e defina common_norm=False.

Erro 3: Ignorar distribuições sobrepostas

Problema: Modo de camada padrão com alta opacidade torna sobreposições invisíveis.

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
 
# Ruim: barras opacas ocultam sobreposição
sns.histplot(data=df, x='values', hue='group',
             alpha=1.0, ax=axes[0])
axes[0].set_title('Ruim: Barras opacas')
 
# Bom: transparência mostra sobreposição
sns.histplot(data=df, x='values', hue='group',
             alpha=0.5, ax=axes[1])
axes[1].set_title('Bom: Barras transparentes')
 
plt.tight_layout()
plt.show()

Solução: Use alpha=0.5 para transparência ou multiple='dodge' para colocar barras lado a lado.

Erro 4: Não rotular eixos adequadamente

Problema: Não está claro o que o eixo y representa, especialmente ao usar diferentes valores stat.

# Boa prática: rótulos claros
sns.histplot(data=data, stat='density', kde=True)
plt.title('Distribuição de valores')
plt.xlabel('Valor')
plt.ylabel('Densidade')
plt.show()

Solução: Sempre rotule os eixos claramente, especialmente o eixo y ao usar stat='density' ou stat='probability'.

Erro 5: Usar distplot() obsoleto

Problema: Código antigo usa distplot(), que está obsoleto e é menos flexível.

# Forma antiga (obsoleta)
# sns.distplot(data)  # Não use isto
 
# Nova forma
sns.histplot(data=data, kde=True)
plt.show()

Solução: Migre para histplot() para histogramas ou kdeplot() para curvas KDE.

Visualizar dados interativamente com PyGWalker

Enquanto seaborn fornece excelentes visualizações de histograma estático, PyGWalker oferece uma alternativa interativa que permite explorar distribuições dinamicamente. PyGWalker transforma seu DataFrame pandas em uma interface interativa semelhante ao Tableau, onde você pode criar histogramas, ajustar agrupamentos e alternar entre tipos de visualização sem escrever código.

import pygwalker as pyg
import pandas as pd
import numpy as np
 
# Criar dados de amostra
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 interativo
pyg.walk(df)

Vantagens do PyGWalker para análise de histograma:

• Interface de arrastar e soltar: Crie histogramas arrastando variáveis para prateleiras
• Agrupamento dinâmico: Ajuste contagens de bins interativamente com controles deslizantes
• Exploração de múltiplas variáveis: Alterne rapidamente entre variáveis para comparar distribuições
• Recursos de exportação: Salve insights como imagens ou compartilhe relatórios interativos
• Nenhuma codificação necessária: Membros da equipe não técnicos podem explorar dados independentemente

Visite github.com/Kanaries/pygwalker (opens in a new tab) para começar com visualização de dados interativa.

Exemplo do mundo real: Analisando pontuações de exames

Vamos aplicar técnicas de histograma para analisar distribuições de pontuações de exames em diferentes turmas:

# Gerar dados de exame realistas
np.random.seed(42)
n_students = 500
 
exam_data = pd.DataFrame({
    'score': np.concatenate([
        np.random.normal(75, 10, 200),  # Turma A
        np.random.normal(68, 15, 150),  # Turma B
        np.random.normal(82, 8, 150)    # Turma C
    ]),
    'class': ['Turma A'] * 200 + ['Turma B'] * 150 + ['Turma C'] * 150,
    'study_hours': np.random.uniform(0, 40, n_students)
})
 
# Limitar pontuações ao intervalo válido
exam_data['score'] = exam_data['score'].clip(0, 100)
 
# Criar visualização abrangente
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Distribuição geral com KDE
sns.histplot(data=exam_data, x='score', kde=True,
             bins=30, ax=axes[0, 0])
axes[0, 0].set_title('Distribuição geral de pontuações')
axes[0, 0].axvline(exam_data['score'].mean(), color='red',
                    linestyle='--', label=f'Média: {exam_data["score"].mean():.1f}')
axes[0, 0].legend()
 
# Comparar turmas
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('Distribuição de pontuações por turma')
 
# Vista empilhada para proporções
sns.histplot(data=exam_data, x='score', hue='class',
             multiple='stack', bins=25, ax=axes[1, 0])
axes[1, 0].set_title('Distribuição empilhada (contagens totais)')
 
# Distribuições cumulativas
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('Distribuição cumulativa por turma')
 
plt.tight_layout()
plt.show()
 
# Imprimir estatísticas resumidas
print(exam_data.groupby('class')['score'].describe())

Este exemplo demonstra:

• Análise de distribuição geral com linha de referência de média
• Comparação de densidade normalizada para diferentes tamanhos de turma
• Visualização empilhada mostrando contribuição de cada turma
• Distribuições cumulativas para análise de percentis

FAQ

Como escolho o número certo de bins para meu histograma?

O número ideal de bins depende do tamanho e distribuição dos seus dados. A seleção automática de bins do Seaborn (baseada na regra de Freedman-Diaconis) funciona bem para a maioria dos casos. Para seleção manual, use a regra de Sturges: bins = log2(n) + 1 para distribuições normais (tipicamente 10-20 bins para 1000 amostras), ou regra da raiz quadrada: bins = sqrt(n) para dados gerais. Experimente com diferentes valores e escolha aquele que revela padrões sem criar ruído excessivo. Use binwidth em vez de bins quando precisar de tamanhos de bin consistentes em vários gráficos para comparação.

Qual é a diferença entre histplot e displot no seaborn?

histplot() é uma função em nível de eixos que plota em um objeto de eixos matplotlib específico, tornando-a adequada para criar figuras complexas de múltiplos gráficos com plt.subplots(). displot() é uma função em nível de figura que cria uma figura inteira e suporta facetamento automático com parâmetros col e row. Use histplot() ao integrar histogramas em figuras matplotlib existentes com vários subgráficos. Use displot() para visualizações independentes ou quando precisar criar gráficos facetados em várias variáveis categóricas. Ambas as funções suportam os mesmos parâmetros principais para controlar bins, KDE, hue e estatísticas.

Devo usar stat='density' ou stat='probability' para meu histograma?

Use stat='density' quando precisar que a área do histograma seja igual a 1, tornando-o comparável com funções de densidade de probabilidade e ideal para sobrepor distribuições teóricas. Use stat='probability' (ou stat='percent') quando quiser interpretar o eixo y como a proporção de dados em cada bin, com todas as alturas de bin somando 1 (ou 100%). Escolha stat='density' para comparar distribuições com diferentes tamanhos de amostra ou ao realizar análise estatística. Escolha stat='probability' para interpretação mais intuitiva em apresentações ou ao explicar resultados para audiências não técnicas.

Como criar um histograma com várias distribuições sobrepostas?

Use o parâmetro hue para especificar uma variável categórica que divide seus dados em grupos. Controle o comportamento de sobreposição com o parâmetro multiple: use 'layer' (padrão) para barras transparentes sobrepostas, 'dodge' para barras lado a lado, 'stack' para barras empilhadas verticalmente mostrando totais, ou 'fill' para barras empilhadas normalizadas mostrando proporções. Defina alpha=0.5 para tornar regiões sobrepostas visíveis. Ao comparar distribuições com diferentes tamanhos de amostra, sempre use stat='density' ou stat='probability' com common_norm=False para garantir comparação justa. Adicione curvas KDE com kde=True para destacar a forma geral de cada distribuição.

Por que o distplot do seaborn está obsoleto e o que devo usar em vez disso?

Seaborn descontinuou distplot() na versão 0.11.0 porque combinava múltiplas funcionalidades em uma única função com nomenclatura de parâmetros inconsistente. As funções de substituição fornecem interfaces mais claras e mais flexibilidade: use histplot() para histogramas, kdeplot() para estimativa de densidade de kernel, ecdfplot() para funções de distribuição cumulativa empírica e rugplot() para gráficos de tapete. Essas novas funções oferecem melhores nomes de parâmetros, mais opções de personalização, suporte nativo para agrupamento baseado em hue e comportamento consistente com outras funções seaborn. Para migrar código antigo, substitua sns.distplot(data) por sns.histplot(data, kde=True) para o caso de uso mais comum.

Conclusão

Os histogramas Seaborn fornecem uma maneira poderosa e flexível de visualizar distribuições de dados com código mínimo. A função histplot() oferece controle refinado sobre agrupamento, estatísticas e agrupamento, enquanto displot() simplifica visualizações facetadas. Ao dominar parâmetros como bins, stat, hue e multiple, você pode criar gráficos de distribuição de qualidade de publicação que revelam padrões, outliers e diferenças entre grupos.

Pontos-chave:

• Use seleção automática de bins para exploração inicial, depois ajuste para clareza
• Aplique stat='density' ao comparar distribuições com diferentes tamanhos de amostra
• Aproveite os parâmetros hue e multiple para comparar múltiplas distribuições eficazmente
• Adicione sobreposições KDE para mostrar formas de distribuição suaves
• Escolha histplot() para integração com subgráficos matplotlib e displot() para gráficos facetados independentes

Quer você esteja analisando pontuações de exames, medições científicas ou métricas de negócios, os histogramas seaborn ajudam você a entender a distribuição dos seus dados e comunicar insights eficazmente. Combine essas técnicas com ferramentas interativas como PyGWalker para análise exploratória de dados abrangente.