Matplotlib Colormaps: Interactive Explorer and Complete Gallery

Name

Soren Atelier

Published on 11/15/2025

Updated on 8/19/2026

A colormap (cmap) is the lookup table Matplotlib uses to turn numbers into colors. Any plotting call that takes a c= or a 2D array also takes cmap=, and you set it by name:

import matplotlib.pyplot as plt
 
plt.imshow(data, cmap="viridis")   # heatmaps, images, 2D arrays
plt.scatter(x, y, c=values, cmap="plasma")   # color encodes a third variable
plt.colorbar()   # always add this so the colors are readable

Append _r to reverse any colormap (viridis_r, Blues_r). If you only need one rule: use viridis for ordered data, RdBu when zero matters, and tab10 for categories.

The explorer below renders every colormap that ships with Matplotlib, grouped the way the official docs group them. Click a color bar to copy its cmap= argument.

Which family should you use?

Pick the family from the shape of your data, then pick a name inside it for taste.

Two rules cover most mistakes:

• Never use a qualitative map for continuous data. tab10 on a heatmap creates bands that are not in the data.
• Never use a diverging map without centering the norm. plt.imshow(data, cmap="RdBu") on data from 3 to 90 puts the white midpoint at 46.5, which reads as "neutral" even though nothing is neutral there. Use TwoSlopeNorm(vcenter=0) instead.

from matplotlib.colors import TwoSlopeNorm
 
norm = TwoSlopeNorm(vmin=data.min(), vcenter=0, vmax=data.max())
plt.imshow(data, cmap="RdBu_r", norm=norm)
plt.colorbar()

Accessibility: what "CB-safe" means in the explorer

Roughly 1 in 12 men and 1 in 200 women have some form of color vision deficiency, most commonly red-green. The badge in the explorer marks colormaps that stay readable under the common forms, because they vary in lightness and not only in hue.

Practical guidance:

• Prefer the perceptually uniform maps (viridis, magma, inferno, plasma, cividis). cividis is specifically designed to look near-identical to readers with and without deuteranomaly.
• For diverging data, prefer RdBu, BrBG, or PuOr over bwr — pure red against pure blue is the exact pairing that collapses for red-green deficiency.
• For categories, tab10 and Dark2 hold up better than Set1. Matplotlib 3.11 also ships okabe_ito, the reference colorblind-safe categorical set.
• Whatever you choose, test it in grayscale. If the figure survives being printed in black and white, it survives most color vision deficiencies too.

Why you should stop using jet

jet and rainbow are still the fastest way to make a misleading figure. Their lightness is not monotonic: it peaks in the cyan and yellow bands and drops at both ends. The eye reads those bright bands as edges, so the colormap invents boundaries that do not exist in the data. The same figure rendered in viridis shows a smooth gradient.

If you inherited code that uses jet, viridis is a drop-in replacement for scientific data, and turbo is the drop-in replacement when you specifically want a rainbow-like high-contrast map without the false banding.

Setting a colormap once for the whole script

Rather than repeating cmap= in every call, set the default:

import matplotlib.pyplot as plt
 
plt.rcParams["image.cmap"] = "viridis"   # applies to imshow, pcolormesh, contourf

For the categorical color cycle used by plot() and bar(), set the property cycle instead:

from cycler import cycler
 
colors = plt.get_cmap("tab10").colors
plt.rcParams["axes.prop_cycle"] = cycler(color=colors)

See Matplotlib style sheets for packaging these defaults into a reusable style.

Five patterns you will actually use

All examples assume:

import numpy as np
import matplotlib.pyplot as plt

1. Continuous colormap with imshow

The most basic use of colormaps is to visualize 2D arrays with imshow — heatmaps, images, or any regular grid.

import numpy as np
import matplotlib.pyplot as plt
 
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()

You get a smooth heatmap using the perceptually uniform viridis colormap. plt.colorbar() draws the color scale, without which the reader cannot map color back to value.

2. Scatter plot with a colormap and colorbar

Colormaps let you encode an extra numeric dimension in a scatter plot — time, intensity, probability.

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)
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.tight_layout()
plt.show()

c=values supplies the numbers to map; pass the returned scatter object to plt.colorbar() so the bar matches the points. More scatter options: Matplotlib scatter plot.

3. Discrete colors for categories

Colormaps are continuous by default, but you can slice a small set of stable colors for classification results or labels.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
 
categories = np.random.randint(0, 4, 100)
x = np.random.randn(100)
y = np.random.randn(100)
 
base_cmap = plt.get_cmap("tab10")
cmap_disc = ListedColormap(base_cmap(np.linspace(0, 1, 4)))
 
plt.figure()
for i in range(4):
    mask = categories == i
    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.tight_layout()
plt.show()

ListedColormap builds a colormap from an explicit list of colors — the right tool when you need a small number of stable category colors. For placing the resulting key, see Matplotlib legend.

4. Nonlinear scaling with LogNorm

When data spans several orders of magnitude, a linear mapping hides structure. Combine the colormap with a normalization.

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)
 
plt.figure()
pcm = plt.pcolormesh(X, Y, Z, norm=LogNorm(), cmap="magma")
plt.colorbar(pcm, label="exp(x * y)")
plt.tight_layout()
plt.show()

The norm controls how values map into [0, 1] before the colormap is applied. Other useful norms: Normalize, BoundaryNorm (for binned ranges), PowerNorm, and TwoSlopeNorm.

5. Sampling colors from a colormap

Colormaps are callable. cmap(t) returns an RGBA color for t in [0, 1], which is how you give a set of lines a coherent color progression.

import numpy as np
import matplotlib.pyplot as plt
 
cmap = plt.get_cmap("cividis")
xs = np.linspace(0, 10, 200)
 
plt.figure()
for i, freq in enumerate(np.linspace(0.5, 2.5, 6)):
    plt.plot(xs, np.sin(freq * xs), label=f"freq={freq:.1f}", color=cmap(i / 5.0))
 
plt.legend(title="frequency")
plt.tight_layout()
plt.show()

Note that plt.cm.<name> still works but plt.get_cmap("name") is the form that keeps working across Matplotlib 3.7+ deprecations of the matplotlib.cm registry helpers.

Common errors

Related Guides

• Matplotlib Colormap: Complete Guide — the concept guide, including building custom colormaps and tuning colorbars.
• Seaborn Color Palettes — the Seaborn side of the same problem, with deep, rocket, vlag, and an interactive palette explorer.
• Seaborn Heatmap — where colormap choice matters most in practice.
• Matplotlib Style Sheets — lock your colormap and color cycle into a reusable style.
• Matplotlib Scatter Plot — the plot type that most often carries a colormap as a third dimension.
• Matplotlib Plot Image — imshow details, interpolation, and aspect handling.