Monitoring memory usage in NumPy - Step-by-Step Execution

Concept Flow - Monitoring memory usage

Start Program

↓

Create numpy array

↓

Check memory usage

↓

Print memory info

↓

Modify array (optional)

↓

Re-check memory usage

↓

End Program

This flow shows creating a numpy array, checking its memory usage, optionally modifying it, and then checking memory usage again.

Execution Sample

NumPy

import numpy as np
arr = np.arange(1000)
print(arr.nbytes)
arr = arr * 2
print(arr.nbytes)

Create a numpy array of 1000 integers, print its memory usage, modify it, then print memory usage again.

Execution Table

Step	Action	Array Size	Memory Usage (bytes)	Output
1	Create array with np.arange(1000)	1000 elements	8000
2	Print arr.nbytes	1000 elements	8000	8000
3	Modify array by multiplying by 2	1000 elements	8000
4	Print arr.nbytes after modification	1000 elements	8000	8000
5	End program	1000 elements	8000

💡 Program ends after printing memory usage twice; memory size remains constant as array size unchanged.

Variable Tracker

Variable	Start	After Step 1	After Step 3	Final
arr	undefined	array of 1000 ints	array of 1000 ints multiplied by 2	array of 1000 ints multiplied by 2
arr.nbytes	undefined	8000	8000	8000

Key Moments - 2 Insights

Why does arr.nbytes stay the same even after modifying the array?

Because the array size (number of elements) does not change, only the values change. Memory usage depends on size, not content. See execution_table rows 1, 3, and 4.

What does arr.nbytes actually measure?

It measures the total bytes used by the array data buffer, calculated as number of elements times size of each element. This is shown in execution_table column 'Memory Usage (bytes)'.

Visual Quiz - 3 Questions

Look at the execution table, what is the memory usage after creating the array?

A 1000 bytes

B 8000 bytes

C 16000 bytes

D 0 bytes

💡 Hint

Check the 'Memory Usage (bytes)' column at Step 1 in the execution_table.

At which step does the array get modified?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the 'Action' column in the execution_table for the modification action.

If the array size changed to 2000 elements, how would arr.nbytes change?

A It would halve to 4000 bytes

B It would stay 8000 bytes

C It would double to 16000 bytes

D It would become zero

💡 Hint

Refer to variable_tracker and understand arr.nbytes depends on number of elements times element size.

Concept Snapshot

Monitoring memory usage with numpy:
- Use arr.nbytes to get total bytes used by array data
- Memory depends on array size and element type
- Modifying values doesn't change memory if size unchanged
- Useful for tracking memory in data processing
- Example: arr = np.arange(1000); print(arr.nbytes)

Full Transcript

This lesson shows how to monitor memory usage of numpy arrays using the nbytes attribute. First, we create an array of 1000 integers with np.arange(1000). Then we print arr.nbytes which shows 8000 bytes because each int64 element uses 8 bytes. Next, we modify the array by multiplying all elements by 2. Printing arr.nbytes again shows 8000 bytes because the array size did not change, only the values. This demonstrates that memory usage depends on the number of elements and their data type, not the content. This helps track memory in programs using numpy arrays.