Invert Colormap in Matplotlib
Matplotlib is a powerful data visualization library in Python that offers a wide range of tools for creating stunning and informative plots. One of the key features of Matplotlib is its ability to work with colormaps, which are used to map numerical values to colors in visualizations. In this comprehensive guide, we will explore the concept of inverting colormaps in Matplotlib, discussing various techniques, use cases, and providing detailed examples to help you master this important aspect of data visualization.
Understanding Colormaps in Matplotlib
Before diving into the process of inverting colormaps, it’s essential to have a solid understanding of what colormaps are and how they function in Matplotlib. A colormap is a mapping from numerical values to colors, which is used to represent data in a visual format. Matplotlib provides a wide variety of builtin colormaps, each designed for specific types of data and visualization needs.
Colormaps can be broadly categorized into several types:
 Sequential colormaps: These are used for data that has a natural ordering, such as temperature or elevation. They typically range from light to dark colors or vice versa.

Diverging colormaps: These are used for data that has a meaningful center point, such as positive and negative values around zero. They typically have contrasting colors at the extremes and a neutral color in the middle.

Qualitative colormaps: These are used for categorical data, where each color represents a distinct category.

Cyclic colormaps: These are used for data that wraps around, such as angles or phases. They typically have colors that smoothly transition and loop back to the starting color.
Let’s start with a basic example of using a colormap in Matplotlib:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample data
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
# Create a figure and axis
fig, ax = plt.subplots(figsize=(10, 8))
# Create a contour plot with a colormap
contour = ax.contourf(X, Y, Z, cmap='viridis')
# Add a colorbar
cbar = plt.colorbar(contour)
cbar.set_label('Value')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_title('Contour Plot with Viridis Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we create a contour plot using the ‘viridis’ colormap, which is a popular sequential colormap. The contourf
function is used to create filled contours, and the cmap
parameter specifies the colormap to be used.
Inverting Colormaps in Matplotlib
Inverting a colormap in Matplotlib means reversing the order of colors in the colormap. This can be useful in various scenarios, such as:
 Improving visibility of certain features in your data
 Matching the colormap to specific domain conventions
 Creating a different visual emphasis in your plots
 Accommodating color vision deficiencies
Matplotlib provides several ways to invert colormaps. Let’s explore these methods in detail.
Using the ‘_r’ Suffix
The simplest way to invert a colormap in Matplotlib is by appending ‘_r’ to the colormap name. This works for all builtin colormaps and creates a reversed version of the original colormap.
Let’s modify our previous example to use an inverted ‘viridis’ colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample data
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
# Create a figure and axis
fig, ax = plt.subplots(figsize=(10, 8))
# Create a contour plot with an inverted colormap
contour = ax.contourf(X, Y, Z, cmap='viridis_r')
# Add a colorbar
cbar = plt.colorbar(contour)
cbar.set_label('Value')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_title('Contour Plot with Inverted Viridis Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we simply changed cmap='viridis'
to cmap='viridis_r'
. The ‘_r’ suffix tells Matplotlib to use the reversed version of the ‘viridis’ colormap.
Colormap Inversion in Different Plot Types
Colormap inversion can be applied to various types of plots in Matplotlib. Let’s explore how to invert colormaps in different plot types.
Heatmaps
Heatmaps are an excellent way to visualize 2D data, and inverting the colormap can sometimes reveal patterns that might not be apparent otherwise.
Here’s an example of creating a heatmap with an inverted colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample data
data = np.random.rand(10, 10)
# Create a figure and axis
fig, ax = plt.subplots(figsize=(10, 8))
# Create a heatmap with an inverted colormap
heatmap = ax.imshow(data, cmap='YlOrRd_r')
# Add a colorbar
cbar = plt.colorbar(heatmap)
cbar.set_label('Value')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_title('Heatmap with Inverted YlOrRd Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we use the inverted ‘YlOrRd’ colormap (‘YlOrRd_r’) to create a heatmap. The inverted colormap can help emphasize different aspects of the data compared to the original colormap.
3D Surface Plots
Inverting colormaps can also be useful in 3D surface plots, where it can help highlight different features of the surface.
Here’s an example of a 3D surface plot with an inverted colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample 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))
# Create a figure and 3D axis
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
# Create a 3D surface plot with an inverted colormap
surf = ax.plot_surface(X, Y, Z, cmap='coolwarm_r', linewidth=0, antialiased=False)
# Add a colorbar
cbar = fig.colorbar(surf)
cbar.set_label('Value')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_zlabel('Zaxis')
ax.set_title('3D Surface Plot with Inverted Coolwarm Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we create a 3D surface plot using the inverted ‘coolwarm’ colormap.Certainly! Let’s continue with more advanced topics and examples related to inverting colormaps in Matplotlib.
Scatter Plots with Inverted Colormaps
Scatter plots are another type of visualization where inverting colormaps can be useful, especially when dealing with large datasets or when you want to emphasize certain data points.
Here’s an example of a scatter plot with an inverted colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample data
np.random.seed(42)
x = np.random.rand(1000)
y = np.random.rand(1000)
colors = np.random.rand(1000)
# Create a figure and axis
fig, ax = plt.subplots(figsize=(10, 8))
# Create a scatter plot with an inverted colormap
scatter = ax.scatter(x, y, c=colors, cmap='autumn_r', alpha=0.6)
# Add a colorbar
cbar = plt.colorbar(scatter)
cbar.set_label('Value')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_title('Scatter Plot with Inverted Autumn Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we create a scatter plot using the inverted ‘autumn’ colormap. The inverted colormap can help highlight different patterns or clusters in the data.
Creating Custom Inverted Colormaps
While Matplotlib provides many builtin colormaps that can be easily inverted, you might sometimes need to create a custom colormap and invert it. Let’s explore how to do this.
Creating a Custom Colormap from Scratch
First, let’s create a custom colormap from scratch and then invert it:
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LinearSegmentedColormap
# Define custom colors
colors = ['#FF0000', '#00FF00', '#0000FF'] # Red, Green, Blue
# Create a custom colormap
n_bins = 100 # Number of bins
custom_cmap = LinearSegmentedColormap.from_list('custom_cmap', colors, N=n_bins)
# Create an inverted version of the custom colormap
inverted_custom_cmap = LinearSegmentedColormap.from_list('inverted_custom_cmap', list(reversed(colors)), N=n_bins)
# Create some sample data
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(X) * np.cos(Y)
# Create a figure with two subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
# Plot with the original custom colormap
contour1 = ax1.contourf(X, Y, Z, cmap=custom_cmap)
cbar1 = plt.colorbar(contour1, ax=ax1)
cbar1.set_label('Value')
ax1.set_title('Original Custom Colormap  how2matplotlib.com')
# Plot with the inverted custom colormap
contour2 = ax2.contourf(X, Y, Z, cmap=inverted_custom_cmap)
cbar2 = plt.colorbar(contour2, ax=ax2)
cbar2.set_label('Value')
ax2.set_title('Inverted Custom Colormap  how2matplotlib.com')
# Show the plot
plt.tight_layout()
plt.show()
Output:
In this example, we create a custom colormap using three colors (red, green, and blue) and then create an inverted version of it. We then use both the original and inverted colormaps to create two contour plots side by side for comparison.
Colormap Inversion in Specialized Plots
Let’s explore how to invert colormaps in some specialized types of plots that Matplotlib offers.
Polar Plots
Polar plots are useful for visualizing directional or cyclical data. Inverting colormaps in polar plots can help emphasize different aspects of the data.
Here’s an example of a polar plot with an inverted colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample data
r = np.linspace(0, 2, 100)
theta = np.linspace(0, 2*np.pi, 100)
R, Theta = np.meshgrid(r, theta)
Z = R**2 * (1  R/2) * np.cos(5*Theta)
# Create a figure and polar axis
fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(projection='polar'))
# Create a polar contour plot with an inverted colormap
contour = ax.contourf(Theta, R, Z, cmap='RdYlBu_r')
# Add a colorbar
cbar = plt.colorbar(contour)
cbar.set_label('Value')
# Set title
ax.set_title('Polar Contour Plot with Inverted RdYlBu Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we create a polar contour plot using the inverted ‘RdYlBu’ colormap. The inverted colormap can help highlight different patterns in the radial and angular dimensions of the data.
Stream Plots
Stream plots are useful for visualizing vector fields. Inverting colormaps in stream plots can help emphasize the magnitude or direction of the vectors.
Here’s an example of a stream plot with an inverted colormap:
import matplotlib.pyplot as plt
import numpy as np
# Create some sample vector field data
x = np.linspace(2, 2, 20)
y = np.linspace(2, 2, 20)
X, Y = np.meshgrid(x, y)
U = Y
V = X
speed = np.sqrt(U**2 + V**2)
# Create a figure and axis
fig, ax = plt.subplots(figsize=(10, 8))
# Create a stream plot with an inverted colormap
stream = ax.streamplot(X, Y, U, V, color=speed, cmap='viridis_r', linewidth=2, density=1.5)
# Add a colorbar
cbar = plt.colorbar(stream.lines)
cbar.set_label('Speed')
# Set labels and title
ax.set_xlabel('Xaxis')
ax.set_ylabel('Yaxis')
ax.set_title('Stream Plot with Inverted Viridis Colormap  how2matplotlib.com')
# Show the plot
plt.show()
Output:
In this example, we create a stream plot of a vector field using the inverted ‘viridis’ colormap to represent the speed of the vectors. The inverted colormap can help emphasize areas of high or low speed in the vector field.
Best Practices for Colormap Inversion
When inverting colormaps, it’s important to keep in mind some best practices to ensure your visualizations are effective and informative:
 Consider the nature of your data: Not all data benefits from colormap inversion. Consider whether inverting the colormap enhances or obscures important features of your data.

Maintain perceptual uniformity: When creating custom inverted colormaps, try to maintain perceptual uniformity, which ensures that equal steps in data are perceived as equal steps in color.

Account for color vision deficiencies: When inverting colormaps, consider how the new color scheme might appear to individuals with color vision deficiencies.

Use appropriate colormaps for your data type: Ensure that you’re using the right type of colormap (sequential, diverging, or qualitative) for your data, even when inverting.

Provide clear labeling: Always include a colorbar with clear labels to help viewers interpret the inverted colormap correctly.

Test different options: Experiment with different colormaps and their inverted versions to find the most effective visualization for your data.
Here’s an example that demonstrates some of these best practices:
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LinearSegmentedColormap
# Create some sample data
x = np.linspace(2, 2, 100)
y = np.linspace(2, 2, 100)
X, Y = np.meshgrid(x, y)
Z = X * np.exp(X**2  Y**2)
# Create a perceptually uniform custom colormap
colors = ['#000033', '#0000FF', '#00FFFF', '#FFFFFF', '#FFFF00', '#FF0000', '#330000']
n_bins = 256
custom_cmap = LinearSegmentedColormap.from_list('custom_cmap', colors, N=n_bins)
# Create an inverted version of the custom colormap
inverted_custom_cmap = LinearSegmentedColormap.from_list('inverted_custom_cmap', list(reversed(colors)), N=n_bins)
# Create a figure with two subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
# Plot with the original custom colormap
contour1 = ax1.contourf(X, Y, Z, cmap=custom_cmap, levels=20)
cbar1 = plt.colorbar(contour1, ax=ax1)
cbar1.set_label('Value')
ax1.set_title('Original Custom Colormap  how2matplotlib.com')
ax1.set_xlabel('Xaxis')
ax1.set_ylabel('Yaxis')
# Plot with the inverted custom colormap
contour2 = ax2.contourf(X, Y, Z, cmap=inverted_custom_cmap, levels=20)
cbar2 = plt.colorbar(contour2, ax=ax2)
cbar2.set_label('Value')
ax2.set_title('Inverted Custom Colormap  how2matplotlib.com')
ax2.set_xlabel('Xaxis')
ax2.set_ylabel('Yaxis')
# Add a note about color vision deficiencies
fig.text(0.5, 0.02, 'Note: This colormap has been designed with consideration for color vision deficiencies.',
ha='center', fontsize=10, style='italic')
# Show the plot
plt.tight_layout()
plt.show()
Output:
This example demonstrates the use of a perceptually uniform custom colormap and its inverted version, clear labeling, and a note about color vision deficiencies.
Invert Colormap in Matplotlib Conclusion
Inverting colormaps in Matplotlib is a powerful technique that can significantly enhance your data visualizations. Whether you’re using builtin colormaps or creating custom ones, the ability to invert colormaps provides you with greater flexibility in presenting your data effectively.
Throughout this guide, we’ve explored various methods for inverting colormaps, from simple techniques like using the ‘_r’ suffix to more advanced approaches involving custom colormap creation. We’ve also looked at how to apply inverted colormaps to different types of plots, including contour plots, heatmaps, 3D surface plots, scatter plots, polar plots, and stream plots.
Remember that the choice of colormap and whether to invert it should always be guided by the nature of your data and the message you want to convey. By following best practices and experimenting with different options, you can create visualizations that are not only visually appealing but also informative and accessible to a wide audience.
As you continue to work with Matplotlib, don’t hesitate to explore and experiment with different colormap inversions and combinations. The flexibility and power of Matplotlib allow for endless possibilities in data visualization, and mastering colormap manipulation is a valuable skill in creating impactful and insightful plots.