map() for element-wise transformation in Pandas

Introduction

The map() function helps change each item in a list or column one by one. It makes it easy to update or replace values quickly.

You want to replace codes with full names, like 'NY' to 'New York'.

You need to apply a small calculation or change to each value in a column.

You want to convert categories to numbers for analysis.

You want to clean or fix typos in text data in a column.

Syntax

Pandas

Series.map(arg, na_action=None)

# arg can be a dict, function, or Series
# na_action='ignore' skips missing values

map() works on pandas Series (one column).

You can pass a dictionary to replace values, or a function to transform each value.

Examples

Replace 'cat' with 'kitten' and 'dog' with 'puppy'. 'bird' stays the same (becomes NaN).

Pandas

import pandas as pd
s = pd.Series(['cat', 'dog', 'bird'])
mapped = s.map({'cat': 'kitten', 'dog': 'puppy'})

Multiply each number by 10 using a function.

Pandas

s = pd.Series([1, 2, 3])
mapped = s.map(lambda x: x * 10)

Convert text to uppercase but keep None as is.

Pandas

s = pd.Series(['apple', None, 'banana'])
mapped = s.map(str.upper, na_action='ignore')

Sample Program

This program changes fruit names to their colors using map(). Fruits not in the map become NaN.

Pandas

import pandas as pd

# Create a simple data column
fruits = pd.Series(['apple', 'banana', 'cherry', 'date'])

# Map fruit names to colors
color_map = {'apple': 'red', 'banana': 'yellow', 'cherry': 'red'}

# Use map to replace fruit names with colors
fruit_colors = fruits.map(color_map)

print(fruit_colors)

Important Notes

If a value is not in the dictionary, map() returns NaN for that value.

Use na_action='ignore' to keep missing values unchanged when using a function.

Summary

map() changes each item in a pandas Series one by one.

You can use a dictionary or a function with map().

It is useful for replacing or transforming data quickly.

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