Introduction

In Matplotlib, the call that actually tells the library you are finished with a figure is plt.close() or plt.close(fig). plt.show() only displays the figure. In simple scripts that may be enough, but in loops, tests, and servers you should close figures explicitly so memory and figure state do not pile up.

Use plt.close(fig) for Explicit Cleanup

The safest habit is to keep a reference to the figure you created and close that exact figure when you are finished.

1import matplotlib.pyplot as plt
2
3fig, ax = plt.subplots()
4ax.plot([1, 2, 3], [1, 4, 9])
5ax.set_title("Quadratic Growth")
6
7fig.savefig("quadratic.png")
8plt.close(fig)

This pattern works well in scripts, batch jobs, web services, and tests. It makes cleanup explicit instead of depending on backend-specific behavior.

What plt.show() Does and Does Not Do

plt.show() asks Matplotlib to render the current figure or figures. In a desktop script, it usually blocks until the window is closed. That is useful for interactive inspection, but it is not the same as resource cleanup.

1import matplotlib.pyplot as plt
2
3fig, ax = plt.subplots()
4ax.bar(["A", "B", "C"], [3, 5, 2])
5plt.show()
6plt.close(fig)

Calling plt.close(fig) after plt.show() is a good habit when the script may continue creating more figures afterward.

Close Figures Inside Loops

A common source of memory growth is generating many figures in a loop and never closing them. Each figure remains registered until it is closed.

1import matplotlib.pyplot as plt
2
3for i in range(3):
4    fig, ax = plt.subplots()
5    ax.plot([0, 1, 2], [i, i + 1, i + 2])
6    fig.savefig(f"plot-{i}.png")
7    plt.close(fig)

If you skip the close call in long-running loops, Matplotlib may warn that too many figures are open. More importantly, your process may keep unnecessary memory alive.

Prefer the Object-Oriented API

When code becomes more than a one-off notebook cell, prefer fig, ax = plt.subplots() over relying entirely on the global pyplot state. The object-oriented style makes it easier to know which figure should be saved, shown, or closed.

It also reduces confusion when multiple figures exist at once. Instead of closing “whatever is current,” you close the figure you created.

cla, clf, and close Are Different

Matplotlib provides several cleanup-related calls, but they do different jobs. ax.cla() clears one axes, plt.clf() clears the current figure, and plt.close() removes the figure itself from Matplotlib's registry.

If your goal is to reuse a figure object in a very controlled workflow, clearing may be enough. If your goal is to finish with the figure completely, closing is the correct call.

Notebook and Headless Environments

In Jupyter notebooks, figures are often displayed automatically. Even there, explicit cleanup can help when generating many plots programmatically.

For headless environments such as CI or backend services, use a non-interactive backend and close figures after saving them.

1import matplotlib
2matplotlib.use("Agg")
3
4import matplotlib.pyplot as plt
5
6fig, ax = plt.subplots()
7ax.hist([1, 2, 2, 3, 3, 3])
8fig.savefig("histogram.png")
9plt.close(fig)

This avoids GUI dependencies and keeps the plotting code suitable for automated runs.

Common Pitfalls

• Assuming plt.show() automatically handles all cleanup in every environment.
• Creating figures in a loop and never closing them.
• Using plt.close() without tracking which figure you mean when multiple figures are open.
• Mixing notebook habits with production code and forgetting explicit resource management.
• Saving a figure after closing it, which can produce empty or invalid output.

Summary

• Use plt.close(fig) to tell Matplotlib you are finished with a specific figure.
• Use plt.show() for display, not as a substitute for cleanup.
• Always close figures in loops, tests, and long-running processes.
• Prefer the object-oriented API so figure ownership is clear.
• In headless environments, save the figure and then close it explicitly.