Contiguous arrays and stride tricks in NumPy - Step-by-Step Execution

Concept Flow - Contiguous arrays and stride tricks

Create numpy array

↓

Check memory layout

↓

Is array contiguous?

No→Use stride tricks to view data

Yes↓

Perform operations efficiently

↓

End

Start by creating a numpy array, check if it is stored contiguously in memory. If not, use stride tricks to create a new view without copying data, enabling efficient operations.

Execution Sample

NumPy

import numpy as np
arr = np.arange(10)
view = np.lib.stride_tricks.as_strided(arr, shape=(5,), strides=(2*arr.strides[0],))
print(view)

Create a numpy array, then use stride tricks to create a view that skips every other element, showing how strides control data access.

Execution Table

Step	Action	Array Shape	Strides (bytes)	Resulting View	Explanation
1	Create arr with np.arange(10)	(10,)	(8,)	[0 1 2 3 4 5 6 7 8 9]	arr is a 1D array of 10 integers, each 8 bytes
2	Calculate new strides for view	-	-	-	Original stride is 8 bytes; new stride is 16 bytes (skip every other element)
3	Create view with as_strided	(5,)	(16,)	[0 2 4 6 8]	View accesses elements at indices 0,2,4,6,8 without copying data
4	Print view	-	-	[0 2 4 6 8]	Output shows the strided view elements
5	End	-	-	-	Execution complete

💡 All steps executed; view created using stride tricks to access every other element.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
arr	None	[0 1 2 3 4 5 6 7 8 9]	[0 1 2 3 4 5 6 7 8 9]	[0 1 2 3 4 5 6 7 8 9]	[0 1 2 3 4 5 6 7 8 9]
arr.strides	None	(8,)	(8,)	(8,)	(8,)
view	None	None	None	View with shape (5,) and strides (16,)	[0 2 4 6 8]

Key Moments - 3 Insights

Why does the view show elements skipping every other index?

Because the stride is set to 16 bytes, which is twice the original 8 bytes per element, so the view jumps over one element each time (see execution_table step 3).

Does using stride tricks copy the data?

No, stride tricks create a new view on the same data buffer without copying, making it memory efficient (see variable_tracker for 'view').

What happens if the stride is set incorrectly?

Incorrect strides can cause the view to access invalid memory or produce unexpected results; always ensure strides align with data layout (refer to execution_table step 2).

Visual Quiz - 3 Questions

Look at the execution_table step 3, what is the shape of the view created?

A (5,)

B (10,)

C (2,)

D (8,)

💡 Hint

Check the 'Array Shape' column in step 3 of the execution_table.

At which step does the stride change to skip every other element?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Action' and 'Strides' columns in the execution_table.

If the stride was set to 8 bytes instead of 16 in step 3, what would the view show?

A Elements at indices 0, 2, 4, 6, 8

B Elements at indices 0, 1, 2, 3, 4

C Elements at indices 1, 3, 5, 7, 9

D An error due to invalid stride

💡 Hint

Refer to how stride relates to element spacing in the variable_tracker and execution_table.

Concept Snapshot

Contiguous arrays store data sequentially in memory.
Strides define how many bytes to jump to get the next element.
Stride tricks create new views by changing strides without copying data.
Use np.lib.stride_tricks.as_strided to make custom views.
Be careful: incorrect strides can cause errors or wrong data.
Efficient for advanced slicing and memory optimization.

Full Transcript

This lesson shows how numpy arrays store data contiguously and how strides control element access. We start by creating a simple array of 10 integers. Each integer takes 8 bytes, so the stride is 8 bytes. Using stride tricks, we create a new view that skips every other element by doubling the stride to 16 bytes. This new view has shape (5,) and accesses elements at indices 0, 2, 4, 6, and 8 without copying data. The execution table tracks each step, showing how the array shape and strides change. The variable tracker shows the original array and the new view. Key moments clarify why the view skips elements, that no data is copied, and the importance of correct strides. The quiz tests understanding of shape, stride changes, and effects of stride values. The snapshot summarizes the concept for quick review.

Practice

1. What does it mean when a NumPy array is contiguous?

easy

A. It has more than one dimension.

B. It contains only positive numbers.

C. Its data is stored in one continuous block of memory.

D. It is a copy of another array.

Solution

1. Step 1: Understand contiguous memory

   A contiguous array stores all its elements in one continuous block of memory, which helps with fast access and efficient computation.

2. Step 2: Compare with other options

   Options B, C, and D describe other properties unrelated to memory layout.

3. Final Answer:

   Its data is stored in one continuous block of memory. -> Option C

4. Quick Check:

   Contiguous = continuous memory block [OK]

Hint: Contiguous means data is stored without gaps [OK]

Common Mistakes:

• Confusing contiguous with array shape
• Thinking contiguous means sorted data
• Assuming contiguous means a copy

2. Which of the following is the correct way to create a view using NumPy stride tricks?

easy

A. np.array(arr, copy=True)

B. np.copy(arr).reshape(3,3)

C. arr.flatten()

D. np.lib.stride_tricks.as_strided(arr, shape=(3,3), strides=(8,8))

Solution

1. Step 1: Identify stride tricks usage

   The function np.lib.stride_tricks.as_strided creates a view with a new shape and strides without copying data.

2. Step 2: Check other options

   Options B, C, and D create copies or flatten arrays, not views with stride tricks.

3. Final Answer:

   np.lib.stride_tricks.as_strided(arr, shape=(3,3), strides=(8,8)) -> Option D

4. Quick Check:

   Stride tricks use as_strided() [OK]

Hint: Use as_strided() to create views with custom strides [OK]

Common Mistakes:

• Using copy() instead of as_strided()
• Flattening instead of changing strides
• Confusing reshape with stride tricks

3. What will be the output of this code?

import numpy as np
arr = np.arange(6)
view = np.lib.stride_tricks.as_strided(arr, shape=(3,), strides=(2*arr.itemsize,))
view[0] = 100
print(arr)

medium

A. [100 1 2 3 4 100]

B. [100 1 2 3 4 5]

C. [100 1 100 3 4 5]

D. [0 1 2 3 4 5]

Solution

1. Step 1: Understand stride and view

   The view selects elements with stride 2*itemsize, so it accesses arr[0], arr[2], arr[4]. Changing view[0] changes arr[0], changing view[1] changes arr[2], etc.

2. Step 2: Analyze the assignment and print

   view[0] = 100 sets arr[0] = 100. The print shows arr with arr[0] changed, arr[2] and arr[4] unchanged.

3. Final Answer:

   [100 1 2 3 4 5] -> Option B

4. Quick Check:

   Stride view modifies original array [OK]

Hint: Stride selects spaced elements; modifying view changes original [OK]

Common Mistakes:

• Assuming view is a copy, not a view
• Ignoring stride size effect
• Expecting all elements to change

4. Identify the error in this code snippet:

import numpy as np
arr = np.arange(4)
view = np.lib.stride_tricks.as_strided(arr, shape=(3,3), strides=(8,8))
print(view)

medium

A. The shape is incompatible with the original array size.

B. The strides are incorrect for the array's data type.

C. as_strided cannot be used on 1D arrays.

D. The code will run without errors and print a 3x3 view.

Solution

1. Step 1: Check shape vs original array size

   The original array has 4 elements, but the requested view shape is (3,3) = 9 elements, which is larger than original data.

2. Step 2: Understand stride_tricks constraints

   as_strided creates views without copying, so shape must fit within original data size. Here, it does not, causing invalid memory access.

3. Final Answer:

   The shape is incompatible with the original array size. -> Option A

4. Quick Check:

   View shape must fit original array size [OK]

Hint: View shape must not exceed original array size [OK]

Common Mistakes:

• Ignoring array size vs view shape
• Assuming as_strided copies data
• Misunderstanding stride meaning

5. You have a large 1D NumPy array representing sensor data. You want to create a 2D sliding window view of size 4 without copying data. Which approach correctly uses stride tricks to achieve this?

hard

A. Use np.lib.stride_tricks.as_strided with shape=(len(arr)-3, 4) and strides=(arr.itemsize, arr.itemsize).

B. Use arr.reshape(-1, 4) to create windows.

C. Use np.copy(arr).reshape(-1, 4) to avoid modifying original data.

D. Use arr.flatten() and then slice manually.

Solution

1. Step 1: Understand sliding window with stride tricks

   Sliding window views use as_strided with shape=(number_of_windows, window_size) and strides that move one element at a time for rows and one element for columns.

2. Step 2: Check options for correct usage

   Use np.lib.stride_tricks.as_strided with shape=(len(arr)-3, 4) and strides=(arr.itemsize, arr.itemsize). correctly sets shape and strides to create overlapping windows without copying. Options B and C reshape but do not create sliding windows. Use arr.flatten() and then slice manually. flattens but does not create windows.

3. Final Answer:

   Use np.lib.stride_tricks.as_strided with shape=(len(arr)-3, 4) and strides=(arr.itemsize, arr.itemsize). -> Option A

4. Quick Check:

   Sliding windows need as_strided with correct shape and strides [OK]

Hint: Sliding windows need as_strided with overlapping strides [OK]

Common Mistakes:

• Using reshape instead of stride tricks
• Copying data unnecessarily
• Incorrect stride values causing wrong windows