Understanding array memory layout in NumPy - Visual Explanation

Concept Flow - Understanding array memory layout

Create numpy array

↓

Array stored in memory as contiguous block

↓

Elements stored row-wise (C order) or column-wise (Fortran order)

↓

Access elements by index

↓

Memory address calculated using strides and index

↓

Data retrieved from memory location

↓

Return element value

This flow shows how a numpy array is created and stored in memory, how elements are accessed using strides and indices, and how the data is retrieved.

Execution Sample

NumPy

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
print(arr.strides)
print(arr[0,1])

Create a 2x3 numpy array, print it, show its memory strides, and access an element.

Execution Table

Step	Action	Array Shape	Strides (bytes)	Index Access	Memory Address Calculation	Value Retrieved
1	Create array	(2, 3)	(24, 8)	N/A	N/A	N/A
2	Print array	(2, 3)	(24, 8)	N/A	N/A	[[1 2 3] [4 5 6]]
3	Print strides	(2, 3)	(24, 8)	N/A	N/A	(24, 8)
4	Access element arr[0,1]	(2, 3)	(24, 8)	(0,1)	base_address + 0*24 + 1*8	2

💡 All steps completed, element accessed using strides to calculate memory offset.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
arr	undefined	[[1 2 3] [4 5 6]]	[[1 2 3] [4 5 6]]	[[1 2 3] [4 5 6]]	[[1 2 3] [4 5 6]]
arr.strides	undefined	(24, 8)	(24, 8)	(24, 8)	(24, 8)
element_value	undefined	undefined	undefined	undefined	2

Key Moments - 3 Insights

Why are the strides (24, 8) for this 2x3 array?

Each element is 8 bytes (int64). Moving one row means skipping 3 elements (3*8=24 bytes). Moving one column means skipping 1 element (8 bytes). See execution_table step 1 and 3.

How does numpy calculate the memory address for arr[0,1]?

It uses base address plus 0 times row stride plus 1 times column stride: base + 0*24 + 1*8. This is shown in execution_table step 4.

Is the array stored row-wise or column-wise in this example?

It is stored row-wise (C order) by default, meaning rows are contiguous in memory. This is why the row stride is larger (24 bytes) and column stride smaller (8 bytes).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of arr.strides after step 3?

A (8, 24)

B (24, 8)

C (3, 2)

D (2, 3)

💡 Hint

Check the 'Strides (bytes)' column in execution_table row with Step 3.

At which step is the element arr[0,1] accessed and its value retrieved?

A Step 4

B Step 3

C Step 2

D Step 1

💡 Hint

Look for 'Access element arr[0,1]' in the 'Action' column of execution_table.

If the array was stored in column-major order (Fortran), how would the strides change?

A (3, 2)

B (24, 8)

C (8, 16)

D (1, 1)

💡 Hint

Recall that Fortran order stores columns contiguously, so the first stride is smaller.

Concept Snapshot

Numpy arrays store data in contiguous memory blocks.
Strides tell how many bytes to skip to move along each dimension.
Default is row-major (C order): rows stored contiguously.
Accessing arr[i,j] uses base + i*stride_row + j*stride_col.
Strides depend on element size and array shape.
Understanding strides helps with memory layout and performance.

Full Transcript

This lesson shows how numpy arrays are stored in memory as contiguous blocks. The array shape and strides determine how to calculate the memory address for any element. Strides represent the number of bytes to jump to move along each dimension. By accessing arr[0,1], numpy calculates the address using the base address plus the strides multiplied by indices. The default storage is row-major order, meaning rows are stored one after another in memory. This understanding helps in optimizing data access and working with advanced numpy features.