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.

Practice

1. Why is it important to use plt.close() after creating large figures in matplotlib?

easy

A. To change the color of the figure

B. To free up memory and prevent slowing down the computer

C. To save the figure automatically

D. To increase the size of the figure

Solution

1. Step 1: Understand memory use by large figures

   Large figures use a lot of computer memory which can slow down the system if not managed.

2. Step 2: Role of plt.close()

   Using plt.close() frees the memory used by the figure after it is shown or saved.

3. Final Answer:

   To free up memory and prevent slowing down the computer -> Option B

4. Quick Check:

   Memory management = Free memory [OK]

Hint: Always close large figures to save memory after use [OK]

Common Mistakes:

• Thinking plt.close() saves the figure
• Believing it changes figure appearance
• Ignoring memory impact of many open figures

2. Which of the following is the correct syntax to close a figure in matplotlib?

easy

A. plt.closeFigure()

B. plt.close_figure()

C. plt.closeFig()

D. plt.close()

Solution

1. Step 1: Recall matplotlib function names

   The official function to close a figure is plt.close().

2. Step 2: Check other options

   Other options like plt.close_figure() or plt.closeFig() do not exist in matplotlib.

3. Final Answer:

   plt.close() -> Option D

4. Quick Check:

   Correct function name = plt.close() [OK]

Hint: Use exact function names from matplotlib docs [OK]

Common Mistakes:

• Adding extra words to function name
• Using camelCase instead of snake_case
• Confusing with save or show functions

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

import matplotlib.pyplot as plt
for i in range(3):
    fig = plt.figure()
    plt.plot([1, 2, 3], [i, i+1, i+2])
plt.show()

medium

A. Three plots will be shown and memory will be freed automatically

B. Only one plot will be shown, others are overwritten

C. Three plots will be shown but memory is not freed, causing high usage

D. Code will raise an error because plt.close() is missing

Solution

1. Step 1: Analyze the loop creating figures

   The loop creates 3 separate figures and plots on each without closing them.

2. Step 2: Understand memory impact

   Since plt.close() is not called, all figures stay in memory, increasing usage.

3. Final Answer:

   Three plots will be shown but memory is not freed, causing high usage -> Option C

4. Quick Check:

   Figures open without close = high memory [OK]

Hint: Without plt.close(), memory stays used after plotting [OK]

Common Mistakes:

• Assuming memory frees automatically after plt.show()
• Thinking only one plot appears
• Expecting an error without plt.close()

4. Identify the error in this code that creates multiple large figures:

import matplotlib.pyplot as plt
for i in range(5):
    fig = plt.figure(figsize=(10,8))
    plt.plot([1,2,3], [i,i+1,i+2])
    plt.show()

medium

A. Missing plt.close() to free memory after each figure

B. plt.show() should be outside the loop

C. Figure size is too small for large data

D. Plot data lists have different lengths

Solution

1. Step 1: Check memory management in loop

   The code creates large figures repeatedly but never closes them, causing memory buildup.

2. Step 2: Identify missing memory freeing step

   Adding plt.close() after plt.show() frees memory for each figure.

3. Final Answer:

   Missing plt.close() to free memory after each figure -> Option A

4. Quick Check:

   Close figures in loops to avoid memory leaks [OK]

Hint: Always close figures inside loops after showing [OK]

Common Mistakes:

• Moving plt.show() outside loop without closing figures
• Changing figure size instead of closing
• Ignoring memory issues with many figures

5. You need to generate 100 large plots in a script without running out of memory. Which approach is best to manage memory efficiently?

hard

A. Create each figure, plot data, save it, then call plt.close() before next

B. Create all 100 figures first, then plot and save them all together

C. Plot all data on one figure without closing it

D. Use plt.show() after all figures are created without closing

Solution

1. Step 1: Understand memory use when creating many figures

   Creating many large figures without closing them uses too much memory and slows the system.

2. Step 2: Best practice for memory management

   Creating, saving, then closing each figure before the next frees memory and avoids overload.

3. Final Answer:

   Create each figure, plot data, save it, then call plt.close() before next -> Option A

4. Quick Check:

   Close each figure after saving to save memory [OK]

Hint: Save and close each figure before next to avoid memory issues [OK]

Common Mistakes:

• Creating all figures before saving causes memory overload
• Not closing figures after plotting
• Plotting all data on one figure when separate plots needed