Vectorized operations vs loops in Pandas - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of vectorized addition vs loop addition

Consider a pandas DataFrame with a column of numbers. What is the output of the following code snippets?

Pandas

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3, 4, 5]})

# Vectorized addition
result_vectorized = df['A'] + 10

# Loop addition
result_loop = []
for x in df['A']:
    result_loop.append(x + 10)

print(result_vectorized.tolist())
print(result_loop)

A [11, 12, 13, 14, 15] and [11, 12, 13, 14, 15]

B [11, 12, 13, 14, 15] and [1, 2, 3, 4, 5]

C [11, 12, 13, 14, 15] and [10, 20, 30, 40, 50]

D [1, 2, 3, 4, 5] and [11, 12, 13, 14, 15]

💡 Hint

Think about how vectorized operations apply the operation to each element automatically.

Both vectorized addition and the loop add 10 to each element in the column, resulting in the same list of values.

❓ data_output

intermediate

Performance difference in execution time

Which of the following statements correctly describes the typical performance difference between vectorized operations and loops in pandas?

A Loops and vectorized operations have the same performance in pandas.

B Vectorized operations are usually slower than loops because they add overhead.

C Vectorized operations are usually faster than loops because they use optimized C code internally.

D Loops are faster because they allow more control over each element.

💡 Hint

Think about how pandas and numpy are implemented under the hood.

Vectorized operations use optimized low-level code, making them faster than explicit Python loops over data.

🔧 Debug

advanced

Identify the error in loop vs vectorized operation

What error will the following code produce and why?

Pandas

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3]})

# Incorrect loop to add 5
result = []
for x in df['A']:
    result.append(x + '5')

print(result)

A ValueError: cannot add string to integer

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

C No error, output: [6, 7, 8]

D SyntaxError: invalid syntax

💡 Hint

Check the data types involved in the addition inside the loop.

The code tries to add an integer and a string, which is not allowed in Python and raises a TypeError.

❓ visualization

advanced

Visualizing speed difference between vectorized and loop operations

You run the following code to compare execution times. Which plot correctly shows the expected result?

Pandas

import pandas as pd
import numpy as np
import time
import matplotlib.pyplot as plt

size = 100000
s = pd.Series(np.arange(size))

start = time.time()
result_vec = s + 1
vec_time = time.time() - start

start = time.time()
result_loop = []
for x in s:
    result_loop.append(x + 1)
loop_time = time.time() - start

plt.bar(['Vectorized', 'Loop'], [vec_time, loop_time])
plt.ylabel('Time in seconds')
plt.title('Execution time comparison')
plt.show()

A Bar plot showing Vectorized time much smaller than Loop time

B Bar plot showing Vectorized time much larger than Loop time

C Bar plot showing Vectorized and Loop times almost equal

D Line plot showing Vectorized time increasing and Loop time decreasing

💡 Hint

Think about how pandas optimizes vectorized operations compared to Python loops.

Vectorized operations run much faster than loops, so the bar for Vectorized time is much smaller.

🧠 Conceptual

expert

Why vectorized operations are preferred in pandas

Which of the following is NOT a reason why vectorized operations are preferred over loops in pandas?

A Vectorized operations reduce the amount of Python code and improve readability.

B Vectorized operations minimize overhead by avoiding explicit Python loops.

C Vectorized operations leverage optimized C code for faster execution.

D Vectorized operations automatically parallelize computations across multiple CPU cores.

💡 Hint

Consider what pandas does internally and what it does not do automatically.

Pandas vectorized operations do not automatically parallelize across CPU cores; parallelism requires extra tools.

Practice

1. Which of the following best describes vectorized operations in pandas?

easy

A. They require writing explicit for-loops to manipulate data.

B. They process data one row at a time using loops.

C. They operate on entire columns or arrays at once, making them faster.

D. They are slower than loops for large datasets.

Solution

1. Step 1: Understand vectorized operations

   Vectorized operations apply a function to whole columns or arrays simultaneously.

2. Step 2: Compare with loops

   Loops process data row by row, which is slower for large data.

3. Final Answer:

   They operate on entire columns or arrays at once, making them faster. -> Option C

4. Quick Check:

   Vectorized = whole columns at once [OK]

Hint: Vectorized means whole column at once, not row by row [OK]

Common Mistakes:

• Confusing vectorized operations with loops
• Thinking loops are faster for large data
• Believing vectorized operations require explicit loops

2. Which of the following is the correct syntax to add 10 to every element in a pandas Series s using vectorized operations?

easy

A. for i in s: s[i] = s[i] + 10

B. s = s + 10

C. s.apply(lambda x: x + 10)

D. s.add(10, inplace=True)

Solution

1. Step 1: Identify vectorized addition syntax

   Adding a scalar to a Series directly uses vectorized addition: s = s + 10.

2. Step 2: Check other options

   for i in s: s[i] = s[i] + 10 uses a loop incorrectly, C returns a new Series but does not assign, B is invalid because add does not have inplace.

3. Final Answer:

   s = s + 10 -> Option B

4. Quick Check:

   Use s + 10 for vectorized add [OK]

Hint: Use s + 10 for vectorized addition, no loops [OK]

Common Mistakes:

• Trying to modify Series inside a for-loop
• Using apply without assignment
• Using invalid inplace parameter with add()

3. What will be the output of this code?

import pandas as pd
s = pd.Series([1, 2, 3])
result = []
for val in s:
    result.append(val * 2)
print(result)

medium

A. Error: cannot multiply Series elements in loop

B. pd.Series([2, 4, 6])

C. [1, 2, 3]

D. [2, 4, 6]

Solution

1. Step 1: Understand the loop operation

   The loop goes through each value in the Series and multiplies it by 2, appending to a list.

2. Step 2: Check the printed output

   The printed output is the list [2, 4, 6], not a Series.

3. Final Answer:

   [2, 4, 6] -> Option D

4. Quick Check:

   Loop multiplies each value, list output [OK]

Hint: Loop appends multiplied values to list, not Series [OK]

Common Mistakes:

• Expecting a Series output instead of list
• Confusing loop with vectorized operation
• Thinking loop causes error multiplying values

4. Identify the error in this code that tries to double values in a pandas Series s:

result = []
for i in range(len(s)):
    result.append(s[i] * 2)
print(result)

medium

A. No error; code works correctly

B. Accessing Series elements by integer index is invalid

C. Using range(len(s)) causes an IndexError

D. Appending to list inside loop is not allowed

Solution

1. Step 1: Check indexing method

   Accessing Series elements by integer position with s[i] works if Series index is default 0-based.

2. Step 2: Verify loop and append

   The loop appends doubled values to list correctly; no error occurs.

3. Final Answer:

   No error; code works correctly -> Option A

4. Quick Check:

   Indexing by position works if default index [OK]

Hint: Default Series index allows integer access [OK]

Common Mistakes:

• Assuming s[i] always causes error
• Thinking append inside loop is invalid
• Confusing label-based and position-based indexing

5. You have a DataFrame df with a column 'price'. You want to increase all prices by 5% efficiently. Which method is best?

hard

A. Use df['price'] = df['price'] * 1.05 to apply vectorized multiplication.

B. Use a for-loop to multiply each price by 1.05 and update the DataFrame row by row.

C. Use df.apply(lambda row: row['price'] * 1.05, axis=1) without assignment.

D. Convert the column to a list, multiply each element by 1.05 in a loop, then assign back.

Solution

1. Step 1: Identify efficient vectorized method

   Multiplying the entire column by 1.05 directly uses vectorized operations and is fastest.

2. Step 2: Evaluate other options

   Use a for-loop to multiply each price by 1.05 and update the DataFrame row by row. uses slow loops, C does not assign result back, D is inefficient with list conversion.

3. Final Answer:

   Use df['price'] = df['price'] * 1.05 to apply vectorized multiplication. -> Option A

4. Quick Check:

   Vectorized column operation is fastest [OK]

Hint: Multiply whole column directly for speed [OK]

Common Mistakes:

• Using loops instead of vectorized operations
• Forgetting to assign result back to DataFrame
• Converting to list unnecessarily