Memory layout (C-order vs Fortran-order) in NumPy - Visual Side-by-Side Comparison

Concept Flow - Memory layout (C-order vs Fortran-order)

Create 2D array

↓

Choose memory order

↓

C-order

↓

Row-major

↓

Memory stores rows

↓

Memory stores columns

↓

Access elements in memory order

↓

Efficient memory use & speed

This flow shows how a 2D array is stored in memory depending on C-order (row-major) or Fortran-order (column-major), affecting access speed.

Execution Sample

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.ravel())
print(arr_f.ravel())

Creates the same 2x2 array in C-order and Fortran-order, then prints their flattened memory layouts.

Execution Table

Step	Action	Array Shape	Memory Order	Flattened Output	Explanation
1	Create arr_c with order='C'	(2,2)	C-order (row-major)	[1 2 3 4]	Rows stored sequentially: first row then second
2	Create arr_f with order='F'	(2,2)	Fortran-order (column-major)	[1 3 2 4]	Columns stored sequentially: first column then second
3	Print arr_c.ravel()	(2,2)	C-order	[1 2 3 4]	Flattened view matches row-major storage
4	Print arr_f.ravel()	(2,2)	Fortran-order	[1 3 2 4]	Flattened view matches column-major storage
5	End	-	-	-	All steps done, arrays created and flattened

💡 Execution stops after printing both flattened arrays showing different memory layouts.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
arr_c	None	[[1 2] [3 4]] (C-order)	[[1 2] [3 4]] (C-order)	[[1 2] [3 4]] (C-order)	[[1 2] [3 4]] (C-order)	[[1 2] [3 4]] (C-order)
arr_f	None	None	[[1 2] [3 4]] (F-order)	[[1 2] [3 4]] (F-order)	[[1 2] [3 4]] (F-order)	[[1 2] [3 4]] (F-order)

Key Moments - 3 Insights

Why does arr_f.ravel() output [1 3 2 4] instead of [1 2 3 4]?

Because arr_f uses Fortran-order, which stores columns sequentially in memory, so flattening reads down columns first, not rows.

Does the shape of arr_c and arr_f differ?

No, both arrays have the same shape (2,2), only their memory layout differs, as shown in the execution_table steps 1 and 2.

Why is memory layout important for performance?

Accessing elements in the order they are stored in memory (row-wise for C-order, column-wise for Fortran-order) is faster due to better cache usage, as implied in the concept_flow.

Visual Quiz - 3 Questions

Look at the execution_table row 2. What is the flattened output of arr_f?

A [1 3 2 4]

B [3 4 1 2]

C [1 2 3 4]

D [2 1 4 3]

💡 Hint

Check the 'Flattened Output' column in row 2 of execution_table.

At which step does arr_c get created with C-order memory layout?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Action' and 'Memory Order' columns in execution_table.

If we access arr_c elements column-wise, how does it affect performance?

A Performance improves because memory is stored column-wise

B Performance decreases because memory is stored row-wise

C Performance is unaffected

D Performance is unpredictable

💡 Hint

Refer to concept_flow and key_moments about memory layout and access patterns.

Concept Snapshot

Memory layout controls how arrays are stored in memory.
C-order means row-major: rows stored one after another.
Fortran-order means column-major: columns stored sequentially.
Flattening (ravel) shows memory order.
Accessing data in stored order is faster.
Use order='C' or order='F' in numpy.array to set layout.

Full Transcript

This lesson shows how numpy arrays can be stored in memory in two ways: C-order (row-major) and Fortran-order (column-major). We create two identical 2x2 arrays but specify different memory orders. When flattened, the C-order array outputs elements row by row, while the Fortran-order array outputs elements column by column. This difference affects how data is accessed and can impact performance. Understanding memory layout helps write faster code by accessing elements in the order they are stored.

Practice

1. What does C-order memory layout mean in NumPy arrays?

easy

A. Rows are stored one after another in memory.

B. Columns are stored one after another in memory.

C. Data is stored randomly in memory.

D. Memory layout depends on the array shape only.

Solution

1. Step 1: Understand C-order layout

   C-order means the array stores data row by row, so all elements of the first row come first, then the second row, and so on.

2. Step 2: Compare with other layouts

   Fortran-order stores columns one after another, not rows. Random or shape-based storage is incorrect.

3. Final Answer:

   Rows are stored one after another in memory. -> Option A

4. Quick Check:

   C-order = rows stored sequentially [OK]

Hint: C-order means row-wise storage in memory [OK]

Common Mistakes:

• Confusing C-order with Fortran-order
• Thinking memory layout depends only on shape
• Assuming random storage order

2. Which of the following is the correct way to create a NumPy array with Fortran-order memory layout?

easy

A. np.array([[1, 2], [3, 4]], order='C')

B. np.array([[1, 2], [3, 4]], order='F')

C. np.array([[1, 2], [3, 4]], layout='F')

D. np.array([[1, 2], [3, 4]], memory='Fortran')

Solution

1. Step 1: Recall NumPy array creation syntax

   NumPy uses the parameter 'order' to specify memory layout, with 'C' for C-order and 'F' for Fortran-order.

2. Step 2: Identify correct parameter and value

   np.array([[1, 2], [3, 4]], order='F') uses order='F', which is the correct way to request Fortran-order layout.

3. Final Answer:

   np.array([[1, 2], [3, 4]], order='F') -> Option B

4. Quick Check:

   Use order='F' for Fortran-order arrays [OK]

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

Common Mistakes:

• Using wrong parameter name like 'layout' or 'memory'
• Confusing order='C' with Fortran-order
• Omitting the order parameter

3. What will be the output of the following code?

import numpy as np
arr = np.array([[1, 2], [3, 4]], order='F')
print(arr.flags.f_contiguous)

medium

A. True

B. False

C. Raises an error

D. None

Solution

1. Step 1: Understand the array creation

   The array is created with order='F', so it uses Fortran-order memory layout.

2. Step 2: Check the f_contiguous flag

   The f_contiguous flag is True if the array is stored in Fortran-contiguous order, which matches order='F'.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Fortran-order array has f_contiguous = True [OK]

Hint: f_contiguous is True for Fortran-order arrays [OK]

Common Mistakes:

• Confusing f_contiguous with c_contiguous
• Expecting False for order='F'
• Thinking flags attribute raises error

4. The following code is intended to create a Fortran-order array, but it does not. What is the error?

import numpy as np
arr = np.array([[1, 2], [3, 4]])
arr = np.asfortranarray(arr, order='C')

medium

A. np.array must have order='F' to create Fortran array.

B. order='C' forces C-order, not Fortran-order.

C. np.asfortranarray does not accept 'order' parameter.

D. arr is immutable and cannot change order.

Solution

1. Step 1: Understand np.asfortranarray usage

   np.asfortranarray converts an array to Fortran-order. It does not take an 'order' parameter.

2. Step 2: Analyze the incorrect parameter

   Passing order='C' is an unexpected keyword argument, causing a TypeError that prevents creating the Fortran-order array.

3. Final Answer:

   np.asfortranarray does not accept 'order' parameter. -> Option C

4. Quick Check:

   np.asfortranarray rejects 'order' parameter [OK]

Hint: np.asfortranarray does not accept 'order' parameter [OK]

Common Mistakes:

• Assuming np.asfortranarray accepts order parameter
• Thinking order='C' overrides Fortran layout
• Thinking arrays are immutable in this context

5. You have a large 2D NumPy array representing image data. You want to speed up column-wise operations. Which memory layout should you choose and why?

hard

A. C-order, because rows are stored consecutively, speeding up column access.

B. Either layout works the same for column-wise operations.

C. Use random memory layout for better cache usage.

D. Fortran-order, because columns are stored consecutively, speeding up column access.

Solution

1. Step 1: Understand memory layout impact on access

   For column-wise operations, accessing consecutive memory locations improves speed due to cache efficiency.

2. Step 2: Identify layout matching column-wise access

   Fortran-order stores columns consecutively, so column-wise operations are faster with Fortran-order.

3. Step 3: Evaluate other options

   C-order stores rows consecutively, so column access is slower. Random layout is not a valid option.

4. Final Answer:

   Fortran-order, because columns are stored consecutively, speeding up column access. -> Option D

5. Quick Check:

   For column speed, use Fortran-order [OK]

Hint: For column operations, choose Fortran-order layout [OK]

Common Mistakes:

• Choosing C-order for column-wise speed
• Thinking layout does not affect speed
• Believing random layout improves cache