Contiguous arrays and stride tricks in NumPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean for a NumPy array to be contiguous?

A contiguous NumPy array stores its data in a single, continuous block of memory. This means the elements are laid out one after another without gaps, which makes operations faster and memory access efficient.

intermediate

What is the purpose of stride tricks in NumPy?

Stride tricks let you create new views of an array by changing how NumPy steps through the data in memory, without copying it. This helps to create sliding windows or reshape data efficiently.

beginner

How can you check if a NumPy array is contiguous?

You can check if an array is contiguous by using the attributes arr.flags['C_CONTIGUOUS'] or arr.flags['F_CONTIGUOUS']. C_CONTIGUOUS means row-major order, and F_CONTIGUOUS means column-major order.

advanced

What happens if you use stride tricks incorrectly?

Using stride tricks incorrectly can lead to unexpected results or even crashes because you might access memory outside the array bounds. It’s important to ensure the new view respects the original data layout.

beginner

Explain the difference between a view and a copy in NumPy.

A view shares the same data buffer as the original array but may have a different shape or strides. Changes to the view affect the original array. A copy creates a new array with its own data, so changes do not affect the original.

Which attribute tells you if a NumPy array is stored in a continuous block of memory in row-major order?

A arr.shape

B arr.strides

C arr.flags['C_CONTIGUOUS']

D arr.flags['F_CONTIGUOUS']

The 'C_CONTIGUOUS' flag is True if the array is stored in a continuous block of memory in row-major (C-style) order.

What does the stride of a NumPy array represent?

A The total number of elements in the array

B The number of bytes to step in each dimension when traversing the array

C The shape of the array

D The data type of the array elements

Stride tells how many bytes NumPy moves in memory to go from one element to the next along each dimension.

What is a key benefit of using stride tricks in NumPy?

A Creating new views without copying data

B Changing the data type of an array

C Creating new arrays with copied data

D Sorting array elements

Stride tricks allow creating new views of the data with different shapes or windows without copying the data.

If an array is not contiguous, what might happen when performing operations?

A Operations might be slower due to non-contiguous memory access

B The array will automatically become contiguous

C The array data will be lost

D The array shape will change

Non-contiguous arrays can cause slower operations because memory access is less efficient.

Which function in NumPy can be used to create a sliding window view using stride tricks?

A numpy.concatenate

B numpy.copy

C numpy.reshape

D numpy.lib.stride_tricks.sliding_window_view

The function 'sliding_window_view' creates a view of sliding windows over the array using stride tricks.

Describe what contiguous arrays are in NumPy and why they matter for performance.

Think about how data is stored in memory and how that affects speed.

Explain how stride tricks work and give an example of when you might use them.

Consider how you can look at the same data in different shapes without copying.

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