Mapas de cores do Matplotlib: Personalizando seus esquemas de cores

A visualização de dados é uma das melhores maneiras (se não a melhor) de analistas e cientistas de dados representarem informações complexas e gerarem percepções significativas. Para que você aproveite ao máximo a oportunidade de se comunicar com as partes interessadas, compilei informações úteis sobre os mapas de cores do Matplotlib. 

Como você verá neste artigo, o Matplotlib é uma biblioteca de visualização extremamente versátil e extensível em Python. Ele oferece todas as opções, desde gráficos simples até visuais totalmente interativos. Se você não estiver familiarizado com Python, recomendo que se inscreva em nosso curso de Introdução a Python antes de começarmos a entender sua base. Pessoalmente, também mantenho a Python Cheat Sheet por perto, pois ela é uma referência útil para funções comuns.

Escolhendo o mapa de cores correto do Matplotlib

Uma das primeiras coisas a considerar é decidir entre mapas de cores sequenciais, divergentes ou categóricos. Outros fatores importantes a serem considerados na escolha de mapas de cores incluem a uniformidade perceptual, o que significa que diferenças iguais nos valores dos dados são percebidas como diferenças iguais na cor, e o uso de opções de mapas de cores amigáveis para daltônicos para tornar seus visuais acessíveis a todos os públicos.

Você também deve considerar os diferentes padrões de domínio ao escolher os mapas de cores. Por exemplo, diferentes tons de azul representam diferentes profundidades de água em estudos oceanográficos. Se você não tiver certeza sobre o mapa de cores correto para a sua visualização, há diferentes ferramentas e recursos disponíveis para orientação. Em particular, nosso próprio curso Introduction to Data Visualization with Matplotlib ajuda você a trabalhar em vários cenários.

Mapas de cores diferentes no Matplotlib

No Python, o módulo matplotlib.colormaps fornece acesso a mapas de cores integrados, o que ajuda você a selecionar o melhor esquema para o seu projeto. A seguir estão as categorias mais comuns de opções:

Mapas de cores sequenciais

Os mapas de cores sequenciais representam dados ordenados que progridem de valores baixos para altos. Eles passam de tons claros para escuros, mostrando a magnitude dos dados em diferentes níveis. Um exemplo de mapa de cores sequencial está nos mapas de calor para dados de temperatura, em que as cores mais claras representam temperaturas mais frias e os tons mais escuros representam temperaturas mais quentes.

Suponha que você tenha um conjunto de dados com colunas de data e temperatura. O código a seguir criará um mapa de calor para a temperatura.

# Import required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Step 1: Extract month and day information from the date column
calendar_data = temperature_data.copy()   # Create a copy to work with
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

# Step 2: Define the order of months for a natural calendar sequence
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

# Convert the 'Month' column to a categorical type with the specified order
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

# Step 3: Pivot the data to create a structured table for the heatmap
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

# Step 4: Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range (optional)
norm = mcolors.Normalize(vmin=15, vmax=35)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Exemplo de visualização de mapas de cores sequenciais do Matplotlib. Imagem do autor

Mapas de cores divergentes

Os mapas de cores divergentes destacam os dados com desvios de um valor central em ambas as direções. Os mapas de cores divergentes têm cores contrastantes para as direções positivas e negativas. Uma aplicação comum de mapas de cores divergentes é em dados financeiros para representar lucros e perdas.

# Set 'Month' as the index
monthly_profit_loss_data.set_index('Month', inplace=True)

# Set the figure size
plt.figure(figsize=(8, 4))

# Create a diverging heatmap using Seaborn
# Use 'RdYlGn' colormap for diverging colors (Red for loss, Green for profit)
sns.heatmap(monthly_profit_loss_data.T, cmap='RdYlGn', center=0, annot=True, fmt='.0f', cbar_kws={'label': 'Profit/Loss ($)'})

# Add labels for the axes
plt.xlabel('Month')
plt.ylabel('')

# Add a title
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Display the plot
plt.show()

Exemplo de visualização de mapa de cores divergentes do Matplotlib. Imagem do autor.

Mapas de cores cíclicas

Os mapas de cores cíclicos são úteis para visualizar dados que representam um padrão repetitivo ou cíclico, como ângulos, fases de ondas ou hora do dia. Um exemplo de um mapa de cores cíclico em ação é a visualização das fases de uma função periódica, como uma onda senoidal.

# Create data for a sine wave
x = np.linspace(0, 2 * np.pi, 100)  # X values from 0 to 2π (one complete cycle)
y = np.sin(x)  # Y values (sine of X)

# Create a figure and axis
plt.figure(figsize=(10, 6))

# Create a scatter plot with a cyclic colormap
# Color points by their position in the sine wave cycle
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Add a color bar to show the phase of the wave
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Label the axes
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Add a title
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Display the plot
plt.grid(True)
plt.show()

Exemplo de visualização de mapa de cores cíclico do Matplotlib. Imagem do autor.

Mapas de cores qualitativos

Os mapas de cores qualitativos são ideais para representar dados categóricos sem uma ordem específica das categorias. Um caso de uso comum de mapas de cores qualitativos é um gráfico de pizza em que cada segmento representa uma categoria diferente que pode ser facilmente distinguida.

# Sample categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Set the figure size
plt.figure(figsize=(8, 8))

# Define a qualitative colormap manually (similar to 'Set3' in Seaborn)
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Manually selected color hex codes

# Create a pie chart
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Equal aspect ratio ensures the pie is drawn as a circle
plt.axis('equal')

# Add a title
plt.title('Pie Chart with Qualitative Colormap')

# Display the chart
plt.show()

Exemplo de visualização de mapa de cores qualitativo do Matplotlib. Imagem do autor.

Mapas de cores do arco-íris

Os mapas de cores do arco-íris, como hsv, são usados quando você precisa de uma ampla gama de tons.

# Generate cyclic data
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

# Create a plot with rainbow colormap
plt.scatter(x, y, c=x, cmap='hsv', s=50)

# Add a color bar
plt.colorbar(label='Phase')

# Add labels and title
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

# Display the plot
plt.show()

Exemplo de visualização de mapa de cores do arco-íris do Matplotlib. Imagem do autor.

Mapas de cores perceptualmente uniformes

Mapas de cores como inferno e plasma oferecem melhor visibilidade em diferentes mídias de exibição.

# Generate synthetic elevation data
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2)) * 100  # Elevation data

# Plot the elevation data using the 'plasma' colormap
plt.contourf(X, Y, Z, cmap='plasma')

# Add a color bar
plt.colorbar(label='Elevation (m)')

# Add title and labels
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

# Display the plot
plt.show()

Exemplo de visualização de mapa de cores perceptualmente uniforme do Matplotlib. Imagem do autor.

Criando e modificando mapas de cores do Matplotlib

Embora o Matplotlib tenha uma grande variedade de mapas de cores integrados, há situações em que você pode querer personalizar as cores. As principais ferramentas para criar mapas de cores personalizados no Matplotlib são ListedColormap e LinearSegmentedColormap.

Criando um mapa de cores personalizado com ListedColormap

ListedColomap permite que você crie um mapa de cores a partir de uma lista de cores específicas. Esse método é útil ao atribuir cores específicas a categorias distintas em dados categóricos. 

from matplotlib.colors import ListedColormap

# Categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D']
values = [25, 40, 35, 30]

# Custom color list for the colormap (e.g., shades of blue, green, red, and purple)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Create a ListedColormap using the custom colors
custom_cmap = ListedColormap(custom_colors)

# Set the figure size
plt.figure(figsize=(8, 6))

# Create a bar plot with the custom colormap
bars = plt.bar(categories, values, color=custom_cmap.colors)

# Add a title
plt.title('Bar Chart with Custom ListedColormap')

# Label the axes
plt.xlabel('Categories')
plt.ylabel('Values')

# Display the plot
plt.show()

Mapa de cores personalizado do Matplotlib com ListedColormap. Imagem do autor.

Criando um mapa de cores personalizado com LinearSegmentedColormap

LinearSegmentedColormap permite que você crie mapas de cores que fazem uma transição suave entre as cores. É importante saber isso porque os dados contínuos geralmente exigem mudanças de cor gradiente. Aqui, também estou especificando o número de intervalos que desejo para o meu visual.

from matplotlib.colors import LinearSegmentedColormap

# Create a grid of values for a 2D Gaussian function
x = np.linspace(-2, 2, 500)
y = np.linspace(-2, 2, 500)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2))

# Define a custom colormap that transitions from blue to white to red
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

# Adjust the number of color classes (discrete levels)
# Specify the number of levels (e.g., 10 for 10 distinct color bands)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

# Set the figure size
plt.figure(figsize=(8, 6))

# Plot the 2D Gaussian function with the adjusted colormap
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

# Add a color bar to show the discrete color classes
plt.colorbar(contour, label='Gaussian Function Value')

# Add labels for the axes
plt.xlabel('X')
plt.ylabel('Y')

# Add a title
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

# Display the plot
plt.show()

Ajuste personalizado do Matplotlib do número de classes de cores. Imagem do autor.

Personalização de faixas de cores e intensidade

Você pode controlar a intensidade ou o intervalo de cores em um mapa de cores existente manipulando sua normalização ou dividindo-o para usar um subconjunto das cores disponíveis. No exemplo a seguir, as faixas de cores são divididas para mostrar temperaturas entre 16 e 40 graus Celsius.

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Matplotlib personalizando intervalos e intensidade de cores. Imagem do autor.

Combinação de mapas de cores existentes

Você também pode combinar mapas de cores existentes, mesclando vários mapas de cores para criar visualizações mais complexas.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Create synthetic elevation data
x = np.linspace(-180, 180, 500)  # Longitude
y = np.linspace(-90, 90, 250)    # Latitude
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Synthetic elevation data

# Define the base colormaps ('viridis' and 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Create a custom colormap by blending the two base colormaps
def blend_colormaps(cmap1, cmap2, blend_ratio=0.5):
    """Blend two colormaps together."""
    c1 = cmap1(np.linspace(0, 1, 256))
    c2 = cmap2(np.linspace(0, 1, 256))
    blended_colors = (1 - blend_ratio) * c1 + blend_ratio * c2
    return LinearSegmentedColormap.from_list('blended_cmap', blended_colors)

# Create the blended colormap
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Normalize the data for visualization
norm = Normalize(vmin=-5000, vmax=5000)

# Set the figure size
plt.figure(figsize=(12, 6))

# Plot the synthetic elevation data with the blended colormap
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Add a color bar to show the blended color mapping
plt.colorbar(contour, label='Elevation (meters)')

# Add labels for the axes
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Add a title
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Display the plot
plt.show()

Matplotlib Combinação de mapas de cores existentes. Imagem do autor.

Inversão de mapas de cores usando o sufixo _r

Você pode reverter qualquer mapa de cores no Matplotlib acrescentando o sufixo _r em seu nome.

# Import required libraries
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Create a custom normalization for the color range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Set the figure size
plt.figure(figsize=(12, 8))

# Create a heatmap with a sequential colormap
ax = sns.heatmap(temperature_pivot, cmap='YlOrRd_r', cbar=True, square=True, norm=norm, cbar_kws={'orientation': 'horizontal'})

# Add labels for the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Add a color bar label (temperature in °C)
colorbar = ax.collections[0].colorbar
colorbar.set_label('Temperature (°C)', labelpad=10)

# Add a title
plt.title('Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.show()

Matplotlib Inversão de mapas de cores usando o sufixo _r. Imagem do autor.

Como lidar com erros comuns nos mapas de cores do Matplotlib

Ao trabalhar com mapas de cores no Matplotlib, você pode encontrar erros que afetam seu fluxo de trabalho. A seguir, você encontrará alguns dos erros e como solucioná-los.

AttributeError: o módulo 'matplotlib' não tem o atributo 'colormaps'

Esse erro ocorre quando você usa versões do Matplotlib anteriores à 3.4.0 para acessar matplotlib.colormaps. O atributo colormaps foi introduzido no Matplotlib 3.4.0. Primeiro, verifique sua versão do Matplotlib usando o código abaixo para solucionar esse erro.

import matplotlib
print(matplotlib.__version__)

Faça a atualização usando o seguinte comando pip.

pip install --upgrade matplotlib

Se você tiver problemas para atualizar sua versão do Matplotlib, tente o seguinte método para acessar os mapas de cores.

plt.get_cmap('viridis')  # instead of matplotlib.colormaps['viridis']

Atribuições de cores incorretas

Você poderá ter atribuições de cores incorretas quando passar um valor fora do intervalo esperado ou quando o mapa de cores for aplicado incorretamente. A atribuição incorreta de cores também pode ocorrer se o mapa de cores for destinado a dados contínuos, mas for aplicado a dados categóricos ou vice-versa.

Para garantir que seus dados estejam dentro do intervalo esperado, sempre normalize ou dimensione-os usando os parâmetros vmax e vmin.

import matplotlib.colors as mcolors

# Create a sample temperature dataset
data = np.random.rand(10, 10) * 100  # Adjust the range to match your data

# Create a color normalization instance to scale the data to the colormap's range
norm = mcolors.Normalize(vmin=0, vmax=100)

# Create a heatmap using the 'viridis' colormap and the specified normalization
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Para um controle mais preciso, você pode definir explicitamente os limites de cor usando os parâmetros boundaries ou norm nas funções de plotagem.

Artefatos visuais e resultados inesperados

Ao trabalhar com dados discretos ou de baixa resolução, você pode experimentar faixas de cores não intencionais, contraste excessivo ou sangramento de cores. O problema ocorre quando seus dados têm um intervalo limitado, mas são exibidos com um mapa de cores contínuo.

Para resolver esse problema, use mais pontos de dados ou ajuste o número de níveis de cores para suavizar as transições.

# Increase the number of bins in the colormap
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

Você pode dividir o mapa de cores em níveis fixos para lidar com dados discretos, quando apropriado.

cmap = plt.get_cmap('inferno', 10)  # Divide colormap into 10 discrete levels
plt.imshow(data, cmap=cmap)

Você também pode verificar as configurações de exibição e ajustar a resolução, especialmente ao salvar as visualizações para evitar gráficos de baixa resolução

plt.savefig('plot.png', dpi=300)  # Save the figure with a higher resolution

Distorção de cores devido ao recorte

A distorção de cores ocorre quando os dados contêm valores extremos fora da faixa de cores esperada. Isso faz com que partes dos dados sejam cortadas e atribuídas à cor mínima ou máxima no mapa de cores.

Para evitar a distorção de cores, ajuste os limites de cores usando vmin e vmax para que correspondam ao intervalo dos dados, evitando o recorte.

plt.imshow(data, cmap='plasma', vmin=0, vmax=100)

Você também deve usar o dimensionamento robusto para lidar com valores discrepantes, definindo limites personalizados que excluam valores extremos.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Use percentiles to remove extreme outliers
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

O mapa de cores não está sendo exibido corretamente em gráficos 3D

Se houver um problema com a forma como os dados são mapeados na superfície 3D, os mapas de cores poderão não ser exibidos corretamente nas visualizações 3D. Para resolver o problema, certifique-se de que os dados do eixo z estejam normalizados para se ajustarem ao intervalo esperado do mapa de cores. Além disso, use os limites apropriados do mapa de cores para capturar toda a faixa dos valores z.

from mpl_toolkits.mplot3d import Axes3D

# Generate sample data for a 3D surface plot
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

# Create a 3D axes object
ax = plt.axes(projection='3d')

# Plot the surface using the 'viridis' colormap and adjusting the color limits
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Conclusão

A escolha do mapa de cores correto é uma etapa importante, pois realmente afeta a forma como os usuários visualizam e entendem seus dados. Na minha opinião, gastar muito tempo na análise de dados e ser desleixado na etapa final, que é a parte em que você comunica suas descobertas, é um grande erro.

Felizmente, o Matplotlib oferece muitas opções para você garantir que seus recursos visuais contem uma história interessante. Inscreva-se em nosso curso, Introdução à visualização de dados com Matplotlib, para que você se torne um especialista. Além disso, se você for um usuário de Python que também usa o Seaborn para visualização (é ótimo conhecer os dois), leia nosso Guia rápido para escolher cores no Seaborn e siga-o com nosso curso Introdução à visualização de dados com o Seaborn.