matplotlib iterate subplot axis array through single list

Question

Is there a simple/clean way to iterate an array of axis returned by subplots like

nrow = ncol = 2
a = []
fig, axs = plt.subplots(nrows=nrow, ncols=ncol)
for i, row in enumerate(axs):
    for j, ax in enumerate(row):
        a.append(ax)

for i, ax in enumerate(a):
    ax.set_ylabel(str(i))

which even works for nrow or ncol == 1.

I tried list comprehension like:

[element for tupl in tupleOfTuples for element in tupl]

but that fails if nrows or ncols == 1

The solution which also works with a single axis is [this one](https://stackoverflow.com/a/33649912/774575). — mins, Dec 15 '22 at 15:53

score 97 · Accepted Answer · edited Apr 25 '18 at 00:18

97

The ax return value is a numpy array, which can be reshaped, I believe, without any copying of the data. If you use the following, you'll get a linear array that you can iterate over cleanly.

nrow = 1; ncol = 2;
fig, axs = plt.subplots(nrows=nrow, ncols=ncol)

for ax in axs.reshape(-1): 
  ax.set_ylabel(str(i))

This doesn't hold when ncols and nrows are both 1, since the return value is not an array; you could turn the return value into an array with one element for consistency, though it feels a bit like a cludge:

nrow = 1; ncol = 1;
fig, axs = plt.subplots(nrows=nrow, ncols=nrow)
axs = np.array(axs)

for ax in axs.reshape(-1):
  ax.set_ylabel(str(i))

reshape docs. The argument -1 causes reshape to infer dimensions of the output.

edited Apr 25 '18 at 00:18

Max Ghenis

14,783
16
84
132

answered Nov 29 '13 at 16:00

Bonlenfum

19,101
2
53
56

14

For `nrow=ncol=1` you can use `squeeze=0`. `plt.subplots(nrows=nrow, ncols=nrow, squeeze=0)` always returns a 2 dimensional array for the axes, even if both are one. – cronos Apr 06 '16 at 11:26
This suggestion will not work because axs is not a numpy array in the case nrow=ncol=1. squeeze=0 works! – Julek Apr 19 '23 at 16:31

score 69 · Answer 2 · answered Nov 11 '15 at 11:48

69

The fig return value of plt.subplots has a list of all the axes. To iterate over all the subplots in a figure you can use:

nrow = 2
ncol = 2
fig, axs = plt.subplots(nrow, ncol)
for i, ax in enumerate(fig.axes):
    ax.set_ylabel(str(i))

This also works for nrow == ncol == 1.

answered Nov 11 '15 at 11:48

Ø. Jensen

943
6
10

so we don't need the `axs` then? – user2739472 Feb 18 '19 at 17:00
3

this is so simple and so useful! – John Mahoney Sep 18 '20 at 21:39
This should be the selected answer. – mins Dec 15 '22 at 15:52

Mark · Answer 3 · 2017-04-04T07:47:19.873

23

I am not sure when it was added, but there is now a squeeze keyword argument. This makes sure the result is always a 2D numpy array. Turning that into a 1D array is easy:

fig, ax2d = subplots(2, 2, squeeze=False)
axli = ax2d.flatten()

Works for any number of subplots, no trick for single ax, so a little easier than the accepted answer (perhaps squeeze didn't exist yet back then).

edited Apr 04 '17 at 07:47

answered Feb 28 '17 at 18:50

Mark

18,730
7
107
130

did you mean `ax2d.flatten()` in your second line? Otherwise it's unclear what `ax1d` is referencing. – not link Apr 03 '17 at 22:30
1

@notlink Ow yeah that makes more sense – Mark Apr 04 '17 at 07:47

score 17 · Answer 4 · answered Oct 14 '17 at 07:06

17

Matplotlib has its own flatten function on axes.

Why don't you try following code?

fig, axes = plt.subplots(2, 3)
for ax in axes.flat:
    ## do something with instance of 'ax'

answered Oct 14 '17 at 07:06

Sukjun Kim

187
1
5

4

`.flat` is an attribute of the numpy array and has nothing to do with matplotlib. – ImportanceOfBeingErnest Jan 25 '18 at 10:00
@ImportanceOfBeingErnest Thanks for correcting my answer. I got confused. – Sukjun Kim Sep 03 '18 at 03:35

score 11 · Answer 5 · answered Jul 01 '20 at 22:47

TLDR; axes.flat is the most pythonic way of iterating through axes

As others have pointed out, the return value of plt.subplots() is a numpy array of Axes objects, thus there are a ton of built-in numpy methods for flattening the array. Of those options axes.flat is the least verbose access method. Furthermore, axes.flatten() returns a copy of the array whereas axes.flat returns an iterator to the array. This means axes.flat will be more efficient in the long run.

Stealing @Sukjun-Kim's example:

fig, axes = plt.subplots(2, 3)
for ax in axes.flat:
    ## do something with instance of 'ax'

sources: axes.flat docs Matplotlib tutorial

Reza K Ghazi · Answer 6 · 2022-11-16T16:50:23.647

3

Here is a good practice:
For example, we need a set up four by four subplots so we can have them like below:

rows = 4; cols = 4;
fig, axes = plt.subplots(nrows=rows, ncols=cols, figsize=(20, 16), squeeze=0, sharex=True, sharey=True)
axes = np.array(axes)

for i, ax in enumerate(axes.reshape(-1)):
  ax.set_ylabel(f'Subplot: {i}')

The output is beautiful and clear.

edited Nov 16 '22 at 16:50

answered Oct 27 '20 at 19:53

Reza K Ghazi

347
2
9

matplotlib iterate subplot axis array through single list

6 Answers6

Linked

Related