# Creating Multiple Plots on a Single Page with Matplotlib in Python

Rate this post

π‘ Problem Formulation: When analyzing data, it’s often helpful to view multiple plots simultaneously for comparison and pattern recognition. However, it can be challenging to condense this information into a single, coherent page. With Python’s `matplotlib` library, there are several methods to position multiple plotsβa set of data visualizationsβon a single page, addressing the layout with different functionalities like subplots, gridspec, and more intricate figure arrangement features. This article will guide you through the best ways to achieve this effectively.

## Method 1: Using `subplot()` for Basic Grid Layouts

The `subplot()` function in Matplotlib allows you to place multiple plots in a simple grid layout. Itβs straightforward to use and ideal for creating a basic array of plots. You specify the number of rows and columns in the grid and the position of each subplot.

Here’s an example:

```import matplotlib.pyplot as plt

plt.subplot(2, 2, 1)
plt.plot([0, 1], [0, 1])

plt.subplot(2, 2, 2)
plt.plot([0, 1], [1, 0])

plt.subplot(2, 2, 3)
plt.plot([1, 0], [0, 1])

plt.subplot(2, 2, 4)
plt.plot([1, 0], [1, 0])

plt.show()```

Output: This code creates a single page with a 2×2 grid of line plots.

This snippet uses `subplot()` to create four axes (plots) arranged in a 2 by 2 grid on a single figure. Each plot contains a simple line graph with different slope directions. With `plt.show()`, we then display the figure with all four subplots.

## Method 2: Utilizing `subplots()` for Enhanced Grid Control

The `subplots()` function creates a full grid of subplots in a single call and returns a figure object and an array of Axes objects. This approach gives you immediate access to each subplot’s axes for customization and is better for more complex grid layouts.

Here’s an example:

```import matplotlib.pyplot as plt
import numpy as np

fig, ax_array = plt.subplots(2, 3)

x = np.linspace(0, 2*np.pi, 100)

for i, ax in enumerate(ax_array.flatten()):
ax.plot(x, np.sin(x + np.pi/2 * i))

plt.tight_layout()
plt.show()```

Output: This code creates a single page with a 2×3 grid of sine wave plots, each subplot showing the sine wave progressively phase-shifted.

In this example, we use `subplots()` to prepare a 2×3 grid layout. NumPy is used to create an array of x-values, and each subplot depicts a sine wave phase-shifted by a quarter period. `plt.tight_layout()` ensures that the plots are spaced neatly.

## Method 3: Using `GridSpec` for Flexible Grid Positioning

`GridSpec` provides an interface for creating complex subplot layouts beyond a regular grid. It allows subplots to span multiple rows or columns, providing greater flexibility in arranging the visualizations.

Here’s an example:

```import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

fig = plt.figure(constrained_layout=True)
gs = gridspec.GridSpec(3, 3, figure=fig)

plt.show()```

Output: This code creates a complex layout with different-sized plots on one page. Some plots span multiple rows or columns.

This code utilizes `GridSpec` to design a more intricate layout where subplots have different sizes and span multiple rows or columns. `constrained_layout=True` in the figure creation helps in managing space between the plots automatically.

## Method 4: Using `subplot2grid()` for Specific Positioning

`subplot2grid()` offers a way to place subplots on a grid by specifying the grid shape, the grid location, and the row and column span of the subplot. This method is particularly useful for custom placement when not all subplots are the same size.

Here’s an example:

```import matplotlib.pyplot as plt

ax1 = plt.subplot2grid((3, 3), (0, 0), colspan=2)
ax2 = plt.subplot2grid((3, 3), (0, 2), rowspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 0), rowspan=2, colspan=2)

ax1.plot([1, 2])
ax2.plot([2, 1])
ax3.plot([0, 1])

plt.tight_layout()
plt.show()```

Output: This code results in a figure where the subplots are arranged non-uniformly across a 3×3 grid.

Using `subplot2grid()`, we granularly specify where each plot should reside within a 3×3 grid. Each axis is given a specific location and a span for both rows and columns that dictates its size. `plt.tight_layout()` is again used for a neat arrangement.

## Bonus One-Liner Method 5: Quick Multiple Plots with `pyplot.subplots()` One-liner

The `subplots()` function can also be used as an efficient one-liner to create multiple subplots, setting the number of rows and columns directly in its parameters. This generates a figure with axes array ready for plotting.

Here’s an example:

```import matplotlib.pyplot as plt

fig, axs = plt.subplots(2, 2, figsize=(5,5))

for i, ax in enumerate(axs.flat):
ax.plot(range(10), [x**(i+1) for x in range(10)])

plt.show()```

Output: This creates a 2×2 grid of plots, each displaying a power curve with increasing exponent.

This concise snippet leverages the fact that `subplots()` can be used directly to quickly generate a grid. In one line, `plt.subplots()` is used to create a 2×2 figure grid. We’re able to iterate over the Axes objects using `axs.flat` and plot onto them in a loop.

## Summary/Discussion

• Method 1: Using `subplot()`. Great for basic grid layouts. It can be less flexible than other methods which allow for enhanced customization.
• Method 2: Utilizing `subplots()`. Offers both the creation of a grid of plots and direct access to individual Axes objects, providing more control and customization of each subplot.
• Method 3: Using `GridSpec`. Best for when subplots of varying sizes and shapes are required, offering the highest layout flexibility.
• Method 4: Using `subplot2grid()`. Useful for specific subplot placements within a grid. It’s great for non-uniform grid layouts, but can be verbose for simpler layouts.
• Bonus Method 5: One-liner with `subplots()`. Extremely concise for quickly setting up a plot matrix, ideal for similar-sized subplots when less custom positioning is needed.