map() for element-wise transformation in Pandas - Mini Project: Build & Apply

Using map() for Element-wise Transformation in pandas

📖 Scenario: You work in a small bookstore. You have a list of books with their genres. You want to create a new column that shows a short code for each genre to make your data easier to read.

🎯 Goal: Build a pandas DataFrame with book titles and genres, then use map() to create a new column with genre codes.

📋 What You'll Learn

Create a pandas DataFrame called books with columns 'Title' and 'Genre' using the exact data provided.

Create a dictionary called genre_codes that maps each genre to its short code.

Use the map() function on the 'Genre' column to create a new column called 'GenreCode'.

Print the books DataFrame to show the new column.

💡 Why This Matters

🌍 Real World

Mapping long or complex category names to short codes helps in reports, dashboards, and data storage.

💼 Career

Data analysts and scientists often use map() to clean and prepare data for analysis or visualization.

1

Create the books DataFrame

Create a pandas DataFrame called books with two columns: 'Title' and 'Genre'. Use these exact entries: 'The Hobbit' with 'Fantasy', '1984' with 'Dystopian', 'To Kill a Mockingbird' with 'Classic', 'The Great Gatsby' with 'Classic', and 'Brave New World' with 'Dystopian'.

Pandas

import pandas as pd
# Create the books DataFrame with the exact titles and genres
# Your code here

Hint

Use pd.DataFrame with a dictionary where keys are column names and values are lists of data.

2

Create the genre_codes dictionary

Create a dictionary called genre_codes that maps the genres to short codes exactly as follows: 'Fantasy' to 'FAN', 'Dystopian' to 'DYS', and 'Classic' to 'CLA'.

Pandas

import pandas as pd
books = pd.DataFrame({
    'Title': ['The Hobbit', '1984', 'To Kill a Mockingbird', 'The Great Gatsby', 'Brave New World'],
    'Genre': ['Fantasy', 'Dystopian', 'Classic', 'Classic', 'Dystopian']
})
# Create the genre_codes dictionary mapping genres to codes
# Your code here

Hint

Use curly braces {} to create a dictionary with the exact key-value pairs.

3

Use map() to create the GenreCode column

Use the map() function on the 'Genre' column of the books DataFrame with the genre_codes dictionary to create a new column called 'GenreCode'.

Pandas

import pandas as pd
books = pd.DataFrame({
    'Title': ['The Hobbit', '1984', 'To Kill a Mockingbird', 'The Great Gatsby', 'Brave New World'],
    'Genre': ['Fantasy', 'Dystopian', 'Classic', 'Classic', 'Dystopian']
})
genre_codes = {
    'Fantasy': 'FAN',
    'Dystopian': 'DYS',
    'Classic': 'CLA'
}
# Use map() on the 'Genre' column to create 'GenreCode'
# Your code here

Hint

Use books['Genre'].map(genre_codes) to transform the genres into codes.

4

Print the books DataFrame

Print the books DataFrame to display the new 'GenreCode' column alongside the original data.

Pandas

import pandas as pd
books = pd.DataFrame({
    'Title': ['The Hobbit', '1984', 'To Kill a Mockingbird', 'The Great Gatsby', 'Brave New World'],
    'Genre': ['Fantasy', 'Dystopian', 'Classic', 'Classic', 'Dystopian']
})
genre_codes = {
    'Fantasy': 'FAN',
    'Dystopian': 'DYS',
    'Classic': 'CLA'
}
books['GenreCode'] = books['Genre'].map(genre_codes)
# Print the books DataFrame
# Your code here

Hint

Use print(books) to show the DataFrame with the new column.

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