Seaborn Heatmap: Guia Completo para Criar Mapas de Calor em Python

Name

Soren Atelier

Updated on 09/02/2026

Você tem um conjunto de dados com dezenas de variáveis. Você precisa entender quais recursos se correlacionam, onde os padrões se escondem ou por que seu modelo de aprendizado de máquina continua funcionando mal. Olhar fixamente para linhas e colunas de números não te diz quase nada. Este é exatamente o problema que um mapa de calor do seaborn resolve - ele converte uma matriz densa de valores em uma grade codificada por cores que seu cérebro pode analisar em segundos.

Mapas de calor são um dos tipos de visualização mais utilizados em ciência de dados, e a biblioteca seaborn do Python torna sua criação notavelmente simples. Seja você construindo uma matriz de correlação, analisando uma matriz de confusão ou visualizando padrões de séries temporais, sns.heatmap() oferece um gráfico pronto para publicação com apenas algumas linhas de código.

Este guia te conduz por tudo: sintaxe básica, opções de personalização, técnicas avançadas como mapas de calor agrupados e uma tabela de referência completa de parâmetros. Cada exemplo de código está pronto para copiar e colar.

Sintaxe Básica do Mapa de Calor Seaborn

A função principal é sns.heatmap(). Ela aceita um conjunto de dados 2D - tipicamente um DataFrame do pandas ou um array NumPy - e o renderiza como uma grade colorida.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Create sample data
data = np.random.rand(5, 7)
ax = sns.heatmap(data)
plt.title("Basic Seaborn Heatmap")
plt.show()

Este é o mapa de calor mais simples possível. A cor de cada célula representa seu valor numérico, e o seaborn adiciona automaticamente uma barra de cores no lado direito. Mas o uso no mundo real quase sempre envolve mais configuração, que cobriremos a seguir.

Criando um Mapa de Calor de Matriz de Correlação

O caso de uso mais comum para um mapa de calor do seaborn é visualizar uma matriz de correlação. Isso te diz quão fortemente cada par de variáveis no seu conjunto de dados está relacionado.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
 
# Load a built-in dataset
df = sns.load_dataset("mpg").select_dtypes(include="number")
 
# Compute the correlation matrix
corr = df.corr()
 
# Plot the heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Correlation Matrix - MPG Dataset")
plt.tight_layout()
plt.show()

Coisas importantes acontecendo aqui:

• annot=True imprime o coeficiente de correlação dentro de cada célula.
• fmt=".2f" formata esses números para duas casas decimais.
• cmap="coolwarm" usa uma paleta de cores divergente onde correlações negativas são azuis e correlações positivas são vermelhas.
• center=0 garante que correlação zero seja mapeada para a cor do ponto médio neutro.
• square=True força cada célula a ser um quadrado perfeito para visuais mais limpos.

Opções de Personalização

Paletas de Cores (parâmetro cmap)

O parâmetro cmap controla o esquema de cores. Escolher a paleta certa depende do seu tipo de dados.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(6, 6)
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
 
cmaps = ["viridis", "coolwarm", "YlOrRd"]
for ax, cmap in zip(axes, cmaps):
    sns.heatmap(data, cmap=cmap, ax=ax, annot=True, fmt=".2f")
    ax.set_title(f'cmap="{cmap}"')
 
plt.tight_layout()
plt.show()

Anotações (parâmetros annot e fmt)

Anotações exibem o valor numérico dentro de cada célula. Você pode controlar seu formato:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.randint(0, 1000, size=(4, 5))
 
plt.figure(figsize=(8, 5))
sns.heatmap(
    data,
    annot=True,
    fmt="d",            # integer format
    cmap="Blues",
    annot_kws={"size": 14, "weight": "bold"}  # customize font
)
plt.title("Heatmap with Integer Annotations")
plt.show()

Valores comuns de fmt: ".2f" para duas decimais, "d" para inteiros, ".1%" para porcentagens, ".1e" para notação científica.

Tamanho da Figura e Proporção

Mapas de calor do Seaborn herdam seu tamanho da figura matplotlib. Configure-o antes de chamar sns.heatmap():

plt.figure(figsize=(12, 8))  # width=12, height=8 inches
sns.heatmap(data, cmap="viridis")
plt.show()

Para células quadradas, passe square=True para sns.heatmap(). Isso sobrescreve a proporção da figura para tornar cada célula do mesmo tamanho.

Mascarando o Triângulo Superior ou Inferior

Matrizes de correlação são simétricas. Mostrar ambas as metades é redundante. Use triu ou tril do NumPy para mascarar uma metade:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
df = sns.load_dataset("mpg").select_dtypes(include="number")
corr = df.corr()
 
# Create a mask for the upper triangle
mask = np.triu(np.ones_like(corr, dtype=bool))
 
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Lower Triangle Correlation Heatmap")
plt.tight_layout()
plt.show()

O parâmetro mask aceita um array booleano da mesma forma que os dados. Células onde mask=True são ocultadas.

Tabela de Referência de Parâmetros do Mapa de Calor

Exemplos Avançados

Mapa de Calor Agrupado com sns.clustermap

Quando você quer agrupar linhas e colunas similares, sns.clustermap() aplica clustering hierárquico e reordena os eixos automaticamente:

import seaborn as sns
import matplotlib.pyplot as plt
 
df = sns.load_dataset("mpg").select_dtypes(include="number").dropna()
corr = df.corr()
 
g = sns.clustermap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="vlag",
    center=0,
    linewidths=0.5,
    figsize=(8, 8),
    dendrogram_ratio=0.15
)
g.ax_heatmap.set_title("Clustered Correlation Heatmap", pad=60)
plt.show()

Os dendrogramas à esquerda e no topo mostram a hierarquia de agrupamento. Variáveis que estão mais estreitamente correlacionadas são colocadas lado a lado, tornando os padrões muito mais fáceis de detectar.

Faixas de Cores Personalizadas (vmin, vmax)

Por padrão, o seaborn escala as cores para o mínimo e máximo dos seus dados. Você pode sobrescrever isso para comparar múltiplos mapas de calor na mesma escala ou para destacar uma faixa específica:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.uniform(-1, 1, size=(8, 8))
 
plt.figure(figsize=(8, 6))
sns.heatmap(
    data,
    vmin=-1,
    vmax=1,
    center=0,
    cmap="RdBu_r",
    annot=True,
    fmt=".2f"
)
plt.title("Heatmap with Fixed Color Range (-1 to 1)")
plt.show()

Definir vmin=-1 e vmax=1 é particularmente útil ao plotar matrizes de correlação ou dados normalizados onde a faixa teórica é conhecida.

Mapa de Calor de Matriz de Confusão

Outra aplicação prática é visualizar uma matriz de confusão de um modelo de classificação:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
 
# Train a quick model
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
 
# Build and plot the confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(7, 5))
sns.heatmap(
    cm,
    annot=True,
    fmt="d",
    cmap="Blues",
    xticklabels=iris.target_names,
    yticklabels=iris.target_names
)
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix - Iris Classification")
plt.tight_layout()
plt.show()

A diagonal mostra previsões corretas. Células fora da diagonal revelam onde o modelo confunde uma classe com outra.

Mapa de Calor de Séries Temporais

Mapas de calor também funcionam bem para detectar padrões através de dimensões temporais. Aqui está um exemplo mostrando atividade por dia da semana e hora:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
np.random.seed(0)
hours = list(range(24))
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
data = pd.DataFrame(
    np.random.poisson(lam=20, size=(7, 24)),
    index=days,
    columns=hours
)
 
plt.figure(figsize=(14, 5))
sns.heatmap(data, cmap="YlOrRd", linewidths=0.3, annot=False)
plt.xlabel("Hour of Day")
plt.ylabel("Day of Week")
plt.title("Activity Heatmap by Day and Hour")
plt.tight_layout()
plt.show()

Mapa de Calor Seaborn vs Matplotlib imshow

Você também pode criar visualizações semelhantes a mapas de calor com matplotlib.pyplot.imshow(). Veja como os dois se comparam:

Conclusão: Use sns.heatmap() quando quiser um mapa de calor limpo e bem rotulado com código mínimo. Recorra ao imshow() quando precisar de controle em nível de pixel ou estiver trabalhando com dados de imagem em vez de dados tabulares.

Alternativa Interativa: PyGWalker

Mapas de calor estáticos são poderosos para relatórios e artigos, mas durante a análise exploratória de dados você frequentemente quer interagir com seus dados - filtrar, dinamizar, aprofundar e alternar entre tipos de gráficos sem reescrever código.

PyGWalker (opens in a new tab) (vinculação Python do Graphic Walker) transforma qualquer DataFrame do pandas em uma interface interativa semelhante ao Tableau diretamente dentro do Jupyter Notebook. Você pode arrastar e soltar campos para construir mapas de calor, gráficos de dispersão, gráficos de barras e muito mais sem escrever código de visualização.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
df = pd.read_csv("your_data.csv")
walker = pyg.walk(df)

Uma vez que a interface interativa é iniciada, você pode:

• Arrastar uma variável categórica para linhas, outra para colunas e uma medida para cor para criar um mapa de calor.
• Alternar instantaneamente para outros tipos de gráficos (barra, linha, dispersão).
• Filtrar e agregar sem escrever código adicional.

Isso é especialmente útil quando você ainda está explorando quais variáveis incluir no seu mapa de calor final do seaborn. Use o PyGWalker para a fase de exploração, depois fixe sua visualização estática final com sns.heatmap() para compartilhamento.

Perguntas Frequentes

Como altero o tamanho de um mapa de calor do seaborn?

Defina o tamanho da figura antes de chamar sns.heatmap() usando plt.figure(figsize=(width, height)). Por exemplo, plt.figure(figsize=(12, 8)) cria uma figura de 12x8 polegadas. Você também pode passar um parâmetro ax se estiver trabalhando com subplots.

Como anoto um mapa de calor do seaborn com valores?

Passe annot=True para sns.heatmap(). Controle o formato dos números com o parâmetro fmt (por exemplo, fmt=".2f" para duas decimais). Personalize propriedades de fonte usando annot_kws, por exemplo: annot_kws={"size": 12, "weight": "bold"}.

Qual é a diferença entre sns.heatmap e sns.clustermap?

sns.heatmap() exibe dados na ordem original de linhas e colunas. sns.clustermap() aplica clustering hierárquico para reordenar linhas e colunas de modo que valores similares sejam agrupados, e adiciona dendrogramas para mostrar a estrutura de agrupamento.

Como mascaro metade de um mapa de calor de correlação?

Use NumPy para criar uma máscara booleana. Para o triângulo superior: mask = np.triu(np.ones_like(corr, dtype=bool)). Então passe mask=mask para sns.heatmap(). Para o triângulo inferior, use np.tril() em vez disso.

Posso salvar um mapa de calor do seaborn como arquivo de imagem?

Sim. Após criar o mapa de calor, chame plt.savefig("heatmap.png", dpi=300, bbox_inches="tight") antes de plt.show(). Mapas de calor do Seaborn suportam todos os formatos de saída do matplotlib incluindo PNG, SVG, PDF e EPS.

Conclusão

O mapa de calor do seaborn é uma das ferramentas mais versáteis no kit de ferramentas de visualização de um cientista de dados. Desde análise de correlação até matrizes de confusão até detecção de padrões de séries temporais, sns.heatmap() lida com tudo isso com sintaxe limpa e saída de qualidade de publicação.

Comece com o básico - passe seus dados e escolha um mapa de cores. Depois adicione camadas de anotações, mascaramento, faixas personalizadas e clustering conforme sua análise exigir. Para a fase de exploração antes de fixar uma visualização final, ferramentas como PyGWalker (opens in a new tab) podem acelerar seu fluxo de trabalho com gráficos interativos de arrastar e soltar.

Os exemplos de código neste guia estão todos prontos para copiar e colar. Escolha o mais próximo do seu caso de uso, troque seus dados, e você terá um mapa de calor claro e informativo em menos de um minuto.