Memory management with large figures in Matplotlib - Step-by-Step Execution

Concept Flow - Memory management with large figures

Create large figure

↓

Plot data on figure

↓

Display or save figure

↓

Clear figure to free memory

↓

Close figure to release resources

↓

Memory freed for next figure

This flow shows how to create, use, and then clear and close large figures to manage memory efficiently.

Execution Sample

Matplotlib

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(10,8))
plt.plot(range(100000))
plt.show()
plt.clf()
plt.close(fig)

This code creates a large figure, plots a big dataset, shows it, then clears and closes the figure to free memory.

Execution Table

Step	Action	Memory Usage	Result
1	Create figure with size 10x8	Memory increases	Figure object created
2	Plot 100000 points	Memory increases significantly	Plot data added to figure
3	Show figure	Memory stable	Figure displayed on screen
4	Clear figure (plt.clf())	Memory decreases	Figure cleared but still open
5	Close figure (plt.close(fig))	Memory decreases further	Figure closed and resources freed
6	End	Memory stable at lower level	Ready for next figure

💡 Figure closed and memory freed, preventing memory buildup with large figures

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
fig	None	Figure object created	Figure with plot data	Figure displayed	Figure cleared	Figure closed (None)
Memory Usage	Low	Increased	High	Stable	Decreased	Lowered

Key Moments - 2 Insights

Why do we need to call plt.clf() before plt.close()?

plt.clf() clears the figure content but keeps the figure open, allowing reuse or proper cleanup. plt.close() frees all resources. See execution_table steps 4 and 5.

What happens if we don't close the figure after showing it?

Memory stays high because the figure and its data remain in memory, which can cause slowdowns or crashes with many large figures. See execution_table step 3 vs step 5.

Visual Quiz - 3 Questions

Look at the execution table, what happens to memory usage after plotting 100000 points?

A Memory decreases

B Memory increases significantly

C Memory stays the same

D Memory is freed

💡 Hint

Check the 'Memory Usage' column at step 2 in the execution_table

At which step is the figure actually closed and resources freed?

A Step 3

B Step 4

C Step 5

D Step 2

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for step 5

If plt.clf() was skipped, what would happen to memory after showing the figure?

A Memory would stay high until plt.close() is called

B Memory would decrease immediately

C Memory would increase further

D Memory would be freed automatically

💡 Hint

Refer to key_moments about clearing vs closing figures and execution_table steps 3-5

Concept Snapshot

Memory management with large figures in matplotlib:
- Create figure with plt.figure(figsize=(w,h))
- Plot large data sets carefully
- Use plt.show() to display
- Call plt.clf() to clear figure content
- Call plt.close(fig) to free memory
- Always clear and close to avoid memory buildup

Full Transcript

This lesson shows how to manage memory when working with large figures in matplotlib. First, you create a figure with a specified size. Then you plot your data, which increases memory use. After displaying the figure with plt.show(), you should clear the figure content using plt.clf() to remove the plot data but keep the figure open. Finally, call plt.close(fig) to close the figure and free all resources. This process prevents memory buildup that can slow down or crash your program when working with many or large plots.