Multiple images in subplot grid in Matplotlib - Step-by-Step Execution

Concept Flow - Multiple images in subplot grid

Start

↓

Create Figure and Subplots Grid

↓

Load or Generate Images

↓

Assign Each Image to a Subplot

↓

Display Images with plt.imshow()

↓

Adjust Layout and Show Plot

↓

End

The flow shows creating a grid of subplots, loading images, placing each image in a subplot, and displaying them together.

Execution Sample

Matplotlib

import matplotlib.pyplot as plt
import numpy as np

fig, axs = plt.subplots(2, 2)
for i in range(2):
    for j in range(2):
        axs[i, j].imshow(np.random.rand(10,10))
plt.show()

This code creates a 2x2 grid of subplots and displays a random image in each subplot.

Execution Table

Step	Action	Variable/Function	Result/State
1	Create figure and 2x2 subplots grid	plt.subplots(2, 2)	fig object and axs 2x2 array created
2	Start outer loop i=0	i=0	Ready to fill first row
3	Start inner loop j=0	j=0	Ready to fill subplot axs[0,0]
4	Generate random image	np.random.rand(10,10)	10x10 array with random floats
5	Display image in axs[0,0]	axs[0,0].imshow()	Image shown in first subplot
6	Inner loop j=1	j=1	Ready to fill subplot axs[0,1]
7	Generate random image	np.random.rand(10,10)	10x10 array with random floats
8	Display image in axs[0,1]	axs[0,1].imshow()	Image shown in second subplot
9	Outer loop i=1	i=1	Ready to fill second row
10	Inner loop j=0	j=0	Ready to fill subplot axs[1,0]
11	Generate random image	np.random.rand(10,10)	10x10 array with random floats
12	Display image in axs[1,0]	axs[1,0].imshow()	Image shown in third subplot
13	Inner loop j=1	j=1	Ready to fill subplot axs[1,1]
14	Generate random image	np.random.rand(10,10)	10x10 array with random floats
15	Display image in axs[1,1]	axs[1,1].imshow()	Image shown in fourth subplot
16	Show all subplots	plt.show()	Window opens with 4 images in grid
17	End	-	All images displayed in subplot grid

💡 All subplots filled with images and displayed, execution ends.

Variable Tracker

Variable	Start	After Step 4	After Step 7	After Step 11	After Step 14	Final
i	N/A	0	0	1	1	1
j	N/A	0	1	0	1	1
axs	N/A	2x2 Axes array	2x2 Axes array	2x2 Axes array	2x2 Axes array	2x2 Axes array
image_array	N/A	random 10x10 array	random 10x10 array	random 10x10 array	random 10x10 array	last random 10x10 array

Key Moments - 3 Insights

Why do we use axs[i, j].imshow() inside nested loops?

Because axs is a 2D array of subplot axes, using axs[i, j] targets the correct subplot to display each image, as shown in steps 5, 8, 12, and 15.

What happens if we call plt.imshow() without specifying the subplot?

It will display the image on the current active axes or create a new figure, not placing images in the grid properly. The execution_table shows images assigned explicitly to axs[i, j].

Why do we call plt.show() only once after the loops?

plt.show() renders the entire figure with all subplots at once. Calling it inside loops would open multiple windows. Step 16 shows the single call after all images are set.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'i' when the image is displayed in axs[1,0]?

A 2

B 0

C 1

D None

💡 Hint

Check step 12 in the execution_table where axs[1,0] is used.

At which step does the inner loop variable 'j' change from 0 to 1 for the first time?

A Step 6

B Step 3

C Step 5

D Step 7

💡 Hint

Look at the execution_table rows where j changes inside the inner loop.

If we change plt.subplots(2, 2) to plt.subplots(3, 1), how would the variable 'axs' change?

A It becomes a 3x1 array of axes

B It becomes a 1D array with 3 axes

C It becomes a single Axes object

D It becomes a 2x3 array of axes

💡 Hint

Check how plt.subplots returns axes arrays depending on rows and columns.

Concept Snapshot

Use plt.subplots(rows, cols) to create a grid of subplots.
Each subplot is accessed by axs[row, col] if rows and cols > 1.
Use axs[i, j].imshow(image) to display images in each subplot.
Call plt.show() once after all images are assigned.
This displays multiple images neatly in a grid layout.

Full Transcript

This visual execution trace shows how to display multiple images in a grid using matplotlib. First, a figure and a 2x2 grid of subplots are created. Then, nested loops iterate over rows and columns. At each subplot position axs[i, j], a random 10x10 image array is generated and displayed using imshow. After filling all subplots, plt.show() displays the window with all images arranged in the grid. Variables i and j track the current subplot indices. The variable axs holds the array of subplot axes. Key moments clarify why images are assigned to specific subplots and why plt.show() is called once at the end. The quiz tests understanding of loop variables and subplot structure. This method helps visualize multiple images side by side clearly.

Practice

1. What is the main purpose of using plt.subplots when displaying multiple images in a grid?

easy

A. To change the color of images

B. To load images from files automatically

C. To create a grid of axes where each image can be shown separately

D. To save images to disk

Solution

1. Step 1: Understand the role of plt.subplots

   plt.subplots creates a figure and a grid of axes (subplots) to place multiple plots or images.

2. Step 2: Connect to displaying images

   Each axis in the grid can show one image, so it helps organize multiple images neatly.

3. Final Answer:

   To create a grid of axes where each image can be shown separately -> Option C

4. Quick Check:

   plt.subplots = grid for images [OK]

Hint: Remember: plt.subplots makes the grid for multiple images [OK]

Common Mistakes:

• Thinking plt.subplots loads or saves images
• Confusing plt.subplots with image display functions
• Assuming plt.subplots changes image colors

2. Which of the following is the correct way to loop through all axes in a subplot grid to plot images?

easy

A. for ax in axes.flat:

B. for ax in axes.grid():

C. for ax in axes.loop():

D. for ax in axes.images():

Solution

1. Step 1: Identify the axes object type

   When plt.subplots creates multiple axes, they are stored in an array or matrix.

2. Step 2: Use axes.flat to flatten the array for looping

   axes.flat lets you loop over all axes in a simple 1D way.

3. Final Answer:

   for ax in axes.flat: -> Option A

4. Quick Check:

   axes.flat loops all axes [OK]

Hint: Use axes.flat to loop all subplot axes easily [OK]

Common Mistakes:

• Using non-existent methods like axes.grid()
• Trying to loop axes directly without flattening
• Confusing axes with image objects

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

import matplotlib.pyplot as plt
import numpy as np
images = [np.random.rand(5,5) for _ in range(4)]
fig, axes = plt.subplots(2, 2)
for ax, img in zip(axes.flat, images):
    ax.imshow(img, cmap='gray')
    ax.axis('off')
plt.show()

medium

A. A single image shown in one plot

B. A 2x2 grid showing 4 random grayscale images without axes

C. An error because axes.flat is not iterable

D. A 2x2 grid with empty plots and no images

Solution

1. Step 1: Understand the code flow

   Four random 5x5 images are created and stored in a list. A 2x2 subplot grid is created.

2. Step 2: Loop through axes and images

   Each axis in the 2x2 grid shows one image with grayscale colormap and axes turned off.

3. Final Answer:

   A 2x2 grid showing 4 random grayscale images without axes -> Option B

4. Quick Check:

   Loop + imshow + axis off = grid of images [OK]

Hint: Loop axes.flat with images to plot all in grid [OK]

Common Mistakes:

• Expecting only one image to show
• Thinking axes.flat is not iterable
• Forgetting to turn axes off

4. Identify the error in this code that tries to display 3 images in a 2x2 grid:

fig, axes = plt.subplots(2, 2)
images = [img1, img2, img3]
for i in range(3):
    axes[i].imshow(images[i])
    axes[i].axis('off')

medium

A. axis('off') is not a valid method

B. images list is empty

C. imshow cannot display images in subplots

D. axes is a 2D array, so axes[i] causes an error

Solution

1. Step 1: Check the type of axes

   plt.subplots(2, 2) returns a 2D array of axes, so axes[i] is invalid indexing.

2. Step 2: Correct way to access axes

   Use axes.flat[i] or flatten axes before indexing to access each subplot.

3. Final Answer:

   axes is a 2D array, so axes[i] causes an error -> Option D

4. Quick Check:

   axes 2D array needs flat for 1D access [OK]

Hint: Use axes.flat to index subplots in 1D [OK]

Common Mistakes:

• Indexing 2D axes array as 1D
• Assuming images list is empty
• Misusing axis('off') method

5. You want to display 6 images in a 2x3 grid with titles on each subplot. Which code snippet correctly does this?

hard

A. fig, axes = plt.subplots(2, 3)
for ax, img, i in zip(axes.flat, images, range(6)):
ax.imshow(img)
ax.set_title(f'Image {i+1}')
ax.axis('off')

B. fig, axes = plt.subplots(3, 2)
for i in range(6):
axes[i].imshow(images[i])
axes[i].title(f'Image {i}')
axes[i].axis('off')

C. fig, axes = plt.subplots(2, 3)
for i in range(6):
axes[i].imshow(images[i])
axes[i].set_title('Image')
axes[i].axis('off')

D. fig, axes = plt.subplots(2, 3)
for ax, img in zip(axes, images):
ax.imshow(img)
ax.set_title('Image')
ax.axis('off')

Solution

1. Step 1: Create correct subplot grid

   plt.subplots(2, 3) creates 2 rows and 3 columns, perfect for 6 images.

2. Step 2: Loop through axes.flat and images with index

   Using axes.flat flattens the 2D axes array for easy looping. Adding index with range(6) helps set titles.

3. Step 3: Set image, title, and turn off axes

   Each axis shows one image, sets a title with number, and hides axis ticks.

4. Final Answer:

   fig, axes = plt.subplots(2, 3) for ax, img, i in zip(axes.flat, images, range(6)): ax.imshow(img) ax.set_title(f'Image {i+1}') ax.axis('off') -> Option A

5. Quick Check:

   axes.flat + set_title + axis off = correct grid [OK]

Hint: Use axes.flat and zip(images, range) for titles [OK]

Common Mistakes:

• Indexing 2D axes as 1D without flat
• Using wrong subplot shape for 6 images
• Calling non-existent title() method