Why vectorized operations matter in NumPy - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of vectorized vs loop sum

What is the output of the following code comparing vectorized sum and loop sum using numpy arrays?

NumPy

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
vectorized_sum = np.sum(arr)
loop_sum = 0
for x in arr:
    loop_sum += x
print(vectorized_sum, loop_sum)

A 15 14

B 15 15

C 15 0

D TypeError

💡 Hint

Think about how numpy's sum and a manual loop add numbers.

Both numpy's sum and the manual loop add all elements, so both results are 15.

❓ data_output

intermediate

Result shape after vectorized operation

Given the code below, what is the shape of the result array after the vectorized operation?

NumPy

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6]])
result = arr * 2
print(result.shape)

A (2,)

B (2, 3)

C (6,)

D (3, 2)

💡 Hint

Multiplying by 2 does not change the shape of the array.

Element-wise multiplication keeps the original shape (3 rows, 2 columns).

🔧 Debug

advanced

Identify the error in vectorized operation

What error does the following code raise?

NumPy

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5])
result = arr1 + arr2

A No error, result is [5, 7, 3]

B TypeError: unsupported operand type(s) for +: 'int' and 'list'

C ValueError: operands could not be broadcast together with shapes (3,) (2,)

D IndexError: index out of range

💡 Hint

Check if the arrays have compatible shapes for element-wise addition.

Arrays with different shapes that cannot be broadcast cause a ValueError.

🚀 Application

advanced

Why vectorized operations are faster

Which reason best explains why vectorized operations in numpy are faster than Python loops?

A Vectorized operations use compiled C code internally, reducing Python overhead.

B Vectorized operations run on a separate GPU automatically.

C Python loops are optimized for speed, so vectorized operations are slower.

D Vectorized operations use more memory, which slows down execution.

💡 Hint

Think about how numpy is implemented under the hood.

Numpy vectorized operations call fast compiled code, avoiding slow Python loops.

🧠 Conceptual

expert

Impact of vectorization on large data processing

Which statement best describes the impact of vectorized operations on processing large datasets?

A Vectorized operations reduce execution time and improve memory efficiency by minimizing explicit loops.

B Vectorized operations increase execution time because they require more complex code.

C Vectorized operations have no impact on performance for large datasets.

D Vectorized operations always use more memory and slow down processing.

💡 Hint

Consider how vectorization affects loops and memory access.

Vectorization reduces Python overhead and uses optimized memory access, speeding up large data processing.