CSC format (Compressed Sparse Column) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of CSC matrix data arrays

Given the following code creating a CSC matrix, what is the output of the data, indices, and indptr arrays?

SciPy

from scipy.sparse import csc_matrix
import numpy as np

matrix = np.array([[0, 0, 1],
                   [2, 0, 0],
                   [0, 3, 4]])
csc = csc_matrix(matrix)
print(csc.data)
print(csc.indices)
print(csc.indptr)

A

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

B

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

C

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

D

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

💡 Hint

Remember CSC stores data column-wise. Check each column's non-zero elements.

The CSC format stores non-zero values column by column. The data array holds these values in order. The indices array holds the row indices of each data element. The indptr array points to column start positions in data.

For the given matrix:

[[0, 0, 1],
 [2, 0, 0],
 [0, 3, 4]]

Column 0 has non-zero value 2 at row 1.

Column 1 has non-zero value 3 at row 2.

Column 2 has non-zero values 1 at row 0 and 4 at row 2.

So data = [1, 2, 3, 4] is incorrect order; correct order is [2, 3, 1, 4] which matches option A.

❓ data_output

intermediate

Number of non-zero elements in CSC matrix

What is the number of non-zero elements in the following CSC matrix?

SciPy

from scipy.sparse import csc_matrix
import numpy as np

matrix = np.array([[0, 5, 0],
                   [0, 0, 0],
                   [7, 0, 9]])
csc = csc_matrix(matrix)
print(csc.nnz)

A 4

B 2

C 5

D 3

💡 Hint

Count all non-zero values in the matrix.

The matrix has three non-zero values: 5, 7, and 9.

So the number of non-zero elements (nnz) is 3.

🔧 Debug

advanced

Identify the error in CSC matrix creation

Which option will cause an error when creating a CSC matrix from the given data arrays?

SciPy

from scipy.sparse import csc_matrix
import numpy as np

data = np.array([1, 2, 3])
indices = np.array([0, 1, 2])
indptr = np.array([0, 1, 2, 3])

csc = csc_matrix((data, indices, indptr), shape=(3, 3))

A csc_matrix((data, indptr, indices), shape=(3, 3))

B csc_matrix((data, indices, indptr), shape=(3, 3))

C csc_matrix((data, indices), shape=(3, 3))

D csc_matrix((data, indices, indptr), shape=(3, 2))

💡 Hint

Check the order of the tuple arguments for CSC matrix constructor.

The CSC matrix constructor expects a tuple of (data, indices, indptr) in that order.

Option A swaps indptr and indices, causing a ValueError.

Option A misses indptr, causing a TypeError.

Option A has a shape mismatch causing a ValueError.

🚀 Application

advanced

Extract column from CSC matrix

Given a CSC matrix, which code snippet correctly extracts the second column as a dense array?

SciPy

from scipy.sparse import csc_matrix
import numpy as np

matrix = np.array([[0, 1, 0],
                   [2, 0, 3],
                   [0, 4, 0]])
csc = csc_matrix(matrix)

A csc[:, 1].toarray()

B csc.getcol(1).toarray().flatten()

C csc.getrow(1).toarray().flatten()

D csc[1, :].toarray()

💡 Hint

Use the method designed to get a column from a sparse matrix.

getcol(1) extracts the second column (index 1) as a sparse matrix.

Calling toarray() converts it to a dense 2D array.

flatten() converts it to 1D array.

Option B returns a 2D array but is valid too, but option B matches the exact requested output (1D array).

Options A and C extract rows, not columns.

🧠 Conceptual

expert

Memory efficiency of CSC vs CSR for column slicing

Which statement best explains why CSC format is more efficient than CSR format for extracting columns from a sparse matrix?

A CSC stores data row-wise, so column slicing is slower than CSR which stores data column-wise.

B CSR stores data row-wise, so column slicing requires scanning all rows, making it slower and less memory efficient.

C CSC stores data column-wise, so column slicing accesses contiguous memory, making it faster and more memory efficient.

D CSR and CSC have identical memory layouts, so there is no difference in efficiency for column slicing.

💡 Hint

Think about how data is stored and accessed in CSC vs CSR formats.

CSC format stores non-zero elements column by column, so accessing a column is direct and efficient.

CSR stores data row by row, so extracting a column requires scanning multiple rows, which is slower.

Therefore, CSC is more efficient for column slicing.