Comprehensive Analysis of Matplotlib Subplot Creation: plt.subplots vs figure.subplots

Overview of Matplotlib Subplot Creation Mechanisms

In the field of data visualization, Matplotlib, as one of Python's most popular plotting libraries, offers multiple methods for creating multiple subplots. Among these, the plt.subplots() function is the most commonly used and recommended approach, as it simultaneously creates both the figure object and the subplot array, significantly simplifying the programming workflow for multi-plot layouts.

Working Mechanism of plt.subplots Function

The concise call plt.subplots(nrows=2, ncols=2) actually accomplishes two important tasks: first, it creates a Figure object, and then generates a grid of subplots within it according to the specified number of rows and columns. The function returns a tuple containing the figure object and the subplot array, a design that makes subsequent plotting operations more intuitive and efficient.

Let's understand its workflow through a complete example:

import matplotlib.pyplot as plt

# Prepare sample data
x = list(range(10))
y = list(range(10))

# Create 2x2 subplot grid
fig, axes = plt.subplots(nrows=2, ncols=2)

# Iterate through all subplots and plot data
for row in axes:
    for ax in row:
        ax.plot(x, y)

plt.show()

In this example, the axes variable is a 2x2 two-dimensional array, where each element is an Axes subplot object. By using nested loops to traverse all subplots, we can uniformly configure and plot on each subplot.

Index-based Access to Subplot Arrays

In addition to using loop iteration, we can also access specific subplot positions through direct indexing. This method is particularly useful when differentiated configuration is needed for different subplots:

fig, ax = plt.subplots(2, 2)

# Access specific subplots via row and column indices
ax[0, 0].plot(range(10), 'r')  # Row 0, column 0, red line
ax[1, 0].plot(range(10), 'b')  # Row 1, column 0, blue line
ax[0, 1].plot(range(10), 'g')  # Row 0, column 1, green line
ax[1, 1].plot(range(10), 'k')  # Row 1, column 1, black line

plt.show()

Limitations of Traditional subplot Method

In earlier versions of Matplotlib, developers typically used the plt.subplot() function to create subplots one by one:

fig = plt.figure()

plt.subplot(2, 2, 1)
plt.plot(x, y)

plt.subplot(2, 2, 2)
plt.plot(x, y)

plt.subplot(2, 2, 3)
plt.plot(x, y)

plt.subplot(2, 2, 4)
plt.plot(x, y)

plt.show()

Although this method can achieve the same visual effect, its code structure is relatively verbose and lacks direct references to subplot objects, making subsequent fine-grained control more difficult.

Analysis of figure.subplots Method Issues

Some developers attempt to use fig.subplots(nrows=2, ncols=2) to create subplots, but this syntax does not work properly in standard Matplotlib. This is because subplots is a function at the pyplot module level, not a method of the Figure object.

The correct approach is to use the fig.add_subplot() method to add subplots individually, or directly use the recommended plt.subplots() function. This design difference stems from the evolutionary history of Matplotlib's API, with plt.subplots() being introduced as a more modern and convenient interface.

Advanced Subplot Layout Techniques

For more complex layout requirements, Matplotlib provides the GridSpec tool, which allows creation of non-uniform subplot grids:

import matplotlib.gridspec as gridspec

fig = plt.figure()
gs = gridspec.GridSpec(2, 2)

ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1])
ax3 = fig.add_subplot(gs[1, :])  # Span two columns

ax1.plot(x, y)
ax2.plot(x, y)
ax3.plot(x, y)

plt.show()

Practical Application Recommendations

In actual project development, it is recommended to always use plt.subplots() as the preferred method for creating multiple subplots. Not only is the code concise, but the returned subplot array facilitates batch operations and programmatic processing. When creating a single subplot, plt.subplots() is equally applicable by simply omitting the row and column parameters.

For special scenarios requiring precise control over subplot positions and dimensions, consider combining GridSpec with the fig.add_subplot() method. However, regardless of the approach, understanding the core mechanism of plt.subplots() remains fundamental to mastering Matplotlib multi-plot layouts.