Seaborn Barplot: O guia completo de gráficos de barras em Python

Name

Soren Atelier

Updated on 09/02/2026

Você precisa comparar médias entre categorias. Talvez seja a receita média por região, notas médias de testes por sala de aula ou tempo de resposta mediano por servidor. Uma tabela bruta de números força você a escanear linhas e fazer cálculos mentais. Um gráfico de barras bem construído torna a resposta óbvia num piscar de olhos -- e a biblioteca seaborn do Python permite que você crie um com uma única chamada de função.

O problema é que sns.barplot() tem um conjunto surpreendentemente profundo de parâmetros. Agrupamento com hue, controle de barras de erro, reordenamento de categorias, escolha de paletas, orientação horizontal -- cada um desses aspectos confunde iniciantes e até usuários experientes que não tocaram na função há algum tempo. Gráficos de barras mal configurados enganam os leitores ou simplesmente ficam feios.

Este guia cobre cada caso de uso prático do sns.barplot(). Cada bloco de código está pronto para copiar e colar, usa conjuntos de dados reais ou realistas e produz saída limpa. No final, você saberá como criar gráficos de barras com qualidade de publicação, entender a diferença entre barplot e countplot, e terá um caminho rápido para exploração interativa com PyGWalker.

O que sns.barplot() faz

sns.barplot() desenha um gráfico de barras onde a altura (ou comprimento) de cada barra representa a tendência central de uma variável numérica para cada categoria. Por padrão, calcula a média e desenha um intervalo de confiança de 95% como barra de erro no topo de cada barra.

Isso o torna diferente de um simples gráfico de barras baseado em contagem. É uma visualização estatística: ele agrega seus dados antes de plotar.

Sintaxe 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 principais de relance:

Gráfico de barras vertical simples

Comece com o conjunto de dados integrado tips. Este DataFrame registra contas de restaurante, gorjetas e atributos dos 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 mostra a média de total_bill para aquele dia. As linhas pretas no topo são intervalos de confiança de 95%, dando uma noção de quanto a média pode variar. Quinta-feira tem a conta média mais baixa, enquanto domingo tende a ser mais alta.

Para mudar a função de agregação, passe 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

Barras horizontais funcionam melhor quando os rótulos de categoria são longos ou quando você tem muitas categorias. Existem duas formas de criar um barplot horizontal.

Opção 1: Trocar 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()

Quando a coluna numérica está em x e a coluna categórica em y, o seaborn automaticamente desenha barras horizontais.

Opção 2: Usar o parâmetro orient.

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

Ambas as abordagens produzem o mesmo resultado. Trocar x e y é o padrão mais comum.

Gráfico de barras agrupado (Hue)

O parâmetro hue divide cada barra de categoria em sub-barras baseadas numa segunda variável categórica. Isso é essencial 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 dia agora mostra duas barras -- uma para masculino, uma para feminino. A legenda mapeia cores para grupos. Você pode ver imediatamente que clientes masculinos tendem a ter contas médias ligeiramente mais altas na maioria dos dias.

Para três ou mais níveis de hue, as barras ficam mais estreitas. Se a legibilidade for prejudicada, considere uma abordagem facetada com 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()

Isso cria painéis separados para Almoço e Jantar, cada um com barras agrupadas por gênero -- muito mais fácil de ler quando você tem múltiplas dimensões de agrupamento.

Personalizando cores com Palette

O parâmetro palette controla o esquema de cores. O Seaborn vem com muitas 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()

Escolhas populares de paleta:

Você também pode passar uma lista de cores hexadecimais específicas:

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

Ou usar um dicionário para mapear categorias específicas para cores:

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 erro e intervalos de confiança

Por padrão, sns.barplot() mostra um intervalo de confiança de 95%. Este é o CI bootstrapped ao redor da média. Você tem controle total sobre o que é exibido.

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: Em versões anteriores do seaborn (antes de 0.12), o parâmetro era chamado ci em vez de errorbar. Se você vir ci=95 em código legado, faz a mesma coisa. O seaborn moderno usa errorbar para mais flexibilidade.

Ordenando barras

Por padrão, as barras aparecem na ordem em que as categorias aparecem nos seus dados. Use o parâmetro order para controlar isso explicitamente.

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 pelo seu valor (do maior para o menor), calcule as médias primeiro:

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

Esse padrão -- ordenar pela métrica agregada -- é uma das formas mais comuns de tornar gráficos de barras imediatamente informativos.

sns.barplot() vs sns.countplot() -- Quando usar qual

Essas duas funções parecem similares, mas servem propósitos diferentes. Escolher a errada é uma fonte comum de confusão.

Regra geral: Se você tem uma coluna numérica que deseja agregar, use barplot. Se você só quer contar quantas linhas caem em cada categoria, 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()

Personalização com Matplotlib

Como o seaborn é construído sobre o matplotlib, você tem acesso completo à camada de personalização do matplotlib. É assim que você adiciona títulos, rotaciona rótulos, ajusta fontes e anota barras.

Títulos, rótulos e rotação

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

Adicionando rótulos de valor nas 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()

O método ax.bar_label() (adicionado no matplotlib 3.4) é a forma mais limpa de adicionar anotações de valor. O argumento padding controla a distância do topo da barra.

Barras empilhadas (Solução alternativa)

O Seaborn não suporta nativamente gráficos de barras empilhadas. Esta é uma decisão de design deliberada -- barras empilhadas tornam mais difícil comparar tamanhos de segmentos individuais. No entanto, se o seu caso de uso exigir, você pode alcançar o efeito com plotagem do pandas ou uma abordagem manual do 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()

Empilhamento manual com 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()

Ambas as abordagens funcionam. O método pandas é mais conciso; o método matplotlib dá mais controle sobre posicionamento e estilo.

Criar gráficos de barras interativos com PyGWalker

Gráficos de barras estáticos são ótimos para relatórios e artigos. Mas durante a análise exploratória, você frequentemente quer mudar eixos, experimentar diferentes agregações, filtrar dados e comparar tipos de gráficos -- tudo sem reescrever código a cada vez.

PyGWalker (opens in a new tab) (binding Python do Graphic Walker) transforma qualquer DataFrame pandas numa interface de visualização interativa semelhante ao Tableau diretamente dentro do Jupyter Notebook. Você pode construir gráficos de barras, gráficos de barras agrupados e dezenas de outros tipos de gráficos arrastando e 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)

Uma vez que a interface carrega, você pode:

• Arrastar day para o eixo X e total_bill para o eixo Y para criar um gráfico de barras instantaneamente.
• Soltar sex ou time no canal de Cor para obter um gráfico de barras agrupado.
• Mudar a agregação de média para soma, mediana ou contagem com um único clique.
• Aplicar filtros (por exemplo, apenas sábado e domingo) sem escrever código pandas.
• Exportar a configuração do seu gráfico para reprodutibilidade.

Isso é particularmente útil durante a fase de exploração -- teste rapidamente quais agrupamentos e agregações revelam mais insights, depois confirme sua visualização estática final com sns.barplot() para compartilhamento.

Perguntas frequentes

Como mudo a cor de barras individuais em sns.barplot()?

Passe uma lista de cores para o parâmetro palette. O comprimento da lista deve corresponder ao número de categorias. Por exemplo: sns.barplot(data=tips, x="day", y="total_bill", palette=["#e74c3c", "#3498db", "#2ecc71", "#f39c12"]). Você também pode passar um dicionário mapeando nomes de categorias para cores para controle explícito.

Qual é a diferença entre sns.barplot() e plt.bar()?

sns.barplot() trabalha diretamente com DataFrames, calcula automaticamente uma estatística agregada (padrão: média) e desenha intervalos de confiança. plt.bar() do matplotlib requer alturas e posições de barra pré-calculadas -- desenha exatamente o que você fornece sem agregação. Use sns.barplot() para resumos estatísticos rápidos e plt.bar() para controle manual completo.

Como removo as barras de erro de um barplot seaborn?

Defina errorbar=None na chamada da função: sns.barplot(data=tips, x="day", y="total_bill", errorbar=None). Em versões do seaborn anteriores a 0.12, use ci=None em vez disso.

O sns.barplot() pode mostrar a soma em vez da média?

Sim. Passe estimator=sum para a função: sns.barplot(data=tips, x="day", y="total_bill", estimator=sum). Você pode usar qualquer função que receba um array e retorne um escalar, incluindo numpy.median, numpy.std ou um lambda personalizado.

Como faço um barplot horizontal no seaborn?

Coloque a coluna numérica no eixo x e a coluna categórica em y: sns.barplot(data=tips, x="total_bill", y="day"). O Seaborn detecta a orientação automaticamente. Você também pode definir explicitamente orient="h".

Conclusão

O barplot do seaborn é a forma mais rápida de visualizar métricas agregadas entre categorias em Python. De uma única linha mostrando valores médios com intervalos de confiança, a comparações agrupadas com hue, a gráficos totalmente estilizados com anotações de valor -- sns.barplot() cobre toda a gama de necessidades de gráficos de barras.

Comece simples: passe seu DataFrame, escolha suas colunas x e y, e deixe o seaborn cuidar da agregação e estilização. Depois adicione personalizações conforme necessário -- reordene barras por valor, mude para um layout horizontal para rótulos longos, ou desative barras de erro para slides de apresentação mais limpos.

Quando precisar de barras empilhadas, recorra diretamente ao pandas ou matplotlib. Quando quiser explorar seus dados interativamente antes de se comprometer com uma configuração de gráfico específica, PyGWalker (opens in a new tab) oferece uma interface de arrastar e soltar que funciona dentro do Jupyter sem código adicional.

Todos os exemplos de código neste guia estão prontos para copiar e executar. Escolha o padrão mais próximo do seu caso de uso, substitua seus dados, e você terá um gráfico de barras claro e informativo em menos de um minuto.