Vectorization over loops in NumPy

Introduction

Vectorization makes your code faster and simpler by doing many calculations at once instead of one by one.

When you want to add two lists of numbers quickly.

When you need to multiply all elements in a big array without writing a loop.

When you want to apply a math operation to every item in a dataset.

When you want to avoid slow loops in data processing.

When working with large data arrays and want faster results.

Syntax

NumPy

result = array1 + array2
result = np.sin(array)
result = array * 2

Vectorized operations work element-wise on arrays.

You do not need to write explicit loops for these operations.

Examples

Adds two arrays element by element without a loop.

NumPy

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
sum_arr = arr1 + arr2
print(sum_arr)

Calculates sine of each element in the array at once.

NumPy

import numpy as np

arr = np.array([0, np.pi/2, np.pi])
sin_arr = np.sin(arr)
print(sin_arr)

Multiplies every element by 2 without a loop.

NumPy

import numpy as np

arr = np.array([1, 2, 3, 4])
doubled = arr * 2
print(doubled)

Sample Program

This program shows how to add, multiply, and apply sine to arrays using vectorized operations. It avoids loops and runs faster.

NumPy

import numpy as np

# Create two arrays
arr1 = np.array([10, 20, 30, 40])
arr2 = np.array([1, 2, 3, 4])

# Vectorized addition
sum_arr = arr1 + arr2

# Vectorized multiplication
product_arr = arr1 * arr2

# Vectorized sine calculation
angles = np.array([0, np.pi/2, np.pi])
sin_values = np.sin(angles)

print("Sum:", sum_arr)
print("Product:", product_arr)
print("Sine values:", sin_values)

Important Notes

Vectorized code is usually much faster than loops in Python.

Make sure arrays have the same shape or compatible shapes for operations.

Use numpy functions for math operations to get vectorization benefits.

Summary

Vectorization lets you do many calculations at once on arrays.

It makes code simpler and faster by avoiding explicit loops.

Use numpy arrays and functions to apply vectorization in data science.

Practice

1. What is the main advantage of using vectorization in numpy instead of loops?

easy

A. It makes the code run faster by doing many operations at once.

B. It uses more memory but slows down the code.

C. It makes the code harder to read and understand.

D. It requires writing more lines of code.

Solution

1. Step 1: Understand vectorization concept

   Vectorization means applying operations on whole arrays at once, not one element at a time.

2. Step 2: Compare speed and simplicity

   This approach uses optimized numpy functions that run faster than explicit loops.

3. Final Answer:

   It makes the code run faster by doing many operations at once. -> Option A

4. Quick Check:

   Vectorization = faster code [OK]

Hint: Vectorization speeds up code by handling arrays at once [OK]

Common Mistakes:

• Thinking vectorization slows code
• Believing vectorization needs more code
• Confusing vectorization with loops

2. Which of the following numpy codes correctly replaces a loop to add 5 to each element in array a?

easy

A. a + 5

B. for i in a: i = i + 5

C. np.add(a, 5, out=a)

D. a.append(5)

Solution

1. Step 1: Identify vectorized addition

   Using np.add(a, 5, out=a) adds 5 to every element in array a efficiently.

2. Step 2: Check other options

   a + 5 works but returns a new array, for i in a: i = i + 5 does not change a, and a.append(5) is invalid for numpy arrays.

3. Final Answer:

   np.add(a, 5, out=a) -> Option C

4. Quick Check:

   np.add = vectorized add [OK]

Hint: Use numpy functions like np.add for vectorized operations [OK]

Common Mistakes:

• Using loops that don't modify array
• Trying list methods on numpy arrays
• Confusing array addition with append

3. What is the output of this code?

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

medium

A. [2 4 6]

B. [1 2 3 1 2 3]

C. [3 4 5]

D. Error: cannot multiply array by int

Solution

1. Step 1: Understand array multiplication

   Multiplying a numpy array by a number multiplies each element by that number.

2. Step 2: Calculate element-wise multiplication

   Each element in [1, 2, 3] is multiplied by 2, resulting in [2, 4, 6].

3. Final Answer:

   [2 4 6] -> Option A

4. Quick Check:

   Array * number = element-wise multiply [OK]

Hint: Array * number multiplies each element [OK]

Common Mistakes:

• Thinking it concatenates arrays
• Expecting an error on multiplication
• Confusing element-wise with matrix multiply

4. Identify the error in this code that tries to add 10 to each element of arr using a loop:

import numpy as np
arr = np.array([1, 2, 3])
for i in arr:
    i = i + 10
print(arr)

medium

A. Syntax error in for loop.

B. Loop variable i does not modify original array elements.

C. Array arr is not defined.

D. Cannot add integer to numpy array elements.

Solution

1. Step 1: Understand loop variable behavior

   Variable i is a copy of each element, so changing i does not change arr.

2. Step 2: Explain why array remains unchanged

   The original array arr stays the same because the loop does not assign back to array elements.

3. Final Answer:

   Loop variable i does not modify original array elements. -> Option B

4. Quick Check:

   Loop var copy ≠ array change [OK]

Hint: Loop vars are copies; assign to array to change [OK]

Common Mistakes:

• Assuming loop changes array automatically
• Thinking syntax error exists
• Believing numpy disallows int addition

5. You have a numpy array data = np.array([1, 2, 3, 4, 5]). You want to create a new array where each element is squared if it is even, otherwise doubled. Which vectorized code achieves this?

hard

A. data * 2 if data % 2 else data ** 2

B. [x**2 if x%2==0 else x*2 for x in data]

C. for i in range(len(data)): data[i] = data[i]**2 if data[i]%2==0 else data[i]*2

D. np.where(data % 2 == 0, data**2, data*2)

Solution

1. Step 1: Understand vectorized conditional with np.where

   np.where(condition, x, y) returns array choosing x where condition is true, else y.

2. Step 2: Apply condition for even and odd elements

   Condition data % 2 == 0 checks even numbers; squares them, else doubles.

3. Step 3: Check other options

   [x**2 if x%2==0 else x*2 for x in data] uses list comprehension (not vectorized), C uses loop (not vectorized), D is invalid syntax.

4. Final Answer:

   np.where(data % 2 == 0, data**2, data*2) -> Option D

5. Quick Check:

   np.where = vectorized if-else [OK]

Hint: Use np.where for vectorized if-else conditions [OK]

Common Mistakes:

• Using loops or list comprehensions instead of vectorization
• Writing invalid syntax for conditional operations
• Confusing element-wise operations with scalar