Understanding array memory layout in NumPy - Interactive Quiz & Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a 2D NumPy array filled with zeros.

NumPy

import numpy as np
arr = np.[1]((3, 4))

Drag options to blanks, or click blank then click option'

Azeros

Bones

Cempty

Dfull

Attempts:

3 left

💡 Hint

Common Mistakes

Using np.ones instead of np.zeros

Using np.empty which creates uninitialized values

The np.zeros function creates an array filled with zeros.

2fill in blank

medium

Complete the code to check if the array is stored in C-contiguous order.

NumPy

is_c_contiguous = arr.[1]

Drag options to blanks, or click blank then click option'

Aflags.contiguous

Bflags.c_order

Cflags.c_contiguous

Dflags.f_contiguous

Attempts:

3 left

💡 Hint

Common Mistakes

Using f_contiguous which checks Fortran order

Using flags.contiguous which does not exist

The flags.c_contiguous attribute tells if the array is stored in C-contiguous order (row-major).

3fill in blank

hard

Fix the error in the code to reshape the array without copying data.

NumPy

reshaped = arr.[1]((6, 2), order='K')

Drag options to blanks, or click blank then click option'

Areshape

Bflatten

Cresize

Dravel

Attempts:

3 left

💡 Hint

Common Mistakes

Using resize which changes the array in-place and may copy

Using flatten which always returns a copy

The reshape method can reshape an array without copying data if possible, especially with order='K'.

4fill in blank

hard

Fill both blanks to create a Fortran-contiguous array and check its memory layout.

NumPy

arr_f = np.array([[1, 2], [3, 4]], order=[1])
is_fortran = arr_f.flags.[2]

Drag options to blanks, or click blank then click option'

A'F'

B'C'

Cf_contiguous

Dc_contiguous

Attempts:

3 left

💡 Hint

Common Mistakes

Using order='C' instead of 'F'

Checking c_contiguous flag for Fortran layout

Setting order='F' creates a Fortran-contiguous array. The flags.f_contiguous attribute checks this layout.

5fill in blank

hard

Fill all three blanks to create a C-contiguous array, reshape it, and verify the layout.

NumPy

arr_c = np.array([[5, 6], [7, 8]], order=[1])
reshaped_c = arr_c.[2]((4, 1))
is_c = reshaped_c.flags.[3]

Drag options to blanks, or click blank then click option'

A'F'

Breshape

Cc_contiguous

D'C'

Attempts:

3 left

💡 Hint

Common Mistakes

Using order='F' instead of 'C'

Using resize instead of reshape

Checking f_contiguous flag for C layout

Creating with order='C' makes a C-contiguous array. Using reshape changes shape without copying. The flags.c_contiguous confirms C-contiguity.

Practice

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

easy

A. The array is stored as a list of Python objects.

B. The array is stored in column-major order, meaning columns are stored one after another in memory.

C. The array is stored in row-major order, meaning rows are stored one after another in memory.

D. The array is stored in a compressed format to save memory.

Solution

1. Step 1: Understand memory layout types

   C-contiguous means the array is stored in row-major order, where rows are stored sequentially in memory.

2. Step 2: Compare with other layouts

   Fortran-contiguous arrays store columns sequentially, not rows.

3. Final Answer:

   The array is stored in row-major order, meaning rows are stored one after another in memory. -> Option C

4. Quick Check:

   C-contiguous = row-major order [OK]

Hint: C-contiguous means rows stored sequentially in memory [OK]

Common Mistakes:

• Confusing C-contiguous with Fortran-contiguous
• Thinking C-contiguous means compressed storage
• Assuming C-contiguous means column-major order

2. Which of the following NumPy commands correctly checks if an array a is stored in Fortran-contiguous order?

easy

A. np.isfortran(a)

B. np.iscontiguous(a)

C. a.is_fortran()

D. a.flags.f_contiguous

Solution

1. Step 1: Recall NumPy flags for memory layout

   NumPy arrays have a flags attribute with f_contiguous to check Fortran order.

2. Step 2: Identify correct syntax

   a.flags.f_contiguous returns True if array a is Fortran-contiguous.

3. Final Answer:

   a.flags.f_contiguous -> Option D

4. Quick Check:

   Check Fortran order with a.flags.f_contiguous [OK]

Hint: Use a.flags.f_contiguous to check Fortran order [OK]

Common Mistakes:

• Using non-existent functions like np.isfortran
• Confusing C-contiguous and Fortran-contiguous flags
• Trying to call methods that don't exist on arrays

3. Consider the following code:

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
transposed = arr.T
print(transposed.flags.c_contiguous)

What will be the output?

medium

A. True

B. False

C. Raises an AttributeError

D. None

Solution

1. Step 1: Understand the original array layout

   Original array arr is C-contiguous by default (row-major).

2. Step 2: Analyze the transpose operation

   Transposing arr.T changes memory layout to non-C-contiguous because rows and columns swap.

3. Step 3: Check the flag after transpose

   transposed.flags.c_contiguous will be False since the transpose breaks row-major order.

4. Final Answer:

   False -> Option B

5. Quick Check:

   Transpose breaks C-contiguity = False [OK]

Hint: Transpose usually breaks C-contiguity, so flag is False [OK]

Common Mistakes:

• Assuming transpose keeps C-contiguity True
• Confusing c_contiguous with f_contiguous
• Expecting an error instead of a boolean

4. You have this code:

import numpy as np
arr = np.arange(6).reshape(2, 3)
sliced = arr[:, 1:3]
print(sliced.flags.c_contiguous)

Why might sliced.flags.c_contiguous be False?

medium

A. Because slicing can create views that are not stored continuously in memory.

B. Because slicing always returns a copy, which is never contiguous.

C. Because reshape changes the memory layout to Fortran order.

D. Because arange creates arrays that are never contiguous.

Solution

1. Step 1: Understand slicing behavior

   Slicing often returns a view, which may not be stored continuously in memory.

2. Step 2: Check memory layout after slicing

   The slice arr[:, 1:3] selects columns 1 and 2, which may not be contiguous in row-major order.

3. Step 3: Explain why c_contiguous is False

   Because the slice skips some elements in memory, the resulting view is not C-contiguous.

4. Final Answer:

   Because slicing can create views that are not stored continuously in memory. -> Option A

5. Quick Check:

   Slicing can break contiguity = False [OK]

Hint: Slicing can create non-contiguous views, so flag may be False [OK]

Common Mistakes:

• Thinking slicing always returns a copy
• Assuming reshape changes memory layout to Fortran order by default
• Believing arange arrays are never contiguous

5. You want to create a large 2D NumPy array with shape (1000, 1000) that is stored in Fortran order for faster column-wise operations. Which code snippet correctly creates such an array?

hard

A. np.zeros((1000, 1000), order='F')

B. np.zeros((1000, 1000), order='C')

C. np.zeros((1000, 1000)).T.copy()

D. np.zeros((1000, 1000), fortran=True)

Solution

1. Step 1: Recall how to specify memory order in NumPy

   Use the order parameter with value 'F' to create Fortran-contiguous arrays.

2. Step 2: Analyze each option

   np.zeros((1000, 1000), order='F') uses order='F', which is correct. np.zeros((1000, 1000), order='C') uses 'C' (row-major). np.zeros((1000, 1000)).T.copy() transposes a C-contiguous array and copies it into a new C-contiguous array by default. np.zeros((1000, 1000), fortran=True) uses an invalid parameter.

3. Final Answer:

   np.zeros((1000, 1000), order='F') -> Option A

4. Quick Check:

   Use order='F' to create Fortran order arrays [OK]

Hint: Use order='F' in array creation for Fortran order [OK]

Common Mistakes:

• Using order='C' instead of 'F'
• Trying to transpose to get Fortran order
• Using invalid parameters like fortran=True