Why multiple plots per figure matter in Matplotlib - Why It Works This Way

Overview - Why multiple plots per figure matter

What is it?

Multiple plots per figure means showing more than one graph inside a single window or image. Instead of making many separate pictures, you combine related charts together. This helps compare data side-by-side easily and saves space. It is common in data analysis to see patterns or differences clearly.

Why it matters

Without multiple plots per figure, you would have many separate images to look at, making it hard to compare data quickly. It wastes screen or paper space and can confuse the story your data tells. Combining plots helps you see relationships and differences in one glance, making your analysis clearer and faster.

Where it fits

Before this, you should know how to create a single plot using matplotlib basics. After learning this, you can explore advanced layout controls, interactive plots, and dashboard creation to present data professionally.

Mental Model

Core Idea

Multiple plots per figure let you organize related graphs together to compare and understand data more effectively in one view.

Think of it like...

It's like having a photo collage instead of many separate photos; you see all important moments side-by-side without flipping pages.

┌───────────────┬───────────────┐
│   Plot 1      │   Plot 2      │
├───────────────┼───────────────┤
│   Plot 3      │   Plot 4      │
└───────────────┴───────────────┘

Build-Up - 7 Steps

1

Foundation

Creating a Single Plot

Concept: Learn how to make one basic plot using matplotlib.

import matplotlib.pyplot as plt x = [1, 2, 3, 4] y = [10, 20, 25, 30] plt.plot(x, y) plt.title('Single Plot Example') plt.show()

Result

A window opens showing a simple line graph with points (1,10), (2,20), (3,25), (4,30).

Understanding how to create a single plot is the foundation before combining multiple plots in one figure.

2

Foundation

Understanding Figure and Axes

Concept: Learn the difference between a figure (the whole window) and axes (individual plots inside).

fig = plt.figure() ax = fig.add_subplot(1,1,1) # One plot in the figure ax.plot([1,2,3], [4,5,6]) plt.show()

Result

A single plot appears inside a figure window.

Knowing that a figure can hold multiple axes (plots) helps you organize multiple graphs later.

3

Intermediate

Adding Multiple Subplots in One Figure

🤔Before reading on: Do you think adding multiple plots means calling plt.plot multiple times or creating separate axes?

Concept: Learn to create multiple plots inside one figure using subplots.

fig, axs = plt.subplots(2, 2) # 2 rows, 2 columns axs[0, 0].plot([1, 2, 3], [1, 4, 9]) axs[0, 0].set_title('Plot 1') axs[0, 1].plot([1, 2, 3], [2, 3, 4]) axs[0, 1].set_title('Plot 2') axs[1, 0].plot([1, 2, 3], [5, 6, 7]) axs[1, 0].set_title('Plot 3') axs[1, 1].plot([1, 2, 3], [7, 8, 9]) axs[1, 1].set_title('Plot 4') plt.tight_layout() plt.show()

Result

A single window shows four separate plots arranged in a 2x2 grid.

Creating multiple axes inside one figure allows you to compare different data sets side-by-side easily.

4

Intermediate

Controlling Layout and Spacing

🤔Before reading on: Do you think matplotlib automatically arranges plots perfectly without extra commands?

Concept: Learn how to adjust spacing between multiple plots for clarity.

fig, axs = plt.subplots(2, 2) for ax in axs.flat: ax.plot([1, 2, 3], [1, 4, 9]) plt.subplots_adjust(wspace=0.5, hspace=0.5) # Increase space plt.show()

Result

Plots appear with more space between them, avoiding overlap of titles and labels.

Adjusting spacing prevents clutter and makes each plot readable when many are shown together.

5

Intermediate

Sharing Axes for Better Comparison

🤔Before reading on: Is it better to have each plot with its own scale or share scales when comparing similar data?

Concept: Learn to share x or y axes among subplots to align scales and improve comparison.

fig, axs = plt.subplots(2, 2, sharex=True, sharey=True) for ax in axs.flat: ax.plot([1, 2, 3], [1, 4, 9]) plt.show()

Result

All plots share the same x and y axis scales, making it easier to compare values directly.

Sharing axes aligns scales, reducing confusion and highlighting differences in data.

6

Advanced

Using GridSpec for Complex Layouts

🤔Before reading on: Do you think subplot grids are always uniform in size and shape?

Concept: Learn to create flexible subplot layouts with different sizes using GridSpec.

import matplotlib.gridspec as gridspec fig = plt.figure() gs = gridspec.GridSpec(3, 3) ax1 = fig.add_subplot(gs[0, :]) # Top row, all columns ax2 = fig.add_subplot(gs[1, :-1]) # Middle row, first two columns ax3 = fig.add_subplot(gs[1:, -1]) # Last column, last two rows ax4 = fig.add_subplot(gs[-1, 0]) # Bottom left corner ax1.plot([1, 2, 3], [1, 2, 3]) ax2.plot([1, 2, 3], [3, 2, 1]) ax3.plot([1, 2, 3], [2, 2, 2]) ax4.plot([1, 2, 3], [1, 3, 1]) plt.tight_layout() plt.show()

Result

A figure with uneven subplot sizes arranged in a custom grid layout appears.

GridSpec allows precise control over subplot placement and size, useful for complex data presentations.

7

Expert

Performance and Memory Considerations

🤔Before reading on: Do you think adding many subplots in one figure always improves performance?

Concept: Understand how many subplots affect rendering speed and memory, and how to optimize.

import matplotlib.pyplot as plt fig, axs = plt.subplots(10, 10) # 100 plots for ax in axs.flat: ax.plot([1, 2, 3], [1, 2, 3]) plt.show() # This can slow down rendering and use lots of memory. # To optimize, consider: # - Reducing number of plots # - Using simpler plot types # - Saving figures instead of interactive display

Result

Rendering 100 plots in one figure may be slow or freeze the program depending on system resources.

Knowing the limits of multiple plots helps avoid performance issues and guides efficient visualization design.

Under the Hood

Matplotlib creates a Figure object as the main container. Inside it, Axes objects represent individual plots. Each Axes manages its own data, scales, labels, and drawing area. When multiple Axes are added, matplotlib arranges them according to layout rules. Rendering combines all Axes into one image. This structure allows independent control of each plot while sharing the same figure canvas.

Why designed this way?

This design separates concerns: the Figure handles overall space, while Axes handle individual plots. It allows flexible layouts and easy extension. Early matplotlib versions had simpler models, but this layered approach supports complex visualizations and interactive features. Alternatives like single-plot-only libraries lack this flexibility.

┌─────────────────────────────┐
│          Figure             │
│ ┌─────────┐ ┌─────────┐     │
│ │  Axes1  │ │  Axes2  │ ... │
│ └─────────┘ └─────────┘     │
│ ┌─────────┐                 │
│ │  Axes3  │                 │
│ └─────────┘                 │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does calling plt.plot() multiple times add multiple plots in one figure or overwrite the same plot?

Common Belief: Calling plt.plot() multiple times adds separate plots side-by-side automatically.

Reality: Calling plt.plot() multiple times draws multiple lines on the same axes, not separate plots. To have multiple plots, you must create multiple axes.

Why it matters: Misunderstanding this leads to cluttered graphs with overlapping lines instead of clear separate plots.

Quick: Is it always better to have many small plots in one figure than separate figures?

Common Belief: More plots in one figure always make data easier to understand.

Reality: Too many plots in one figure can cause clutter, small unreadable plots, and confusion. Sometimes separate figures are clearer.

Why it matters: Overcrowding plots reduces clarity and defeats the purpose of comparison.

Quick: Does sharing axes always improve plot comparison?

Common Belief: Sharing axes is always good because it aligns scales perfectly.

Reality: Sharing axes can hide important differences if data ranges vary widely, making some plots misleading.

Why it matters: Blindly sharing axes can cause misinterpretation of data differences.

Quick: Can you create complex subplot layouts only with plt.subplots()?

Common Belief: plt.subplots() can handle all subplot arrangements easily.

Reality: plt.subplots() creates uniform grids; for complex layouts, GridSpec or manual placement is needed.

Why it matters: Relying only on plt.subplots() limits visualization design and flexibility.

Expert Zone

1

Using constrained_layout instead of tight_layout can better handle complex subplot spacing automatically.

2

Axes sharing can be partial: share only x or y axis depending on data comparison needs.

3

Interactive backends handle multiple plots differently; knowing backend behavior helps optimize performance.

When NOT to use

Avoid multiple plots per figure when plots require very different scales or when high detail is needed in each plot. Instead, use separate figures or interactive dashboards that allow zooming and focus.

Production Patterns

Professionals use multiple plots per figure in reports to compare scenarios side-by-side, in dashboards for compact views, and in exploratory data analysis to spot patterns quickly. GridSpec is common for custom layouts in publications.

Connections

Dashboard Design

Builds-on

Understanding multiple plots per figure is foundational for creating dashboards that display many data views compactly and interactively.

Human Visual Perception

Same pattern

Arranging multiple plots leverages how humans compare visual information side-by-side, improving comprehension and decision-making.

Photo Collage Art

Analogy-based connection

Just like photo collages combine images to tell a story at once, multiple plots per figure combine data views to tell a clearer story.

Common Pitfalls

#1 Overcrowding too many plots in one figure making them unreadable.

Wrong approach:

fig, axs = plt.subplots(10, 10)
for ax in axs.flat:
ax.plot([1, 2, 3], [1, 2, 3])
plt.show()

Correct approach:

fig, axs = plt.subplots(2, 2)
for ax in axs.flat:
ax.plot([1, 2, 3], [1, 2, 3])
plt.show()

Root cause:

Trying to fit too many plots without considering size and readability.

#2 Calling plt.plot multiple times expecting separate plots.

Wrong approach:

plt.plot([1, 2, 3], [1, 4, 9])
plt.plot([1, 2, 3], [2, 3, 4])
plt.show()

Correct approach:

fig, axs = plt.subplots(2)
axs[0].plot([1, 2, 3], [1, 4, 9])
axs[1].plot([1, 2, 3], [2, 3, 4])
plt.show()

Root cause:

Not understanding that multiple plots require multiple axes, not multiple plot calls on one axes.

#3 Not adjusting spacing causing overlapping labels and titles.

Wrong approach:

fig, axs = plt.subplots(2, 2)
for ax in axs.flat:
ax.plot([1, 2, 3], [1, 4, 9])
plt.show()

Correct approach:

fig, axs = plt.subplots(2, 2)
for ax in axs.flat:
ax.plot([1, 2, 3], [1, 4, 9])
plt.tight_layout()
plt.show()

Root cause:

Ignoring layout adjustments needed for multiple plots.

Key Takeaways

Multiple plots per figure help compare related data side-by-side in one view, saving space and improving clarity.

A figure contains one or more axes, each representing an individual plot with its own data and settings.

Using subplots and GridSpec allows flexible arrangement of multiple plots with control over layout and spacing.

Sharing axes aligns scales for better comparison but must be used carefully to avoid misleading interpretations.

Too many plots in one figure can reduce readability and performance; balance quantity with clarity.

Practice

1. Why is it useful to have multiple plots in one figure when analyzing data?

easy

A. It automatically cleans the data for errors.

B. It reduces the total number of data points shown.

C. It allows easy comparison of different data sets side by side.

D. It makes the figure file size smaller.

Solution

1. Step 1: Understand the purpose of multiple plots

   Multiple plots in one figure let us see different data sets or views together.

2. Step 2: Compare data side by side

   This side-by-side view helps spot differences or similarities easily.

3. Final Answer:

   It allows easy comparison of different data sets side by side. -> Option C

4. Quick Check:

   Multiple plots = easy comparison [OK]

Hint: Multiple plots show data side by side for easy comparison [OK]

Common Mistakes:

• Thinking multiple plots reduce data points
• Believing multiple plots clean data automatically
• Assuming multiple plots reduce file size

2. Which of the following is the correct way to create a figure with 2 rows and 3 columns of plots using matplotlib?

easy

A. plt.subplots(3, 2)

B. plt.subplots(2, 3)

C. plt.subplot(2, 3)

D. plt.figure(2, 3)

Solution

1. Step 1: Recall the function for multiple plots

   Use plt.subplots(rows, columns) to create a grid of plots.

2. Step 2: Match rows and columns

   For 2 rows and 3 columns, call plt.subplots(2, 3).

3. Final Answer:

   plt.subplots(2, 3) -> Option B

4. Quick Check:

   plt.subplots(rows, cols) = plt.subplots(2, 3) [OK]

Hint: Use plt.subplots(rows, columns) to create grid [OK]

Common Mistakes:

• Confusing plt.subplot with plt.subplots
• Swapping rows and columns
• Using plt.figure for subplots

3. What will be the output of this code snippet?

import matplotlib.pyplot as plt
fig, axs = plt.subplots(1, 2)
axs[0].plot([1, 2, 3], [4, 5, 6])
axs[1].plot([1, 2, 3], [6, 5, 4])
plt.show()

medium

A. Two separate plots side by side, each with its own line.

B. A blank figure with no plots.

C. An error because axs is not iterable.

D. A single plot with two lines overlapping.

Solution

1. Step 1: Understand plt.subplots(1, 2)

   This creates 1 row and 2 columns of plots, so axs is an array of two axes.

2. Step 2: Plot on each axis separately

   axs[0] and axs[1] each get their own line plot, so two plots appear side by side.

3. Final Answer:

   Two separate plots side by side, each with its own line. -> Option A

4. Quick Check:

   plt.subplots(1,2) + axs[0], axs[1] plots = two side-by-side plots [OK]

Hint: plt.subplots(1,2) creates two side-by-side plots [OK]

Common Mistakes:

• Thinking axs is a single axis, not an array
• Expecting one plot with two lines
• Assuming code causes error

4. Identify the error in this code that tries to create 2 plots in one figure:

import matplotlib.pyplot as plt
fig, ax = plt.subplots(2)
ax.plot([1, 2, 3], [4, 5, 6])
plt.show()

medium

A. ax is an array but used as a single axis, causing an error.

B. plt.subplots(2) creates only one plot, so ax.plot is invalid.

C. The plot data lists have different lengths causing error.

D. plt.show() is missing and causes no output.

Solution

1. Step 1: Check plt.subplots(2) output

   It creates 2 subplots in one column, so ax is an array of axes.

2. Step 2: Using ax.plot() on array causes error

   ax.plot() expects a single axis, but ax is an array, so this causes an AttributeError.

3. Final Answer:

   ax is an array but used as a single axis, causing an error. -> Option A

4. Quick Check:

   Multiple subplots return array, must index before plot [OK]

Hint: Multiple subplots return array; index before plotting [OK]

Common Mistakes:

• Calling plot on array of axes instead of one axis
• Assuming plt.subplots(2) returns single axis
• Ignoring plt.show() is present

5. You want to compare sales data for 3 products over 4 quarters in one figure. Which approach best uses multiple plots per figure to achieve this?

hard

A. Plot all products on a single plot with overlapping lines and no labels.

B. Use plt.figure() once and call plt.plot() three times without subplots.

C. Create 3 separate figures, each with one product's sales plot.

D. Create a 1x3 grid of plots using plt.subplots(1, 3), plot each product's quarterly sales separately, and label each plot.

Solution

1. Step 1: Understand the goal

   We want to compare 3 products side by side in one figure for clarity.

2. Step 2: Use plt.subplots(1, 3) for side-by-side plots

   This creates 3 plots in one row, perfect for comparing products separately but together.

3. Step 3: Label each plot for clarity

   Clear labels help understand which plot shows which product's sales.

4. Final Answer:

   Create a 1x3 grid of plots using plt.subplots(1, 3), plot each product's quarterly sales separately, and label each plot. -> Option D

5. Quick Check:

   Multiple plots + labels = clear side-by-side comparison [OK]

Hint: Use plt.subplots(1,3) and label each plot for clear comparison [OK]

Common Mistakes:

• Plotting all lines on one plot without labels
• Creating separate figures instead of subplots
• Not labeling plots causing confusion