Colormap do Matplotlib: Guia Completo de Mapas de Cores em Python

Name

Soren Atelier

Updated on 12/02/2026

Escolher as cores certas para uma visualização de dados é enganosamente difícil. Você escolhe um colormap arco-íris e seu heatmap fica dramático — mas a não uniformidade perceptual distorce os dados, engana quem está vendo e falha completamente para qualquer pessoa com deficiência de visão de cores. Você usa uma paleta de um único matiz e padrões sutis desaparecem em uma parede de tons quase idênticos. A diferença entre um gráfico que revela insight e outro que o esconde muitas vezes se resume a uma decisão: o colormap.

O Matplotlib vem com mais de 150 colormaps integrados e uma API flexível para criar os seus próprios. O desafio não é a falta de opções — é saber qual colormap usar, quando usar e como personalizá-lo para o seu dataset específico. Uma escolha ruim pode arruinar silenciosamente a precisão da sua visualização; a escolha certa torna dados complexos imediatamente legíveis.

Este guia cobre todos os aspectos práticos de colormaps no Matplotlib: as quatro grandes categorias, os mapas integrados mais importantes, como aplicá-los em diferentes tipos de gráficos, como construir colormaps personalizados do zero e como escolher um colormap que seja cientificamente preciso e acessível.

O que é um Colormap no Matplotlib?

Um colormap é uma função de mapeamento que traduz valores escalares de dados em cores. Dado um número (tipicamente normalizado para o intervalo 0–1), o colormap retorna uma tupla de cor RGBA. O Matplotlib representa colormaps como objetos que herdam de matplotlib.colors.Colormap, e toda função de plotagem que aceita um parâmetro cmap usa esse sistema por baixo dos panos.

import matplotlib.pyplot as plt
import numpy as np
 
# A colormap is a callable: pass a float in [0, 1], get an RGBA tuple
cmap = plt.colormaps['viridis']
print(cmap(0.0))   # dark purple
print(cmap(0.5))   # teal-green
print(cmap(1.0))   # bright yellow

Quando você escreve plt.imshow(data, cmap='viridis'), o Matplotlib normaliza seus dados para [0, 1] usando um objeto Normalize, e então passa cada valor normalizado pelo colormap para produzir as cores finais de cada pixel. Entender esse processo em duas etapas — normalização e, depois, consulta de cor — é a chave para controlar todos os aspectos de cor nos seus plots.

As Quatro Categorias de Colormaps

O Matplotlib organiza seus colormaps em quatro categorias funcionais. Cada uma atende a um tipo diferente de dado, e usar a categoria errada é o erro de colormap mais comum.

Colormaps Sequenciais

Colormaps sequenciais variam suavemente de claro para escuro (ou de escuro para claro) em um único matiz ou em uma faixa estreita de matizes. Eles foram projetados para dados que têm uma ordenação natural de baixo para alto, sem um ponto médio especial.

Quando usar: Leituras de temperatura, densidade populacional, elevação, probabilidade, qualquer variável contínua com uma direção significativa.

Exemplos-chave: viridis, plasma, inferno, magma, cividis, Blues, Greens, OrRd, YlGnBu

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(12, 12)
 
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
 
for ax, name in zip(axes, ['viridis', 'plasma', 'inferno']):
    im = ax.imshow(data, cmap=name)
    ax.set_title(f'Sequential: {name}')
    fig.colorbar(im, ax=ax, shrink=0.8)
 
plt.tight_layout()
plt.show()

Colormaps Divergentes

Colormaps divergentes usam dois matizes contrastantes que se encontram em um ponto médio neutro (geralmente branco ou cinza claro). Eles enfatizam a variação em ambas as direções a partir de um valor central.

Quando usar: Anomalias de temperatura (acima/abaixo da média), matrizes de correlação, lucro/prejuízo, qualquer dado em que zero ou um ponto médio tenha significado especial.

Exemplos-chave: coolwarm, RdBu, RdYlGn, BrBG, PiYG, seismic, bwr

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.randn(10, 10)  # Values centered around zero
 
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
 
for ax, name in zip(axes, ['coolwarm', 'RdBu', 'seismic']):
    im = ax.imshow(data, cmap=name, vmin=-3, vmax=3)
    ax.set_title(f'Diverging: {name}')
    fig.colorbar(im, ax=ax, shrink=0.8)
 
plt.tight_layout()
plt.show()

Dica: Sempre defina vmin e vmax de forma simétrica em torno do ponto médio para que a cor neutra fique alinhada com zero (ou com o valor central escolhido).

Colormaps Qualitativos

Colormaps qualitativos fornecem um conjunto de cores visualmente distintas, sem ordem implícita. Cada cor é maximamente diferente das vizinhas, o que os torna ideais para rótulos categóricos.

Quando usar: Rótulos de clusters, scatter plots categóricos, gráficos de barras com grupos sem ordenação.

Exemplos-chave: tab10, tab20, Set1, Set2, Set3, Paired, Accent

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(7)
categories = 6
x = np.concatenate([np.random.randn(30) + i * 3 for i in range(categories)])
y = np.concatenate([np.random.randn(30) + i * 1.5 for i in range(categories)])
labels = np.concatenate([np.full(30, i) for i in range(categories)])
 
plt.figure(figsize=(9, 6))
scatter = plt.scatter(x, y, c=labels, cmap='tab10', s=50, alpha=0.8, edgecolors='white')
plt.colorbar(scatter, label='Category')
plt.title('Qualitative Colormap: tab10')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

Colormaps Cíclicos

Colormaps cíclicos começam e terminam na mesma cor, tornando-os apropriados para dados que “dão a volta” — ângulos, fases, hora do dia, direção do vento.

Quando usar: Dados de fase, direções da bússola, sinais periódicos, horas do dia.

Exemplos-chave: twilight, twilight_shifted, hsv

import matplotlib.pyplot as plt
import numpy as np
 
theta = np.linspace(0, 2 * np.pi, 300)
r = np.linspace(0, 1, 300)
T, R = np.meshgrid(theta, r)
Z = T  # Color represents angle
 
fig, ax = plt.subplots(subplot_kw={'projection': 'polar'}, figsize=(6, 6))
im = ax.pcolormesh(T, R, Z, cmap='twilight', shading='auto')
fig.colorbar(im, ax=ax, label='Angle (radians)')
ax.set_title('Cyclic Colormap: twilight')
plt.show()

Tabela de Comparação: Categorias de Colormaps

Referência de Colormaps Integrados

O Matplotlib inclui colormaps de várias famílias. Aqui estão os mais usados por categoria.

Sequenciais Perceptualmente Uniformes

Esses colormaps foram desenhados para que passos iguais nos dados produzam passos iguais no brilho percebido. Eles são a recomendação padrão para a maioria dos casos de uso.

Colormaps Divergentes Populares

Usando Colormaps em Diferentes Tipos de Gráfico

Heatmaps com imshow

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.rand(8, 10)
 
fig, ax = plt.subplots(figsize=(10, 6))
im = ax.imshow(data, cmap='YlOrRd', aspect='auto')
ax.set_xlabel('Columns')
ax.set_ylabel('Rows')
ax.set_title('Heatmap with YlOrRd Colormap')
fig.colorbar(im, ax=ax, label='Value')
plt.tight_layout()
plt.show()

Scatter Plots com Codificação por Cor

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
n = 300
x = np.random.randn(n)
y = np.random.randn(n)
distance = np.sqrt(x**2 + y**2)
 
plt.figure(figsize=(8, 6))
sc = plt.scatter(x, y, c=distance, cmap='magma', s=40, alpha=0.8, edgecolors='gray', linewidths=0.3)
plt.colorbar(sc, label='Distance from Origin')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Scatter Plot with magma Colormap')
plt.show()

Gráficos de Contorno

import matplotlib.pyplot as plt
import numpy as np
 
x = np.linspace(-3, 3, 200)
y = np.linspace(-3, 3, 200)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
 
fig, axes = plt.subplots(1, 2, figsize=(13, 5))
 
# Filled contour
cf = axes[0].contourf(X, Y, Z, levels=20, cmap='RdBu')
fig.colorbar(cf, ax=axes[0])
axes[0].set_title('contourf with RdBu')
 
# Line contour with colormap
cl = axes[1].contour(X, Y, Z, levels=15, cmap='plasma')
axes[1].clabel(cl, inline=True, fontsize=8)
axes[1].set_title('contour with plasma')
 
plt.tight_layout()
plt.show()

Pcolormesh para Grades Irregulares

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(0)
x = np.linspace(0, 4, 50)
y = np.linspace(0, 3, 40)
X, Y = np.meshgrid(x, y)
Z = np.exp(-(X - 2)**2 - (Y - 1.5)**2) + 0.5 * np.sin(3 * X) * np.cos(3 * Y)
 
plt.figure(figsize=(9, 6))
pcm = plt.pcolormesh(X, Y, Z, cmap='cividis', shading='auto')
plt.colorbar(pcm, label='Intensity')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('pcolormesh with cividis Colormap')
plt.tight_layout()
plt.show()

Personalização da Colorbar

A colorbar é a legenda do seu colormap. Personalizá-la corretamente é essencial para uma visualização legível.

Opções Básicas de Colorbar

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(10, 10)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap='viridis')
 
cbar = fig.colorbar(im, ax=ax, orientation='vertical', shrink=0.8, pad=0.02)
cbar.set_label('Measurement Value', fontsize=12)
cbar.ax.tick_params(labelsize=10)
plt.title('Colorbar Customization')
plt.tight_layout()
plt.show()

Colorbar Discreta com BoundaryNorm

Quando seus dados caem naturalmente em bins discretos (níveis de risco, categorias de avaliação), use BoundaryNorm para criar limites nítidos entre cores em vez de um gradiente suave.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
data = np.random.rand(10, 10) * 100
 
bounds = [0, 20, 40, 60, 80, 100]
norm = mcolors.BoundaryNorm(bounds, ncolors=256)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap='RdYlGn', norm=norm)
cbar = fig.colorbar(im, ax=ax, ticks=bounds)
cbar.set_label('Score')
ax.set_title('Discrete Colorbar with BoundaryNorm')
plt.tight_layout()
plt.show()

Colorbar Horizontal

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(8, 12)
 
fig, ax = plt.subplots(figsize=(10, 5))
im = ax.imshow(data, cmap='plasma')
cbar = fig.colorbar(im, ax=ax, orientation='horizontal', fraction=0.046, pad=0.12)
cbar.set_label('Value')
ax.set_title('Horizontal Colorbar')
plt.tight_layout()
plt.show()

Criando Colormaps Personalizados

Quando os colormaps integrados não atendem às suas necessidades — cores de marca corporativa, convenções específicas de domínio ou requisitos perceptuais específicos — o Matplotlib fornece duas classes para você criar os seus.

ListedColormap: A partir de uma Lista de Cores

ListedColormap cria um colormap a partir de uma lista explícita de cores. Cada cor ocupa uma porção igual do intervalo [0, 1].

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Define colors by name, hex, or RGB tuple
colors = ['#2c3e50', '#2980b9', '#27ae60', '#f39c12', '#e74c3c']
cmap_custom = mcolors.ListedColormap(colors)
 
data = np.random.rand(10, 10)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_custom)
fig.colorbar(im, ax=ax)
ax.set_title('Custom ListedColormap (5 colors)')
plt.tight_layout()
plt.show()

LinearSegmentedColormap: Gradientes Suaves

LinearSegmentedColormap cria transições suaves entre cores. A abordagem mais simples usa from_list, que interpola linearmente entre cores âncora.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Smooth gradient from dark blue through white to dark red
colors = ['#1a1a6e', '#4a90d9', '#ffffff', '#d94a4a', '#6e1a1a']
cmap_diverge = mcolors.LinearSegmentedColormap.from_list('custom_diverge', colors)
 
np.random.seed(42)
data = np.random.randn(12, 12)
 
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_diverge, vmin=-3, vmax=3)
fig.colorbar(im, ax=ax, label='Standard Deviations')
ax.set_title('Custom Diverging Colormap')
plt.tight_layout()
plt.show()

Avançado: Formato de Dicionário de Segmentos

Para controle total de como cada canal de cor transita, defina um dicionário de segmentos. Cada canal (vermelho, verde, azul) recebe uma lista de tuplas (x, y_left, y_right) especificando pontos âncora.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Custom colormap: black -> blue -> cyan -> yellow -> white
cdict = {
    'red':   [(0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.5, 0.0, 0.0),
              (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)],
    'green': [(0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.5, 1.0, 1.0),
              (0.75, 1.0, 1.0), (1.0, 1.0, 1.0)],
    'blue':  [(0.0, 0.0, 0.0), (0.25, 1.0, 1.0), (0.5, 1.0, 1.0),
              (0.75, 0.0, 0.0), (1.0, 1.0, 1.0)]
}
cmap_seg = mcolors.LinearSegmentedColormap('custom_seg', cdict)
 
data = np.random.rand(10, 10)
fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(data, cmap=cmap_seg)
fig.colorbar(im, ax=ax)
ax.set_title('Segment Dictionary Colormap')
plt.tight_layout()
plt.show()

Registrando um Colormap Personalizado

Registre seu colormap para que ele possa ser referenciado por nome em qualquer função de plotagem, assim como um colormap integrado:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
 
colors = ['#0d0887', '#7e03a8', '#cc4778', '#f89540', '#f0f921']
my_cmap = mcolors.LinearSegmentedColormap.from_list('my_palette', colors)
plt.colormaps.register(cmap=my_cmap)
 
# Now use it by name anywhere
# plt.imshow(data, cmap='my_palette')

Invertendo um Colormap

Acrescente _r ao nome de qualquer colormap para obter a versão invertida. Isso é útil quando você quer inverter a ênfase visual — por exemplo, fazer valores mais altos ficarem mais escuros em vez de mais claros.

import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(8, 8)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
axes[0].imshow(data, cmap='viridis')
axes[0].set_title('viridis (default)')
 
axes[1].imshow(data, cmap='viridis_r')
axes[1].set_title('viridis_r (reversed)')
 
plt.tight_layout()
plt.show()

Todo colormap integrado tem um correspondente invertido: plasma_r, coolwarm_r, RdBu_r, inferno_r e assim por diante.

Truncando e Extraindo Subconjuntos de Colormap

Às vezes você só precisa de uma parte de um colormap. Use Colormap.__call__ com np.linspace e ListedColormap para extrair uma fatia:

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
# Extract the middle 50% of the viridis colormap
full_cmap = plt.colormaps['viridis']
colors = full_cmap(np.linspace(0.25, 0.75, 256))
truncated_cmap = mcolors.ListedColormap(colors)
 
data = np.random.rand(10, 10)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
axes[0].imshow(data, cmap='viridis')
axes[0].set_title('Full viridis')
axes[1].imshow(data, cmap=truncated_cmap)
axes[1].set_title('Truncated viridis (25%-75%)')
plt.tight_layout()
plt.show()

Normalização: Controlando Como os Dados Mapeiam para Cores

A normalização determina como valores brutos de dados são convertidos para o intervalo [0, 1] antes da consulta ao colormap. O padrão é linear, mas o Matplotlib oferece várias alternativas.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np
 
np.random.seed(42)
data = np.random.lognormal(mean=2, sigma=1.5, size=(20, 20))
 
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
 
# Linear (default)
im0 = axes[0].imshow(data, cmap='magma')
fig.colorbar(im0, ax=axes[0])
axes[0].set_title('Linear Normalize')
 
# LogNorm
im1 = axes[1].imshow(data, cmap='magma', norm=mcolors.LogNorm())
fig.colorbar(im1, ax=axes[1])
axes[1].set_title('LogNorm')
 
# PowerNorm (gamma=0.5 = square root)
im2 = axes[2].imshow(data, cmap='magma', norm=mcolors.PowerNorm(gamma=0.5))
fig.colorbar(im2, ax=axes[2])
axes[2].set_title('PowerNorm (gamma=0.5)')
 
plt.tight_layout()
plt.show()

Escolhendo o Colormap Certo para Seus Dados

Escolher o colormap certo é uma decisão de design com consequências reais. Aqui vai um framework prático de decisão:

1. Os dados são sequenciais (baixo para alto)? Use um colormap sequencial. Comece com viridis. Se você precisar de mais contraste, tente plasma ou inferno.

2. Os dados divergem de um centro significativo? Use um colormap divergente. coolwarm para uma aparência mais sutil, RdBu para alto contraste. Defina vmin e vmax de forma simétrica.

3. Os dados são categóricos sem ordenação? Use um colormap qualitativo. tab10 para até 10 categorias, tab20 para até 20.

4. Os dados “dão a volta” (ângulos, fases)? Use um colormap cíclico. twilight é a melhor opção moderna.

5. O público inclui pessoas com deficiência de visão de cores? Use cividis (sequencial) ou viridis. Evite pares vermelho-verde como RdYlGn.

6. A figura será impressa em escala de cinza? Use viridis, plasma, inferno ou magma — eles mantêm uma luminosidade monotonicamente crescente.

Acessibilidade: Colormaps Amigáveis para Daltonismo

Aproximadamente 8% dos homens e 0,5% das mulheres têm algum tipo de deficiência de visão de cores, mais comumente afetando a capacidade de distinguir vermelho de verde. Colormaps perceptualmente uniformes (viridis, plasma, inferno, magma, cividis) foram projetados especificamente para permanecer legíveis sob as formas mais comuns de daltonismo.

Colormaps a evitar por acessibilidade: jet, rainbow, RdYlGn, RdYlBu (quando a distinção vermelho-verde é crítica), hot.

Por que jet é prejudicial: O colormap jet (um arco-íris do azul passando por ciano, verde, amarelo até vermelho) tem não uniformidades perceptuais que criam fronteiras falsas nos dados. Regiões que diferem muito no valor real podem parecer similares, enquanto pequenas diferenças perto de ciano-verde podem parecer dramáticas. Ele também falha completamente para pessoas com deuteranopia (daltonismo vermelho-verde).

import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.rand(15, 15)
 
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
 
axes[0].imshow(data, cmap='jet')
axes[0].set_title('jet (avoid for scientific use)')
 
axes[1].imshow(data, cmap='cividis')
axes[1].set_title('cividis (colorblind-safe)')
 
plt.tight_layout()
plt.show()

Listando Todos os Colormaps Disponíveis

Para ver todos os colormaps disponíveis na sua versão do Matplotlib:

import matplotlib.pyplot as plt
 
# All colormap names, sorted
all_cmaps = sorted(plt.colormaps())
print(f"Total colormaps: {len(all_cmaps)}")
 
# Filter out reversed versions
base_cmaps = [c for c in all_cmaps if not c.endswith('_r')]
print(f"Base colormaps (excluding _r): {len(base_cmaps)}")

Para exibi-los visualmente:

import matplotlib.pyplot as plt
import numpy as np
 
gradient = np.linspace(0, 1, 256).reshape(1, -1)
 
cmaps_to_show = ['viridis', 'plasma', 'inferno', 'magma', 'cividis',
                 'coolwarm', 'RdBu', 'seismic',
                 'tab10', 'Set1',
                 'twilight']
 
fig, axes = plt.subplots(len(cmaps_to_show), 1, figsize=(10, len(cmaps_to_show) * 0.5))
fig.subplots_adjust(hspace=0.4)
 
for ax, name in zip(axes, cmaps_to_show):
    ax.imshow(gradient, aspect='auto', cmap=name)
    ax.set_ylabel(name, rotation=0, labelpad=80, fontsize=10, va='center')
    ax.set_xticks([])
    ax.set_yticks([])
 
fig.suptitle('Matplotlib Colormap Samples', fontsize=14, y=1.01)
plt.tight_layout()
plt.show()

Visualização Interativa com PyGWalker

Ao explorar datasets interativamente, configurar colormaps manualmente para cada plot pode te deixar mais lento. PyGWalker (opens in a new tab) é uma biblioteca Python open-source que transforma qualquer DataFrame do pandas ou polars em uma interface interativa no estilo Tableau diretamente dentro do Jupyter. Você pode arrastar variáveis para eixos, atribuir codificações de cor e alternar tipos de visualização — tudo sem escrever código de colormap ou de plotagem à mão.

import pandas as pd
import pygwalker as pyg
 
# Load your data
df = pd.read_csv('your_data.csv')
 
# Launch the interactive UI -- color encoding, binning, and filtering are all point-and-click
walker = pyg.walk(df)

Isso é especialmente útil durante a análise exploratória quando você ainda está decidindo quais variáveis visualizar e quais codificações de cor deixam os padrões mais claros. Depois de encontrar a visualização certa, você sempre pode reproduzi-la no Matplotlib com uma configuração precisa de colormap.

Armadilhas Comuns e Como Evitá-las

FAQ

O que é um colormap no Matplotlib?

Um colormap no Matplotlib é uma função que mapeia valores numéricos escalares para cores. Ele recebe um valor entre 0 e 1 e retorna uma tupla de cor RGBA. Colormaps são usados em funções como imshow, scatter, contourf e pcolormesh para visualizar dados com gradientes de cor. Acesse-os com plt.colormaps['name'] ou passe o nome como string para o parâmetro cmap.

Como escolho o colormap certo para meus dados?

Para dados sequenciais (baixo para alto), use viridis, plasma ou inferno. Para dados divergentes (desvio em relação a um centro), use coolwarm ou RdBu. Para dados categóricos, use tab10 ou Set1. Para dados cíclicos como ângulos, use twilight. Sempre considere acessibilidade — viridis e cividis são seguros para pessoas daltônicas.

Como crio um colormap personalizado no Matplotlib?

Use matplotlib.colors.ListedColormap para criar um colormap a partir de uma lista de cores específicas, ou use matplotlib.colors.LinearSegmentedColormap.from_list('name', colors) para criar um gradiente suave entre cores âncora. Registre-o com plt.colormaps.register() para usá-lo por nome.

Como inverto um colormap no Matplotlib?

Acrescente _r ao nome de qualquer colormap. Por exemplo, cmap='viridis_r' retorna a versão invertida de viridis. Isso funciona para todos os colormaps integrados. Para colormaps personalizados, chame o método .reversed() no objeto colormap.

Por que devo evitar o colormap jet?

O colormap jet tem não uniformidades perceptuais que criam fronteiras falsas e escondem padrões reais nos dados. Ele também falha para pessoas com daltonismo vermelho-verde. O Matplotlib mudou seu padrão de jet para viridis na versão 2.0 especificamente por causa desses problemas. Em vez disso, use viridis, plasma ou cividis.

Como adiciono uma colorbar a um plot do Matplotlib?

Chame plt.colorbar(mappable), onde mappable é o objeto retornado por imshow, scatter, contourf ou funções semelhantes. Personalize com parâmetros como label, orientation ('horizontal' ou 'vertical'), shrink e pad. Você também pode acessar os eixos da colorbar com cbar.ax para um controle mais detalhado.

Conclusão

Colormaps não são escolhas decorativas — são componentes funcionais que determinam se sua visualização comunica a verdade de forma fiel ou engana. O Matplotlib oferece uma grande biblioteca de colormaps integrados organizados em quatro categorias claras (sequenciais, divergentes, qualitativos e cíclicos), além de ferramentas para construir colormaps totalmente personalizados quando necessário. A família perceptualmente uniforme (viridis, plasma, inferno, magma, cividis) deve ser seu ponto de partida padrão para qualquer dado sequencial. Para dados divergentes, escolha um mapa como coolwarm ou RdBu e sempre centralize a cor neutra no ponto médio significativo dos seus dados. Para categorias, use tab10 ou Set1. E sempre considere seu público — usar colormaps amigáveis para daltonismo não é opcional, é prática profissional.