Fig, ax = plt.subplots pattern in Matplotlib - Deep Dive

Overview - Fig, ax = plt.subplots pattern

What is it?

The 'fig, ax = plt.subplots' pattern is a common way to create a figure and one or more axes (plots) in matplotlib, a popular Python library for making graphs. 'fig' represents the whole figure or window, and 'ax' is the specific area where data is drawn. This pattern helps organize plots clearly and makes it easy to customize each part separately.

Why it matters

Without this pattern, creating and managing plots can become confusing, especially when working with multiple graphs in one figure. It solves the problem of controlling layout and appearance cleanly, making your visualizations easier to read and modify. This clarity is important when sharing results or exploring data.

Where it fits

Before learning this, you should know basic Python and how to install and import matplotlib. After mastering this pattern, you can learn advanced plotting techniques, customizing styles, and creating interactive visualizations.

Mental Model

Core Idea

The 'fig, ax = plt.subplots' pattern separates the whole drawing area (figure) from the specific plot area (axes) so you can control each part independently.

Think of it like...

It's like having a picture frame (figure) and the canvas inside it (axes) where you paint. You can change the frame size or style without touching the painting, and you can paint different things on each canvas inside multiple frames.

┌─────────────── Figure (fig) ────────────────┐
│                                            │
│   ┌────────── Axes (ax) ──────────┐         │
│   │           Plot area            │         │
│   │                              │         │
│   └──────────────────────────────┘         │
│                                            │
└────────────────────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

Understanding Figure and Axes Basics

Concept: Learn what a figure and axes are in matplotlib and their roles.

In matplotlib, a figure is the entire window or page that holds one or more plots. Axes are the individual plots or graphs inside the figure where data is drawn. You can think of the figure as a container and axes as the drawing spaces inside it.

Result

You understand that a figure can hold multiple axes, and each axes is where you plot data.

Knowing the difference between figure and axes is key to controlling your plots effectively.

2

Foundation

Creating Plots with plt.subplots()

Concept: Use plt.subplots() to create a figure and axes together.

The command 'fig, ax = plt.subplots()' creates a new figure and a single axes. 'fig' is the figure object, and 'ax' is the axes object. You can then use 'ax' to plot data, like ax.plot([1,2,3], [4,5,6]).

Result

You get a blank figure window with one plot area ready for drawing.

Creating figure and axes together simplifies plot setup and makes your code cleaner.

3

Intermediate

Working with Multiple Axes

🤔Before reading on: do you think plt.subplots(2, 2) returns one or multiple axes objects? Commit to your answer.

Concept: Create multiple axes in a grid layout using plt.subplots(rows, columns).

You can create multiple plots in one figure by specifying rows and columns in plt.subplots(). For example, 'fig, axs = plt.subplots(2, 2)' creates a 2x2 grid of axes. 'axs' is an array of axes objects you can access individually to plot different data.

Result

A figure window with four separate plot areas arranged in a grid.

Understanding how to handle multiple axes lets you compare data side-by-side in one figure.

4

Intermediate

Customizing Figure and Axes Separately

🤔Before reading on: do you think changing the figure size affects all axes inside it? Commit to your answer.

Concept: Control figure size and axes properties independently for better layout.

You can set the figure size when creating it with plt.subplots(figsize=(width, height)). Axes have their own methods to set titles, labels, and limits, like ax.set_title('Title') or ax.set_xlim(0, 10). This separation helps you customize the overall look and each plot's details.

Result

A figure with the desired size and axes customized with titles and axis ranges.

Separating figure and axes customization gives you precise control over your visualization's appearance.

5

Advanced

Handling Axes Arrays and Flattening

🤔Before reading on: when you create a 2x2 grid of axes, is axs a 2D array or a flat list? Commit to your answer.

Concept: Manage axes arrays returned by plt.subplots() for easy iteration and plotting.

When you create multiple axes, plt.subplots() returns an array of axes objects shaped by rows and columns. For example, a 2x2 grid returns a 2D numpy array. You can flatten this array with axs.flatten() to loop over all axes easily.

Result

You can write loops to plot on each axes without indexing confusion.

Knowing how to handle axes arrays prevents bugs and makes your code scalable for many plots.

6

Expert

Advanced Figure and Axes Management

🤔Before reading on: do you think modifying an axes after plt.show() affects the displayed figure? Commit to your answer.

Concept: Understand the lifecycle of figure and axes objects and how to update or save plots efficiently.

Figures and axes are objects in memory. You can modify them anytime before saving or showing. After plt.show(), the figure window may close, so further changes won't appear. For complex apps, managing these objects carefully allows dynamic updates, multiple saves, or embedding plots in GUIs.

Result

You can create interactive or multi-step plotting workflows without recreating figures.

Understanding object lifecycles helps build advanced visualizations and avoid common pitfalls with plot updates.

Under the Hood

plt.subplots() is a convenience function that creates a Figure object and one or more Axes objects inside it. Internally, it calls Figure() to make the container and then adds Axes instances arranged in a grid if specified. Each Axes manages its own coordinate system and drawing area, while the Figure handles overall layout and rendering.

Why designed this way?

This design separates concerns: the Figure manages the whole image, and Axes handle individual plots. It allows flexible layouts and independent customization. Earlier matplotlib versions required manual figure and axes creation, which was more complex. plt.subplots() simplifies this common pattern.

┌─────────────── Figure ────────────────┐
│ ┌────── Axes 1 ──────┐ ┌────── Axes 2 ──────┐ │
│ │ Plot area          │ │ Plot area          │ │
│ └────────────────────┘ └────────────────────┘ │
│ ┌────── Axes 3 ──────┐ ┌────── Axes 4 ──────┐ │
│ │ Plot area          │ │ Plot area          │ │
│ └────────────────────┘ └────────────────────┘ │
└───────────────────────────────────────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Does plt.subplots() always return a single axes object? Commit to yes or no.

Common Belief: plt.subplots() always returns a single axes object, no matter the arguments.

Reality: If you specify multiple rows and columns, plt.subplots() returns an array of axes objects, not just one.

Why it matters: Assuming a single axes can cause errors when trying to plot on multiple axes or when indexing the returned object.

Quick: Does changing the figure size after creating axes resize the axes automatically? Commit to yes or no.

Common Belief: Changing the figure size after creating axes automatically resizes all axes proportionally.

Reality: Axes sizes and positions are set when created; changing figure size later may not adjust axes layout unless you redraw or adjust manually.

Why it matters: Ignoring this can lead to distorted or overlapping plots when resizing figures dynamically.

Quick: Can you plot directly using plt.plot() after creating axes with plt.subplots()? Commit to yes or no.

Common Belief: After creating axes with plt.subplots(), you can use plt.plot() to plot on those axes.

Reality: plt.plot() plots on the current axes, which may not be the axes created by plt.subplots(). You should use ax.plot() to plot on specific axes.

Why it matters: Using plt.plot() can lead to plots appearing on unexpected axes or figures, causing confusion.

Expert Zone

1

When creating multiple axes, the shape of the returned axes array depends on the number of rows and columns, and can be 1D or 2D, which affects how you index it.

2

The figure and axes objects are mutable and can be updated multiple times before rendering, enabling complex interactive visualizations.

3

Using constrained_layout=True or tight_layout() with plt.subplots() helps automatically adjust spacing between axes, but they behave differently and have tradeoffs.

When NOT to use

For very simple plots, using plt.plot() directly without creating figure and axes objects is easier. For highly customized layouts, using GridSpec or manually adding axes may be better than plt.subplots().

Production Patterns

In production, plt.subplots() is used to create dashboards with multiple plots, where each axes is updated dynamically. It's also common to save figures to files after customizing axes individually for reports.

Connections

Object-Oriented Programming

The figure and axes are objects with methods and properties, illustrating OOP principles in plotting.

Understanding matplotlib's figure and axes as objects helps grasp how methods like ax.plot() work and how to customize plots programmatically.

Graphic Design Layout

Separating figure and axes is like separating page layout and content areas in graphic design.

Knowing this connection helps appreciate why controlling figure size and axes placement independently improves visual clarity.

User Interface Windows and Panels

A figure is like a window, and axes are panels inside it, similar to UI design.

This analogy helps understand how multiple plots can coexist and be managed independently within one display.

Common Pitfalls

#1 Trying to plot on axes without referencing the axes object.

Wrong approach:

fig, ax = plt.subplots()
plt.plot([1, 2, 3], [4, 5, 6]) # Wrong: plots on current axes, not ax

Correct approach:

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6]) # Correct: plots on the created axes

Root cause:

Confusing pyplot's state-machine interface with object-oriented interface leads to plotting on unintended axes.

#2 Assuming axs is always a flat list when creating multiple subplots.

Wrong approach:

fig, axs = plt.subplots(2, 2)
for ax in axs:
ax.plot([1, 2, 3], [4, 5, 6]) # Error: axs is 2D array, not iterable directly

Correct approach:

fig, axs = plt.subplots(2, 2)
for ax in axs.flatten():
ax.plot([1, 2, 3], [4, 5, 6]) # Correct: flatten to iterate

Root cause:

Not realizing the shape of axs causes iteration errors.

#3 Changing figure size after plotting without adjusting layout.

Wrong approach:

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])
fig.set_size_inches(10, 5) # Figure size changed but layout not updated

Correct approach:

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])
fig.set_size_inches(10, 5)
fig.tight_layout() # Adjust layout after resizing

Root cause:

Forgetting to update layout after resizing leads to overlapping or clipped plots.

Key Takeaways

The 'fig, ax = plt.subplots()' pattern cleanly separates the whole figure from individual plot areas, giving you precise control.

Using this pattern helps manage multiple plots in one figure, making complex visualizations easier to build and understand.

Always plot on the axes object returned by plt.subplots() to avoid confusion and unexpected results.

Understanding the shape and structure of axes arrays is crucial when working with multiple subplots.

Advanced control of figure and axes lifecycles enables dynamic and interactive plotting beyond simple static graphs.