Memory layout (C-order vs Fortran-order) in NumPy - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of array flattening with different memory orders

What is the output of the following code?

import numpy as np
arr = np.array([[1, 2], [3, 4]])
flat_c = arr.flatten(order='C')
flat_f = arr.flatten(order='F')
print(flat_c)
print(flat_f)

NumPy

import numpy as np
arr = np.array([[1, 2], [3, 4]])
flat_c = arr.flatten(order='C')
flat_f = arr.flatten(order='F')
print(flat_c)
print(flat_f)

A

[1 2 3 4]
[1 3 2 4]

B

[1 3 2 4]
[1 2 3 4]

C

[1 2 3 4]
[4 3 2 1]

D

[4 3 2 1]
[1 2 3 4]

💡 Hint

Remember that C-order flattens row-wise, Fortran-order flattens column-wise.

In C-order, flattening reads rows first: [1, 2, 3, 4]. In Fortran-order, flattening reads columns first: [1, 3, 2, 4].

❓ data_output

intermediate

Shape and strides of arrays with different memory orders

Given the code below, what are the strides of the arrays arr_c and arr_f?

import numpy as np
arr_c = np.array([[1, 2], [3, 4]], order='C')
arr_f = np.array([[1, 2], [3, 4]], order='F')
print(arr_c.strides)
print(arr_f.strides)

NumPy

import numpy as np
arr_c = np.array([[1, 2], [3, 4]], order='C')
arr_f = np.array([[1, 2], [3, 4]], order='F')
print(arr_c.strides)
print(arr_f.strides)

A

(8, 8)
(8, 8)

B

(8, 16)
(16, 8)

C

(16, 16)
(16, 16)

D

(16, 8)
(8, 16)

💡 Hint

Strides show how many bytes to jump to get to the next element in each dimension.

In C-order, the last axis changes fastest, so strides are (row_stride, col_stride) = (16, 8) for int64 (8 bytes per element). In Fortran-order, the first axis changes fastest, so strides are (8, 16).

🔧 Debug

advanced

Why does this reshape cause an error with Fortran order?

Consider the code below. Which option correctly explains why the reshape fails?

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]], order='F')
arr_reshaped = arr.reshape((3, 2), order='C')

NumPy

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]], order='F')
arr_reshaped = arr.reshape((3, 2), order='C')

A Runs successfully and returns a reshaped array with shape (3, 2).

B Raises ValueError because the memory layout order of the original array does not match the reshape order.

C Raises TypeError because reshape does not accept the order parameter.

D Raises IndexError because the new shape is incompatible with the original shape.

💡 Hint

Reshape with order='C' expects the array to be C-contiguous.

The original array is Fortran-contiguous, but reshape with order='C' requires C-contiguous memory. This mismatch causes a ValueError.

🚀 Application

advanced

Choosing memory layout for performance in matrix multiplication

You want to multiply two large matrices using NumPy. Which memory layout choice is generally better for performance and why?

A Use C-order arrays because NumPy's dot product is optimized for row-major contiguous data.

B Use Fortran-order arrays because NumPy's dot product is optimized for column-major contiguous data.

C Memory layout does not affect matrix multiplication performance in NumPy.

D Use a mix of C-order and Fortran-order arrays for best performance.

💡 Hint

Think about how NumPy stores arrays by default and how BLAS libraries expect data.

NumPy stores arrays in C-order by default, and its underlying BLAS libraries are optimized for row-major contiguous data, so using C-order arrays usually gives better performance.

🧠 Conceptual

expert

Effect of memory layout on slicing and views

Which statement about slicing a Fortran-order NumPy array is true?

A Slicing a Fortran-order array along any axis returns a view with contiguous memory in C order.

B Slicing a Fortran-order array always returns a copy, never a view.

C Slicing a Fortran-order array along the first axis returns a view with contiguous memory in Fortran order.

D Slicing a Fortran-order array along the last axis returns a view with contiguous memory in C order.

💡 Hint

Consider how Fortran-order arrays store data column-wise and how slicing affects contiguity.

Fortran-order arrays store data column-wise, so slicing along the first axis (rows) preserves Fortran-contiguous views. Slicing along other axes may break contiguity or return non-contiguous views.