Right join behavior in Pandas - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this right join?

Given two DataFrames df1 and df2, what is the result of df1.merge(df2, how='right', on='key')?

Pandas

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'val1': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['B', 'C', 'D'], 'val2': [4, 5, 6]})

result = df1.merge(df2, how='right', on='key')
print(result)

A

  key  val1  val2
0   A   1.0     NaN
1   B   2.0     4
2   D   NaN     6

B

  key  val1  val2
0   A   1.0     NaN
1   B   2.0     4
2   C   3.0     5

C

  key  val1  val2
0   B   2.0     4
1   C   3.0     5
2   D   NaN     6

D

  key  val1  val2
0   B   2.0     4
1   C   3.0     5

💡 Hint

Remember, a right join keeps all rows from the right DataFrame and matches rows from the left.

The right join keeps all keys from df2. Keys 'B', 'C', and 'D' are in df2. For 'D', there is no match in df1, so val1 is NaN.

🧠 Conceptual

intermediate

Which statement best describes a right join?

Choose the correct description of what a right join does in pandas merge.

A Returns all rows from the left DataFrame and matching rows from the right DataFrame.

B Returns all rows from the right DataFrame and matching rows from the left DataFrame.

C Returns only rows that have matching keys in both DataFrames.

D Returns all rows from both DataFrames, filling missing matches with NaN.

💡 Hint

Think about which DataFrame's rows are always kept in a right join.

A right join keeps all rows from the right DataFrame and matches rows from the left DataFrame where keys match. Unmatched left rows are dropped.

📝 Syntax

advanced

Which code correctly performs a right join on columns 'id' and 'code'?

Given two DataFrames df1 and df2, which code snippet correctly performs a right join on columns 'id' and 'code'?

Pandas

import pandas as pd

# df1 and df2 are predefined DataFrames

A df1.merge(df2, how='right', left_on=['id', 'code'], right_on=['id', 'code'])

B df1.merge(df2, how='right', left_on='id', right_on='code')

C df1.merge(df2, how='right', on='id', on='code')

D df1.merge(df2, how='right', on=['id', 'code'])

💡 Hint

Check the correct syntax for joining on multiple columns with the same names.

When joining on multiple columns with the same names in both DataFrames, use on=[...]. Using left_on and right_on is for different column names.

❓ optimization

advanced

How to optimize a right join when the right DataFrame is very large?

You have two DataFrames: df1 (small) and df2 (very large). You want to perform a right join. Which approach optimizes performance?

A Perform a left join with <code>df2</code> as left and <code>df1</code> as right, then rename columns accordingly.

B Perform a right join directly with <code>df1.merge(df2, how='right')</code> without changes.

C Convert both DataFrames to dictionaries and merge manually in Python.

D Sort both DataFrames by join keys before merging.

💡 Hint

Think about which DataFrame should be on the left for better performance.

Left joins are generally faster when the left DataFrame is large. Since df2 is large, making it the left DataFrame and performing a left join is more efficient than a right join.

🔧 Debug

expert

Why does this right join produce unexpected NaNs?

Consider this code:

df1 = pd.DataFrame({'key': ['A', 'B'], 'val1': [1, 2]})
df2 = pd.DataFrame({'key': ['a', 'b', 'c'], 'val2': [3, 4, 5]})
result = df1.merge(df2, how='right', on='key')

Why does result contain NaNs in val1 for all rows?

A Because the keys have different cases ('A' vs 'a'), so no matches occur.

B Because right join only keeps rows from the left DataFrame.

C Because the 'on' parameter is missing in the merge call.

D Because the DataFrames have different column names for the join key.

💡 Hint

Check if the join keys match exactly including case sensitivity.

Join keys are case sensitive. 'A' is not equal to 'a', so no rows match. The right join keeps all rows from df2, but val1 is NaN because no matching keys in df1.

Practice

1. What does a right join do in pandas merge operation?

easy

A. Keeps only rows that match in both dataframes.

B. Keeps all rows from the left dataframe and matches from the right.

C. Keeps all rows from the right dataframe and matches from the left.

D. Keeps all rows from both dataframes, filling missing with NaN.

Solution

1. Step 1: Understand the join direction

   A right join keeps all rows from the right dataframe regardless of matches.

2. Step 2: Understand matching behavior

   It adds matching rows from the left dataframe where possible; unmatched left rows become NaN.

3. Final Answer:

   Keeps all rows from the right dataframe and matches from the left. -> Option C

4. Quick Check:

   Right join = all right rows kept [OK]

Hint: Right join keeps all right rows, fills left missing with NaN [OK]

Common Mistakes:

• Confusing right join with left join
• Thinking right join keeps all left rows
• Assuming only matching rows are kept

2. Which of the following is the correct syntax to perform a right join on two pandas DataFrames df1 and df2 using column 'key'?

easy

A. df1.merge(df2, how='inner', on='key')

B. pd.merge(df1, df2, how='left', on='key')

C. df1.join(df2, how='right', on='key')

D. pd.merge(df1, df2, how='right', on='key')

Solution

1. Step 1: Identify correct merge function and parameters

   Use pd.merge() with how='right' and on='key' to join on the key column.

2. Step 2: Check other options for correctness

   pd.merge(df1, df2, how='left', on='key') uses left join, df1.join(df2, how='right', on='key') uses join method incorrectly with on parameter, pd.merge(df1, df2, how='inner', on='key') uses inner join.

3. Final Answer:

   pd.merge(df1, df2, how='right', on='key') -> Option D

4. Quick Check:

   Right join syntax = pd.merge(..., how='right', on=...) [OK]

Hint: Use pd.merge with how='right' and on='key' for right join [OK]

Common Mistakes:

• Using left join instead of right join
• Using DataFrame.join with on parameter (not supported)
• Forgetting to specify 'how' parameter

3. Given the following DataFrames:

df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'val1': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['B', 'C', 'D'], 'val2': [4, 5, 6]})

What is the result of pd.merge(df1, df2, how='right', on='key')?

medium

A. [{'key': 'B', 'val1': 2, 'val2': 4}, {'key': 'C', 'val1': 3, 'val2': 5}, {'key': 'D', 'val1': NaN, 'val2': 6}]

B. [{'key': 'A', 'val1': 1, 'val2': NaN}, {'key': 'B', 'val1': 2, 'val2': 4}, {'key': 'C', 'val1': 3, 'val2': 5}]

C. [{'key': 'A', 'val1': 1, 'val2': NaN}, {'key': 'B', 'val1': 2, 'val2': 4}, {'key': 'C', 'val1': 3, 'val2': 5}, {'key': 'D', 'val1': NaN, 'val2': 6}]

D. [{'key': 'B', 'val1': 2, 'val2': 4}, {'key': 'C', 'val1': 3, 'val2': 5}]

Solution

1. Step 1: Identify rows kept by right join

   Right join keeps all rows from df2 (keys B, C, D).

2. Step 2: Match df1 rows on key and fill missing

   Keys B and C match with df1, key D has no match so val1 is NaN.

3. Final Answer:

   [{'key': 'B', 'val1': 2, 'val2': 4}, {'key': 'C', 'val1': 3, 'val2': 5}, {'key': 'D', 'val1': NaN, 'val2': 6}] -> Option A

4. Quick Check:

   Right join keeps all right keys, unmatched left = NaN [OK]

Hint: Right join keeps all right keys; unmatched left columns show NaN [OK]

Common Mistakes:

• Expecting all left keys to appear
• Forgetting NaN for missing left matches
• Confusing inner join output with right join

4. You run this code:

pd.merge(df1, df2, how='right', left_on='id', right_on='key')

But get a KeyError: 'id'. What is the likely cause?

medium

A. df1 does not have a column named 'id'.

B. df2 does not have a column named 'key'.

C. You cannot use different column names in left_on and right_on.

D. The 'how' parameter cannot be 'right' with left_on and right_on.

Solution

1. Step 1: Understand KeyError meaning

   KeyError means the specified column is missing in the dataframe.

2. Step 2: Check which dataframe is missing the column

   Since error is 'id', and left_on='id', df1 likely lacks 'id' column.

3. Final Answer:

   df1 does not have a column named 'id'. -> Option A

4. Quick Check:

   KeyError 'id' means missing column in df1 [OK]

Hint: KeyError means missing column in specified dataframe [OK]

Common Mistakes:

• Assuming right_on column missing causes KeyError for left_on
• Thinking different column names can't be used
• Believing 'right' join disallows left_on/right_on

5. You have two DataFrames:

df1 = pd.DataFrame({'key': ['X', 'Y', 'Z'], 'val1': [10, 20, 30]})
df2 = pd.DataFrame({'key': ['Y', 'Z', 'W'], 'val2': [100, 200, 300]})

You want to keep all rows from df2 and add matching val1 from df1. Then fill missing val1 with 0 instead of NaN. Which code achieves this using a right join?

hard

A. pd.merge(df2, df1, how='right', on='key').fillna({'val1': 0})

B. pd.merge(df1, df2, how='right', on='key').fillna({'val1': 0})

C. pd.merge(df1, df2, how='left', on='key').fillna({'val1': 0})

D. pd.merge(df2, df1, how='left', on='key').fillna({'val1': 0})

Solution

1. Step 1: Determine which dataframe is right

   To keep all rows from df2, df2 must be the right dataframe in merge.

2. Step 2: Use right join and fill missing val1

   Use how='right' with on='key' and then fill NaN in val1 with 0.

3. Final Answer:

   pd.merge(df1, df2, how='right', on='key').fillna({'val1': 0}) -> Option B

4. Quick Check:

   Right join with df2 right, fillna val1=0 [OK]

Hint: Right join with df2 right, then fillna val1 with 0 [OK]

Common Mistakes:

• Swapping left and right dataframes incorrectly
• Using left join instead of right join
• Filling NaN before merge