# How do I tell Matplotlib to create a second (new) plot, then later plot on the old one?

## Question:

I want to plot data, then create a new figure and plot data2, and finally come back to the original plot and plot data3, kinda like this:

```
import numpy as np
import matplotlib as plt
x = arange(5)
y = np.exp(5)
plt.figure()
plt.plot(x, y)
z = np.sin(x)
plt.figure()
plt.plot(x, z)
w = np.cos(x)
plt.figure("""first figure""") # Here's the part I need
plt.plot(x, w)
```

FYI How do I tell matplotlib that I am done with a plot? does something similar, but not quite! It doesn’t let me get access to that original plot.

## Answers:

When you call `figure`

, simply number the plot.

```
x = arange(5)
y = np.exp(5)
plt.figure(0)
plt.plot(x, y)
z = np.sin(x)
plt.figure(1)
plt.plot(x, z)
w = np.cos(x)
plt.figure(0) # Here's the part I need
plt.plot(x, w)
```

Edit: Note that you can number the plots however you want (here, starting from `0`

) but if you don’t provide figure with a number at all when you create a new one, the automatic numbering will start at `1`

(“Matlab Style” according to the docs).

However, numbering starts at `1`

, so:

```
x = arange(5)
y = np.exp(5)
plt.figure(1)
plt.plot(x, y)
z = np.sin(x)
plt.figure(2)
plt.plot(x, z)
w = np.cos(x)
plt.figure(1) # Here's the part I need, but numbering starts at 1!
plt.plot(x, w)
```

Also, if you have multiple axes on a figure, such as subplots, use the `axes(h)`

command where `h`

is the handle of the desired axes object to focus on that axes.

(don’t have comment privileges yet, sorry for new answer!)

If you find yourself doing things like this regularly it may be worth investigating the object-oriented interface to matplotlib. In your case:

```
import matplotlib.pyplot as plt
import numpy as np
x = np.arange(5)
y = np.exp(x)
fig1, ax1 = plt.subplots()
ax1.plot(x, y)
ax1.set_title("Axis 1 title")
ax1.set_xlabel("X-label for axis 1")
z = np.sin(x)
fig2, (ax2, ax3) = plt.subplots(nrows=2, ncols=1) # two axes on figure
ax2.plot(x, z)
ax3.plot(x, -z)
w = np.cos(x)
ax1.plot(x, w) # can continue plotting on the first axis
```

It is a little more verbose but it’s much clearer and easier to keep track of, especially with several figures each with multiple subplots.

One way I found after some struggling is creating a function which gets data_plot matrix, file name and order as parameter to create boxplots from the given data in the ordered figure (different orders = different figures) and save it under the given file_name.

```
def plotFigure(data_plot,file_name,order):
fig = plt.figure(order, figsize=(9, 6))
ax = fig.add_subplot(111)
bp = ax.boxplot(data_plot)
fig.savefig(file_name, bbox_inches='tight')
plt.close()
```

The accepted answer here says to use the *object oriented interface* (`matplotlib`

) but the answer itself incoporates some of the *MATLAB-style interface* (`matplotib.pyplot`

).

It is possible to use **solely the OOP** method, if you like that sort of thing:

```
import numpy as np
import matplotlib
x = np.arange(5)
y = np.exp(x)
first_figure = matplotlib.figure.Figure()
first_figure_axis = first_figure.add_subplot()
first_figure_axis.plot(x, y)
z = np.sin(x)
second_figure = matplotlib.figure.Figure()
second_figure_axis = second_figure.add_subplot()
second_figure_axis.plot(x, z)
w = np.cos(x)
first_figure_axis.plot(x, w)
display(first_figure) # Jupyter
display(second_figure)
```

This gives the user manual control over the figures, and avoids problems associated with `pyplot`

‘s internal state supporting only a single figure.

An easy way to plot separate frame for each iteration could be:

```
import matplotlib.pyplot as plt
for grp in list_groups:
plt.figure()
plt.plot(grp)
plt.show()
```

Then python will plot different frames.