Matplotlib Visualization

August 30, 2023

1 Enhancing Matplotlib Visualizations

Matplotlib is a powerful and versatile library in Python for creating a wide range of visualizations.
While its default settings produce functional plots, customizing the aesthetics of your visualizations
can significantly e nhance t heir r eadability a nd a ppeal. I n t his a rticle, w e w ill d elve i nto t he art
of customizing plot aesthetics using Matplotlib, exploring various techniques to create visually
stunning and informative plots.

1.1 Anatomy of a Matplotlib Figure and Subplots

Before we dive into customization, let’s understand the basic structure of a Matplotlib figure and
how it consists of various components. A Matplotlib figure t ypically c omprises t he f ollowing ele-
ments:
1. Figure: The entire plotting area where subplots and other elements are placed.
2. Subplots: Individual plots within the figure, arranged in rows and columns.
3. Axes: The plotting area within each subplot, including the coordinate system.
4. Title, Labels, and Legends: Textual elements that provide context and information about
the plot.
5. Ticks and Tick Labels: Markings along the axes indicating data points and their labels.

1.2 Utilizing the rcParams System for Global Customization

Matplotlib provides a global parameter system called rcParams that allows you to customize various
aspects of the plot’s appearance. These parameters control default settings for fonts, colors, line
styles, and more. To customize these settings globally, you can use the plt.rcParams dictionary.
import matplotlib.pyplot as plt

# Example of customizing global parameters

plt.rcParams['font.size'] = 12
plt.rcParams['axes.labelsize'] = 10
plt.rcParams['lines.linewidth'] = 2

1.2.1 Color Maps

Color maps play a crucial role in determining the color palette of your visualizations. Matplotlib
provides a range of predefined color maps, and you can also create your own.
import matplotlib.pyplot as plt

1
# Using a predefined color map
plt.imshow(data, cmap='viridis')

# Creating a custom color map

from matplotlib.colors import LinearSegmentedColormap
colors = [(0, "red"), (0.5, "green"), (1, "blue")]
custom_cmap = LinearSegmentedColormap.from_list("custom", colors)
plt.imshow(data, cmap=custom_cmap)

1.2.2 Styles and Themes

Matplotlib provides various built-in styles that define a set of parameters for different aesthetics.
You can choose from styles like 'ggplot', 'seaborn', and more. To apply a style:
import matplotlib.pyplot as plt

plt.style.use('ggplot')

1.3 Customizing Fonts, Text Properties, and Annotations

1.3.1 Fonts and Text Properties
Customizing fonts and text properties enhances the readability of your plots. You can customize
properties such as font size, weight, and style for different text elements.
import matplotlib.pyplot as plt

plt.title('Custom Font Example', fontsize=16, fontweight='bold')

plt.xlabel('X-axis', fontsize=12)
plt.ylabel('Y-axis', fontsize=12, fontstyle='italic')

1.3.2 Annotations
Annotations provide additional information on your plots, such as arrows, text boxes, and high-
lights.
import matplotlib.pyplot as plt

plt.annotate('Important Point', xy=(x, y), xytext=(x_text, y_text),

arrowprops=dict(facecolor='black', shrink=0.05),
fontsize=10, color='red')

1.4 Creating Complex Subplot Arrangements

1.4.1 GridSpec: Fine-grained Subplot Control
Matplotlib’s GridSpec module allows you to create custom grid layouts for subplots, giving you
fine-grained control over the arrangement of your plots.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

2
# Creating a 2x3 grid of subplots
grid = GridSpec(2, 3)

plt.subplot(grid[0, 0]) # First subplot

plt.subplot(grid[0, 1:]) # Second subplot spanning multiple columns
plt.subplot(grid[1, :2]) # Third subplot spanning multiple rows
plt.subplot(grid[1, 2]) # Fourth subplot

1.4.2 subplots2grid: Flexible Grid Arrangements

The subplots2grid function provides another approach to create flexible subplot arrangements.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.pyplot import subplots_adjust

# Creating custom grid using subplots2grid

grid = GridSpec(2, 3)
plt.subplot(grid[0, 0]) # First subplot
plt.subplot(grid[0, 1:]) # Second subplot
plt.subplot(grid[1, :]) # Third and fourth subplots

subplots_adjust(wspace=0.4, hspace=0.4) # Adjust spacing between subplots

1.5 Fine-tuning Subplot Spacing and Alignment

Controlling the spacing between subplots and aligning them properly is crucial for visual clarity.

1.5.1 Adjusting Spacing

You can adjust spacing using the subplots_adjust function, as shown in the previous example.
This function allows you to customize the width and height gaps between subplots.

1.5.2 Aligning Subplots

Matplotlib provides a range of tools to align subplots properly. For instance, you can align subplots
using the align_labels() function.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
from matplotlib.pyplot import subplots_adjust

# Creating subplots with aligned labels

grid = GridSpec(2, 2)
ax1 = plt.subplot(grid[0, 0])
ax2 = plt.subplot(grid[0, 1])
ax3 = plt.subplot(grid[1, :])

subplots_adjust(wspace=0.4, hspace=0.4)
plt.align_labels()

3
1.6 Nested Subplots and Shared Axes
1.6.1 Nested Subplots
You can create nested subplots to showcase different levels of detail within your data.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

# Creating nested subplots

outer_grid = GridSpec(1, 2)
inner_grid_left = GridSpecFromSubplotSpec(2, 1, subplot_spec=outer_grid[0])
inner_grid_right = GridSpecFromSubplotSpec(3, 1, subplot_spec=outer_grid[1])

plt.subplot(inner_grid_left[0])
plt.subplot(inner_grid_left[1])
plt.subplot(inner_grid_right[0])
plt.subplot(inner_grid_right[1])
plt.subplot(inner_grid_right[2])

1.6.2 Shared Axes

Shared axes allow you to create compact visualizations with linked scales.
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

# Creating subplots with shared y-axis

grid = GridSpec(2, 1, height_ratios=[3, 1])

ax1 = plt.subplot(grid[0])
ax2 = plt.subplot(grid[1], sharex=ax1)

1.7 Multi-axes Plots with Different Scales

Creating multi-axes plots with different scales can help you visualize data with varying ranges more
effectively.
import matplotlib.pyplot as plt

fig, ax1 = plt.subplots()

ax1.plot(x, y1, 'g-')

ax1.set_xlabel('X-axis')
ax1.set_ylabel('Primary Y-axis', color='g')

ax2 = ax1.twinx()
ax2.plot(x, y2, 'b-')
ax2.set_ylabel('Secondary Y-axis', color='b')

# Customize further as needed

4
1.8 Hexbin Plots: Visualizing Density
Hexbin plots are excellent for visualizing the density of points in a scatterplot. Instead of displaying
individual data points, hexbins divide the plot area into hexagonal bins and represent the data
density within each bin with color or shading.
import matplotlib.pyplot as plt

# Generating hexbin plot

plt.hexbin(x_data, y_data, gridsize=20, cmap='viridis')
plt.colorbar(label='Density')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Hexbin Plot: Data Density')
plt.show()

1.9 Polar Plots: Circular Data Representation

Polar plots are used to visualize data that has a circular relationship, such as direction or angle
data. You can use polar coordinates to create plots that represent circular patterns effectively.
import matplotlib.pyplot as plt
import numpy as np

# Generating polar plot

theta = np.linspace(0, 2*np.pi, 100)
r = np.sin(3*theta)
plt.polar(theta, r, label='Data')
plt.legend()
plt.title('Polar Plot: Circular Data Representation')
plt.show()

1.10 Treemaps and Sunburst Charts: Hierarchical Data

Treemaps and sunburst charts are powerful tools for visualizing hierarchical data structures.
Treemaps represent hierarchical data as nested rectangles, while sunburst charts use nested rings
to show hierarchical relationships.
import matplotlib.pyplot as plt
import squarify # For treemaps

# Generating treemap
sizes = [30, 20, 25, 15, 10]
labels = ['A', 'B', 'C', 'D', 'E']
colors = plt.cm.Spectral
squarify.plot(sizes=sizes, label=labels, color=colors, alpha=0.7)
plt.axis('off')
plt.title('Treemap: Hierarchical Data Representation')
plt.show()

5
For sunburst charts, you might want to explore libraries like Plotly, which offer interactive sunburst
visualizations.

1.11 Smith Charts: Complex Impedance Visualization

Smith charts are a specialized plot type used in electrical engineering to visualize complex
impedance and reflection coefficients. They are particularly useful for designing and analyzing
RF (radio frequency) circuits.
import matplotlib.pyplot as plt
import numpy as np

# Generating Smith chart

theta = np.linspace(0, np.pi, 100)
r = 1 - np.sin(theta)
plt.plot(r*np.cos(theta), r*np.sin(theta))
plt.plot([0, 0], [-1, 1], 'k--')
plt.plot([-1, 1], [0, 0], 'k--')
plt.gca().set_aspect('equal', adjustable='box')
plt.title('Smith Chart: Complex Impedance Visualization')
plt.show()

2 Exploring 3D Visualization with Matplotlib

Matplotlib goes beyond the realm of 2D plots by offering an array of tools for creating immersive
3D visualizations.

2.1 Introduction to 3D Plotting

Matplotlib’s mpl_toolkits.mplot3d submodule provides the necessary tools to create 3D plots.
To get started, import the required classes:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

2.2 Creating 3D Scatter Plots

3D scatter plots allow you to visualize data points in a 3D space, with the third dimension repre-
sented by the size, color, or shape of the markers.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x = [1, 2, 3, 4, 5]
y = [2, 3, 4, 5, 6]
z = [3, 4, 5, 6, 7]

ax.scatter(x, y, z, c='r', marker='o')

ax.set_xlabel('X Label')

6
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

2.3 Creating 3D Surface Plots

Surface plots are used to visualize functions of two variables as a 3D surface. Matplotlib’s
plot_surface() function creates surface plots from 2D grids of data.
import numpy as np

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

ax.plot_surface(X, Y, Z, cmap='viridis')

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

2.4 Creating 3D Wireframes

Wireframes provide a 3D representation of a surface using lines. The plot_wireframe() function
in Matplotlib generates wireframe plots.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

ax.plot_wireframe(X, Y, Z, cmap='plasma')

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

7
2.5 Combining 2D and 3D Elements
Matplotlib allows you to combine 2D and 3D elements within the same plot, providing enhanced
context to your visualizations.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x_2d = [1, 2, 3, 4, 5]
y_2d = [2, 4, 6, 8, 10]

z_2d = [0, 0, 0, 0, 0] # Place the 2D data on the XY plane

ax.plot(x_2d, y_2d, z_2d, marker='o', label='2D Data')

ax.scatter(x, y, z, c='r', marker='^', label='3D Data')

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.legend()
plt.show()

2.6 Interactive 3D Visualizations using Widgets

Jupyter Notebook provides interactive features for 3D visualizations using widgets. The
ipywidgets library is a great way to create interactive plots with sliders, buttons, and more.
from ipywidgets import interact

def plot_3d_surface(elev=30, azim=30):

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

ax.view_init(elev=elev, azim=azim)

ax.plot_surface(X, Y, Z, cmap='viridis')

ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')

plt.show()

interact(plot_3d_surface, elev=(0, 90), azim=(0, 180))

8
3 Conclusion
In the world of data visualization, Matplotlib stands as a versatile and powerful library, offering a
wide array of techniques to elevate your plots from basic to breathtaking. Through this journey,
we’ve explored a range of advanced visualization concepts that can bring your data to life in
captivating ways.
As you embark on your data visualization journey, remember that each technique is a tool in
your toolkit, to be chosen based on the data’s nature and the story you aim to tell. Matplotlib’s
versatility empowers you to choose the right tool for the job, whether it’s enhancing aesthetics,
managing subplots, embracing advanced plot types, or venturing into 3D visualization.
The culmination of these techniques allows you to create visualizations that not only present data
but also communicate insights effectively. A well-crafted visualization has the power to enlighten,
inform, and inspire, making it an essential skill for data scientists, analysts, and researchers across
disciplines. By mastering these advanced visualization concepts, you’ve equipped yourself to tell
richer, more impactful stories through your data. Happy plotting!