map() for element-wise transformation in Pandas - Time & Space Complexity

Time Complexity: map() for element-wise transformation

O(n)

Understanding Time Complexity

We want to understand how the time taken by pandas' map() grows as the data size grows.

Specifically, how does applying a function to each element scale with more data?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import pandas as pd

df = pd.DataFrame({'A': range(1, 101)})
df['B'] = df['A'].map(lambda x: x * 2)

This code creates a DataFrame with 100 numbers and uses map() to double each number in column 'A', storing results in column 'B'.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Applying the function to each element in the column.
• How many times: Once for each element in the column (n times).

How Execution Grows With Input

As the number of elements grows, the total work grows roughly the same amount.

Input Size (n)	Approx. Operations
10	10 function calls
100	100 function calls
1000	1000 function calls

Pattern observation: Doubling the input size roughly doubles the work done.

Final Time Complexity

Time Complexity: O(n)

This means the time grows linearly with the number of elements you apply map() to.

Common Mistake

[X] Wrong: "Using map() applies the function instantly to all elements at once, so time does not grow with data size."

[OK] Correct: Actually, map() applies the function to each element one by one, so more elements mean more work and more time.

Interview Connect

Understanding how element-wise operations scale helps you write efficient data transformations and explain your code clearly in interviews.

Self-Check

"What if we replaced map() with a vectorized operation like * 2 directly on the column? How would the time complexity change?"

Practice

1. What does the map() function do when used on a pandas Series?

easy

A. It combines two Series into one.

B. It applies a transformation to each element individually.

C. It filters out elements based on a condition.

D. It sorts the Series in ascending order.

Solution

1. Step 1: Understand the purpose of map()

   map() applies a function or dictionary mapping to each element in a pandas Series one by one.

2. Step 2: Compare with other operations

   Combining, filtering, or sorting are different operations; map() specifically transforms elements individually.

3. Final Answer:

   It applies a transformation to each element individually. -> Option B

4. Quick Check:

   map() = element-wise transform [OK]

Hint: Remember: map changes each item one by one [OK]

Common Mistakes:

• Confusing map() with merge or join
• Thinking map() filters data
• Assuming map() sorts data

2. Which of the following is the correct syntax to replace values in a pandas Series s using a dictionary d with map()?

easy

A. map(s, d)

B. s.map([d])

C. s.map(d)

D. map(d, s)

Solution

1. Step 1: Recall the method call format

   In pandas, map() is a Series method called as s.map(), where s is the Series.

2. Step 2: Check argument type

   The argument to map() can be a dictionary for replacement, so s.map(d) is correct syntax.

3. Final Answer:

   s.map(d) -> Option C

4. Quick Check:

   Series.map(dict) = s.map(d) [OK]

Hint: Use Series.map(dict) syntax, not standalone map() [OK]

Common Mistakes:

• Using map() as a standalone function
• Passing dictionary inside a list
• Swapping argument order

3. Given the code:

import pandas as pd
s = pd.Series(['cat', 'dog', 'bird'])
mapping = {'cat': 'feline', 'dog': 'canine'}
result = s.map(mapping)

What is the value of result?

medium

A. 0 feline
1 canine
2 NaN
dtype: object

B. 0 feline
1 canine
2 canine
dtype: object

C. 0 cat
1 dog
2 bird
dtype: object

D. 0 feline
1 canine
2 bird
dtype: object

Solution

1. Step 1: Apply dictionary mapping with map()

   Values 'cat' and 'dog' are replaced by 'feline' and 'canine' respectively. 'bird' is not in the dictionary, so it becomes NaN.

2. Step 2: Check the output Series

   The resulting Series has 'feline', 'canine', and NaN for the third element.

3. Final Answer:

   0 feline 1 canine 2 NaN dtype: object -> Option A

4. Quick Check:

   Missing keys map to NaN [OK]

Hint: Unmapped values become NaN by default [OK]

Common Mistakes:

• Expecting unmapped values to stay unchanged
• Confusing map() with replace() behavior
• Assuming map fills missing keys automatically

4. What is wrong with this code snippet?

import pandas as pd
s = pd.Series([1, 2, 3])
result = s.map({1: 'one', 2: 'two', 3: 'three'})
print(result)

It raises a KeyError. Why?

medium

A. The dictionary keys match Series values, so no error should occur.

B. The dictionary keys do not match Series values type.

C. The dictionary keys are integers but Series has strings.

D. map() cannot accept dictionaries as arguments.

Solution

1. Step 1: Check Series and dictionary key types

   Series contains integers 1, 2, 3 and dictionary keys are also integers 1, 2, 3.

2. Step 2: Understand map() behavior with matching keys

   Since keys match values, map() replaces all values correctly without error.

3. Final Answer:

   The dictionary keys match Series values, so no error should occur. -> Option A

4. Quick Check:

   Matching keys cause no error [OK]

Hint: Matching keys and values avoid KeyError in map() [OK]

Common Mistakes:

• Assuming map() raises error on missing keys
• Confusing map() with indexing behavior
• Thinking map() cannot use dictionaries

5. You have a pandas Series s = pd.Series(['apple', 'banana', 'cherry', 'date']). You want to replace 'banana' and 'date' with their uppercase versions using map(), but keep other fruits unchanged. Which code achieves this?

hard

A. s.map({'banana': 'BANANA', 'date': 'DATE'})

B. s.map({'banana': 'BANANA', 'date': 'DATE'}, na_action='ignore')

C. s.map(lambda x: x if x in ['banana', 'date'] else x.upper())

D. s.map(lambda x: x.upper() if x in ['banana', 'date'] else x)

Solution

1. Step 1: Understand dictionary map behavior

   Using a dictionary with map replaces only keys found; others become NaN, so s.map({'banana': 'BANANA', 'date': 'DATE'}) loses 'apple' and 'cherry'.

2. Step 2: Check lambda function usage

   s.map(lambda x: x.upper() if x in ['banana', 'date'] else x) uses a lambda to uppercase only 'banana' and 'date', else keeps original, preserving all values correctly.

3. Step 3: Analyze other options

   Options A and B produce NaN for 'apple' and 'cherry' since dictionary map() sets NaN for missing keys even with na_action='ignore'; s.map(lambda x: x if x in ['banana', 'date'] else x.upper()) reverses the condition and uppercases wrong fruits.

4. Final Answer:

   s.map(lambda x: x.upper() if x in ['banana', 'date'] else x) -> Option D

5. Quick Check:

   Use lambda for selective transformation [OK]

Hint: Use lambda in map() for conditional changes [OK]

Common Mistakes:

• Using dictionary map without fillna loses data
• Confusing condition in lambda
• Assuming map() changes all values automatically