5 Maneiras Comuns de Usar Matplotlib Colormaps (cmaps)

Name

Elwynn AI

Updated on 15/11/2025

O sistema de colormap (cmap) do Matplotlib é muito mais rico do que “apenas escolher um esquema de cores”. Depois que você entende a API, é possível:

• Visualizar valores contínuos (heatmaps, imagens)
• Codificar dimensões extras em gráficos de dispersão
• Criar colormaps discretos para categorias
• Usar escalas não lineares (log, por faixas) para dados complicados
• Amostrar cores de um colormap para estilizar seus próprios gráficos

Neste post vamos passar por 5 padrões comuns com código + gráficos reais. Você pode copiar e colar cada trecho diretamente no seu notebook ou script.

Todos os exemplos assumem:

import numpy as np
import matplotlib.pyplot as plt

1. Colormap contínuo com imshow

O uso mais básico de colormaps é visualizar arrays 2D com imshow — por exemplo heatmaps, imagens ou qualquer grade regular.

Código

import numpy as np
import matplotlib.pyplot as plt
 
# Generate some random-ish 2D data
data = np.random.randn(50, 50).cumsum(axis=0)
 
plt.figure()
plt.imshow(data, cmap="viridis")
plt.colorbar()
plt.title("Continuous colormap with imshow (viridis)")
plt.tight_layout()
plt.show()

Gráfico

Você obtém um heatmap suave usando o colormap perceptualmente uniforme viridis:

(Isso corresponde à primeira imagem acima: um heatmap roxo–verde com uma barra de cores.)

Pontos principais:

• cmap="viridis" seleciona o colormap.
• plt.colorbar() desenha uma escala de cores para o leitor interpretar os valores.
• Qualquer array 2D do NumPy pode ser passado para imshow.

2. Gráfico de dispersão com colormap e colorbar

Você pode usar colormaps para codificar uma dimensão numérica extra em um gráfico de dispersão (por exemplo tempo, intensidade, probabilidade).

Código

import numpy as np
import matplotlib.pyplot as plt
 
np.random.seed(0)
x = np.linspace(0, 10, 200)
y = np.sin(x) + 0.1 * np.random.randn(200)
 
# A separate value for each point, mapped to a colormap
values = np.linspace(0, 1, 200)
 
plt.figure()
scatter = plt.scatter(x, y, c=values, cmap="plasma")
plt.colorbar(scatter, label="value")
plt.title("Scatter with colormap (plasma)")
plt.xlabel("x")
plt.ylabel("sin(x) + noise")
plt.tight_layout()
plt.show()

Gráfico

Você obtém um gráfico de dispersão em que as cores dos pontos mudam suavemente ao longo do colormap plasma, com uma colorbar que explica o significado das cores.

Pontos principais:

• c=values fornece os dados numéricos a serem mapeados em cores.
• cmap="plasma" escolhe o colormap.
• Passe o objeto scatter para plt.colorbar() para obter uma colorbar correspondente.

3. Colormap discreto para categorias

Colormaps são contínuos por padrão, mas você também pode usá-los para criar um pequeno conjunto de cores discretas para categorias (resultados de classificação, rótulos, etc.).

Código

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
 
# Fake 4-category classification
categories = np.random.randint(0, 4, 100)
x = np.random.randn(100)
y = np.random.randn(100)
 
# Build a discrete colormap from the first 4 colors of tab10
base_cmap = plt.cm.tab10
cmap_disc = ListedColormap(base_cmap(np.linspace(0, 1, 4)))
 
plt.figure()
for i in range(4):
    mask = categories == i
    # Use a single color for each class
    plt.scatter(x[mask], y[mask], c=[cmap_disc(i)], label=f"class {i}")
 
plt.legend()
plt.title("Discrete colormap for categories (tab10 subset)")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.show()

Gráfico

Você verá um gráfico de dispersão em que cada categoria (0–3) tem sua própria cor distinta (vinda de tab10).

Pontos principais:

• ListedColormap permite construir um colormap a partir de uma lista de cores.
• Isso é ótimo quando você precisa de um pequeno número de cores estáveis para categorias.
• Usamos tab10 (um bom colormap qualitativo padrão) e pegamos 4 cores dele.

4. Usando normalização (LogNorm) com um colormap

Às vezes os dados se estendem por várias ordens de grandeza. Mapeá-los linearmente para cores pode esconder estrutura. Em vez disso, combine um colormap com uma função de normalização como LogNorm.

Código

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
 
x = np.linspace(0.01, 2, 200)
y = np.linspace(0.01, 2, 200)
X, Y = np.meshgrid(x, y)
Z = np.exp(X * Y)  # Grows very quickly
 
plt.figure()
pcm = plt.pcolormesh(X, Y, Z, norm=LogNorm(), cmap="magma")
plt.colorbar(pcm, label="exp(x * y)")
plt.title("LogNorm with colormap (magma)")
plt.xlabel("x")
plt.ylabel("y")
plt.tight_layout()
plt.show()

Gráfico

Você verá um campo 2D colorido no qual regiões com valores pequenos e grandes são ambas visíveis, graças à escala logarítmica, usando magma.

Pontos principais:

• norm=LogNorm() controla como os valores são mapeados para o intervalo [0, 1] antes de aplicar o cmap.
• Funciona com pcolormesh, imshow, scatter, etc.
• Outros norms: Normalize, BoundaryNorm, PowerNorm, etc.

5. Amostrando cores de um colormap para gráficos de linhas

Colormaps não servem apenas para gráficos “preenchidos”. Você pode amostrar cores individuais de um colormap e usá-las onde quiser — em linhas, barras, anotações, etc.

Código

import numpy as np
import matplotlib.pyplot as plt
 
cmap = plt.cm.cividis   # choose any colormap you like
xs = np.linspace(0, 10, 200)
 
plt.figure()
for i, freq in enumerate(np.linspace(0.5, 2.5, 6)):
    ys = np.sin(freq * xs)
    color = cmap(i / 5.0)   # sample evenly across the colormap
    plt.plot(xs, ys, label=f"freq={freq:.1f}", color=color)
 
plt.legend(title="frequency")
plt.title("Sampling colors from colormap (cividis)")
plt.xlabel("x")
plt.ylabel("sin(freq * x)")
plt.tight_layout()
plt.show()

Gráfico

Você obterá várias ondas seno, cada uma com uma cor diferente retirada de cividis, variando suavemente ao longo do colormap.

Pontos principais:

• plt.cm.<name> fornece um objeto colormap que você pode chamar como função.
• cmap(t) retorna uma cor RGBA para t em [0, 1].
• Esta é uma forma prática de obter paletas de cores consistentes e visualmente agradáveis.

Conclusão

Esses 5 padrões cobrem boa parte do uso diário de colormaps no Matplotlib:

1. Heatmaps contínuos com imshow + cmap.
2. Gráficos de dispersão em que a cor codifica uma dimensão de valor extra.
3. Cores categóricas discretas usando ListedColormap.
4. Escalas não lineares com LogNorm (e similares) + colormaps.
5. Amostragem de cores de um colormap para estilos personalizados (linhas, barras, etc.).

Depois de se sentir confortável com esses padrões, você pode explorar:

• Colormaps personalizados (a partir de suas próprias listas de cores ou ferramentas externas)
• BoundaryNorm para faixas de valores discretas (por exemplo, bins)
• Colormaps perceptualmente uniformes (viridis, plasma, cividis, etc.) para melhor legibilidade e acessibilidade