Why NumPy over Python lists - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Comparing speed of element-wise addition

What is the output of the following code showing the time taken for element-wise addition using Python lists vs NumPy arrays?

NumPy

import time
import numpy as np

size = 1000000
list1 = list(range(size))
list2 = list(range(size))

start = time.time()
result_list = [list1[i] + list2[i] for i in range(size)]
end = time.time()
list_time = end - start

arr1 = np.arange(size)
arr2 = np.arange(size)

start = time.time()
result_np = arr1 + arr2
end = time.time()
np_time = end - start

print(f"List time: {list_time:.4f} seconds")
print(f"NumPy time: {np_time:.4f} seconds")

A NumPy time is significantly higher than list time, showing lists are faster

B List time and NumPy time are about the same

C List time is significantly higher than NumPy time, showing NumPy is faster

D Both times are zero seconds due to fast execution

💡 Hint

Think about how Python loops compare to NumPy's optimized operations.

NumPy uses optimized C code and vectorized operations, making element-wise operations much faster than Python loops over lists.

❓ data_output

intermediate

Memory usage difference between list and NumPy array

What is the output of the following code comparing memory usage of a Python list and a NumPy array of the same size?

NumPy

import sys
import numpy as np

size = 1000000
list1 = list(range(size))
arr1 = np.arange(size)

list_mem = sys.getsizeof(list1) + sum(sys.getsizeof(x) for x in list1)
arr_mem = arr1.nbytes

print(f"List memory: {list_mem} bytes")
print(f"NumPy array memory: {arr_mem} bytes")

A List memory is much larger than NumPy array memory

B NumPy array memory is zero bytes

C Both have the same memory usage

D List memory is smaller than NumPy array memory

💡 Hint

Consider how Python lists store references vs NumPy arrays store raw data.

Python lists store pointers to objects, which uses more memory. NumPy arrays store data in a compact, typed format, using less memory.

🧠 Conceptual

advanced

Why does NumPy use less memory than Python lists?

Which reason best explains why NumPy arrays use less memory than Python lists?

A NumPy arrays store data as strings, which are smaller than numbers.

B NumPy arrays store elements as raw typed data in contiguous memory blocks, while lists store pointers to objects.

C Python lists store data in a binary format, which uses more space.

D NumPy arrays compress data automatically, while lists do not.

💡 Hint

Think about how data is stored in memory for each type.

NumPy arrays store data in fixed-type, contiguous blocks, reducing overhead. Lists store references to Python objects, increasing memory use.

🔧 Debug

advanced

Identifying error in mixed-type NumPy array creation

What error or behavior occurs when running this code?

NumPy

import numpy as np

arr = np.array([1, 2, '3', 4])
print(arr.dtype)
print(arr + 1)

A The array has dtype '<U21' (string) and adding 1 raises a TypeError

B The array has dtype int and adding 1 works fine

C The array has dtype float and adding 1 works fine

D The code raises a SyntaxError

💡 Hint

Check how NumPy handles mixed data types in arrays.

NumPy converts all elements to a common type. Here, presence of a string causes all elements to become strings. Adding 1 to strings causes a TypeError.

🚀 Application

expert

Choosing NumPy for large-scale numerical computations

You need to perform matrix multiplication on two large datasets efficiently. Which reason best supports choosing NumPy arrays over Python lists?

A Python lists can only store strings, so they cannot be used for matrix multiplication.

B Python lists automatically parallelize operations, making them faster for large data.

C NumPy arrays use more memory but are easier to read.

D NumPy arrays support optimized, vectorized operations implemented in C, making matrix multiplication faster and more memory efficient.

💡 Hint

Think about speed and memory when working with large numerical data.

NumPy uses optimized C code and vectorized operations for fast and memory-efficient matrix math. Python lists are slower and less efficient for such tasks.