When to use apply vs vectorized operations in Pandas - Performance Comparison

Time Complexity: When to use apply vs vectorized operations

O(n) for apply, O(1) for vectorized operations

Understanding Time Complexity

We want to understand how the time to run pandas code changes when using apply versus vectorized operations.

Which method grows faster as data size increases?

Scenario Under Consideration

Analyze the time complexity of these two approaches.

import pandas as pd

n = 10  # Define n before using it

df = pd.DataFrame({'A': range(n)})

# Using apply
result_apply = df['A'].apply(lambda x: x * 2)

# Using vectorized operation
result_vec = df['A'] * 2

This code multiplies each value in column 'A' by 2 using two methods: apply with a lambda, and a vectorized operation.

Identify Repeating Operations

Look at what repeats as the data grows.

• Primary operation: For apply, the lambda function runs once per row.
• How many times: Exactly n times, where n is the number of rows.
• Vectorized operation: Uses optimized internal code that processes all rows together.
• How many times: Effectively once, working on the whole column at once.

How Execution Grows With Input

As the number of rows grows, the time for apply grows linearly because it runs the function on each row.

Vectorized operations grow much slower because they use fast, low-level code that handles many rows at once.

Input Size (n)	Approx. Operations for apply	Approx. Operations for vectorized
10	10 function calls	1 fast operation
100	100 function calls	1 fast operation
1000	1000 function calls	1 fast operation

Pattern observation: apply time grows directly with data size; vectorized stays mostly constant and is much faster.

Final Time Complexity

Time Complexity: O(n) for apply, O(1) for vectorized operations

This means apply takes longer as data grows, while vectorized operations handle large data efficiently.

Common Mistake

[X] Wrong: "Using apply is just as fast as vectorized operations because both process all rows."

[OK] Correct: apply runs Python code for each row, which is slower, while vectorized operations use optimized compiled code that works on all data at once.

Interview Connect

Knowing when to use vectorized operations versus apply shows you understand efficient data handling, a key skill in data science work.

Self-Check

What if the function inside apply was a built-in NumPy function instead of a lambda? How would that affect the time complexity?

Practice

1. Which of the following best describes when to use apply in pandas?

easy

A. When you want to merge two DataFrames.

B. When you want to perform simple arithmetic on entire columns quickly.

C. When you want to sort a DataFrame by a column.

D. When you need to run a custom function on each row or column.

Solution

1. Step 1: Understand the purpose of apply

   apply is used to apply custom or complex functions to rows or columns in a DataFrame.

2. Step 2: Compare with vectorized operations

   Vectorized operations are for simple, fast math on entire columns, not custom row-wise functions.

3. Final Answer:

   When you need to run a custom function on each row or column. -> Option D

4. Quick Check:

   Custom function use = apply = A [OK]

Hint: Use apply for custom row/column functions, vectorized for simple math [OK]

Common Mistakes:

• Confusing apply with vectorized operations for simple math
• Using apply for sorting or merging
• Thinking apply is always faster

2. Which of these is the correct syntax to use apply on a DataFrame column df['col'] with a function func?

easy

A. apply(df['col'], func)

B. df['col'].apply(func)

C. df.apply['col'](func)

D. df['col'].apply = func

Solution

1. Step 1: Recall the method call syntax

   In pandas, apply is a method called on a Series or DataFrame with the function as argument.

2. Step 2: Check each option

   df['col'].apply(func) uses correct syntax: df['col'].apply(func). Others have syntax errors or wrong usage.

3. Final Answer:

   df['col'].apply(func) -> Option B

4. Quick Check:

   Method call with function argument = C [OK]

Hint: Use dot apply with parentheses and function inside [OK]

Common Mistakes:

• Using square brackets instead of parentheses for apply
• Trying to assign function to apply attribute
• Calling apply as a standalone function

3. Given the DataFrame:

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

What is the output of:

df['C'] = df['A'] + df['B']
df['D'] = df['A'].apply(lambda x: x * 2)
df[['C', 'D']]

medium

A. C D
0 5 2
1 7 4
2 9 6

B. C D
0 5 1
1 7 2
2 9 3

C. C D
0 4 2
1 5 4
2 6 6

D. C D
0 5 4
1 7 6
2 9 8

Solution

1. Step 1: Calculate column C using vectorized addition

   Column C = A + B = [1+4, 2+5, 3+6] = [5, 7, 9]

2. Step 2: Calculate column D using apply with lambda

   Column D = A * 2 = [1*2, 2*2, 3*2] = [2, 4, 6]

3. Final Answer:

   C D 0 5 2 1 7 4 2 9 6 -> Option A

4. Quick Check:

   Vectorized + apply results = B [OK]

Hint: Add columns directly, use apply for custom row-wise ops [OK]

Common Mistakes:

• Mixing up which columns are added
• Forgetting to multiply by 2 in apply
• Confusing apply output with original values

4. You want to double the values in column 'A' of DataFrame df. Which code has an error?

medium

A. df['A'] = df['A'] * 2

B. df['A'] = df['A'].apply(lambda x: x * 2)

C. df['A'] = df.apply(lambda x: x['A'] * 2)

D. df['A'] = df['A'].map(lambda x: x * 2)

Solution

1. Step 1: Analyze df['A'] = df.apply(lambda x: x['A'] * 2)'s use of apply

   Using df.apply without specifying axis defaults to axis=0 (columns), so x['A'] fails because x is a column name string, not a row.

2. Step 2: Compare with other options

   Options B, C, and D correctly double values using apply on Series, vectorized, or map on Series.

3. Final Answer:

   df['A'] = df.apply(lambda x: x['A'] * 2) -> Option C

4. Quick Check:

   apply on DataFrame needs axis=1 for row-wise, else error = A [OK]

Hint: Use axis=1 with apply on DataFrame rows to avoid errors [OK]

Common Mistakes:

• Forgetting axis=1 in DataFrame apply
• Confusing apply on DataFrame vs Series
• Using map on DataFrame instead of Series

5. You have a DataFrame df with columns 'X' and 'Y'. You want to create a new column 'Z' that is 'X' squared if 'Y' is even, else 'X' cubed. Which is the best approach?

hard

A. Use vectorized operations with np.where and powers.

B. Use apply with a custom function checking Y and computing Z.

C. Use a for loop to iterate rows and assign Z values.

D. Use map on column 'X' only.

Solution

1. Step 1: Understand the condition and operations

   We want Z = X^2 if Y is even, else Z = X^3.

2. Step 2: Choose efficient method

   Using np.where with vectorized power operations is fast and clear. apply works but is slower. For loops are slow and verbose. map on X alone can't check Y.

3. Final Answer:

   Use vectorized operations with np.where and powers. -> Option A

4. Quick Check:

   Conditional vectorized ops > apply or loops = D [OK]

Hint: Use np.where for conditional vectorized operations [OK]

Common Mistakes:

• Using apply when vectorized is faster
• Using loops instead of vectorized code
• Trying to map without condition on another column