Left join behavior in Pandas - Step-by-Step Execution

Concept Flow - Left join behavior

Start with Left DataFrame

↓

Match keys with Right DataFrame

↓

If match found

→Combine rows

↓

If no match

→Fill right columns with NaN

↓

Result: Left join DataFrame

Left join keeps all rows from the left table and adds matching rows from the right table. If no match, right side is filled with missing values.

Execution Sample

Pandas

import pandas as pd
left = pd.DataFrame({'key': ['A', 'B', 'C'], 'left_val': [1, 2, 3]})
right = pd.DataFrame({'key': ['B', 'C', 'D'], 'right_val': [4, 5, 6]})
result = pd.merge(left, right, on='key', how='left')
print(result)

This code merges two tables on 'key' using a left join, keeping all left rows and adding matching right rows.

Execution Table

Step	Left Row Key	Right Match Found?	Action	Result Row
1	A	No	Keep left row, fill right with NaN	{'key': 'A', 'left_val': 1, 'right_val': null}
2	B	Yes	Combine left and right rows	{'key': 'B', 'left_val': 2, 'right_val': 4}
3	C	Yes	Combine left and right rows	{'key': 'C', 'left_val': 3, 'right_val': 5}
4	End	-	All left rows processed	Result has 3 rows

💡 All rows from left DataFrame processed; left join complete.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
result	Empty	[{'A',1,null}]	[{'A',1,null}, {'B',2,4}]	[{'A',1,null}, {'B',2,4}, {'C',3,5}]	[{'A',1,null}, {'B',2,4}, {'C',3,5}]

Key Moments - 2 Insights

Why does the row with key 'A' have NaN in the right_val column?

Because there is no matching key 'A' in the right DataFrame, left join keeps the left row and fills right columns with NaN as shown in execution_table step 1.

What happens to rows in the right DataFrame that do not match any left key?

They are ignored in a left join. For example, key 'D' in right DataFrame is not in left, so it does not appear in the result.

Visual Quiz - 3 Questions

Look at the execution table, what is the 'right_val' for the left key 'B' after step 2?

A 4

B NaN

C 2

D 5

💡 Hint

Check the 'Result Row' column for step 2 in the execution_table.

At which step does the left join fill right columns with NaN?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look for 'fill right with NaN' in the 'Action' column of execution_table.

If the right DataFrame had a matching key 'A', how would the result change at step 1?

A The right_val would be NaN

B The row would be dropped

C The right_val would have the matching value from right DataFrame

D The left_val would become NaN

💡 Hint

Consider how left join combines rows when a match is found, as shown in steps 2 and 3.

Concept Snapshot

Left join keeps all rows from the left table.
It adds matching rows from the right table based on key.
If no match, right columns are filled with NaN.
Syntax: pd.merge(left, right, on='key', how='left')
Useful to keep all left data and add info from right.

Full Transcript

This visual execution shows how a left join works in pandas. We start with two DataFrames, left and right, each with a key column. The left join keeps every row from the left DataFrame. For each left row, it looks for matching keys in the right DataFrame. If a match is found, it combines the rows. If not, it keeps the left row and fills right columns with NaN. The execution table traces each left row step-by-step, showing when matches occur and when NaNs appear. The variable tracker shows how the result DataFrame grows after each step. Key moments clarify why unmatched rows have NaN and what happens to unmatched right rows. The quiz tests understanding of these steps. This helps beginners see exactly how left join merges data visually and clearly.

Practice

1. What does a left join do in pandas when merging two DataFrames?

easy

A. Removes all rows that do not have matches in either DataFrame.

B. Keeps all rows from the left DataFrame and adds matching rows from the right DataFrame.

C. Keeps all rows from the right DataFrame and adds matching rows from the left DataFrame.

D. Keeps only rows that match in both DataFrames.

Solution

1. Step 1: Understand left join behavior

   A left join keeps all rows from the left DataFrame regardless of matches.

2. Step 2: Check how matching rows are added

   Matching rows from the right DataFrame are added; unmatched right rows are ignored.

3. Final Answer:

   Keeps all rows from the left DataFrame and adds matching rows from the right DataFrame. -> Option B

4. Quick Check:

   Left join = all left rows + matching right rows [OK]

Hint: Left join keeps all left rows, adds matching right rows [OK]

Common Mistakes:

• Confusing left join with inner join
• Thinking unmatched right rows appear in output
• Mixing up left and right join behavior

2. Which of the following is the correct syntax to perform a left join of DataFrames df1 and df2 on column 'id' in pandas?

easy

A. pd.merge(df1, df2, on='id', how='left')

B. pd.merge(df1, df2, on='id', how='inner')

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

D. pd.concat([df1, df2], join='left')

Solution

1. Step 1: Identify correct merge function and parameters

   Use pd.merge with 'on' for join column and 'how="left"' for left join.

2. Step 2: Check each option's correctness

   pd.merge(df1, df2, on='id', how='left') uses correct function and parameters; others use wrong join type or method.

3. Final Answer:

   pd.merge(df1, df2, on='id', how='left') -> Option A

4. Quick Check:

   Left join syntax = pd.merge(..., how='left') [OK]

Hint: Use pd.merge with how='left' for left join [OK]

Common Mistakes:

• Using how='inner' instead of 'left'
• Using pd.concat instead of pd.merge
• Confusing join methods like right join

3. Given these DataFrames:

df1 = pd.DataFrame({'id': [1, 2, 3], 'val1': ['A', 'B', 'C']})
df2 = pd.DataFrame({'id': [2, 3, 4], 'val2': ['X', 'Y', 'Z']})

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

medium

A. [{'id':1,'val1':'A','val2':NaN},{'id':2,'val1':'B','val2':'X'},{'id':3,'val1':'C','val2':'Y'}]

B. [{'id':2,'val1':'B','val2':'X'},{'id':3,'val1':'C','val2':'Y'},{'id':4,'val1':NaN,'val2':'Z'}]

C. [{'id':1,'val1':'A','val2':'X'},{'id':2,'val1':'B','val2':'Y'},{'id':3,'val1':'C','val2':'Z'}]

D. [{'id':1,'val1':'A','val2':'Z'},{'id':2,'val1':'B','val2':'X'},{'id':3,'val1':'C','val2':'Y'}]

Solution

1. Step 1: Identify left join behavior on 'id'

   All rows from df1 (ids 1,2,3) appear; matching df2 rows added.

2. Step 2: Match rows and fill unmatched with NaN

   id=1 has no match in df2, so val2 is NaN; id=2 and 3 match with val2 'X' and 'Y'.

3. Final Answer:

   [{'id':1,'val1':'A','val2':NaN},{'id':2,'val1':'B','val2':'X'},{'id':3,'val1':'C','val2':'Y'}] -> Option A

4. Quick Check:

   Left join keeps all left rows, unmatched right columns = NaN [OK]

Hint: Left join keeps all left rows; unmatched right columns become NaN [OK]

Common Mistakes:

• Including rows from right DataFrame not in left
• Filling unmatched right columns with wrong values
• Confusing left join with inner join output

4. You wrote this code:

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

but got an error: KeyError: 'id'. What is the likely cause?

medium

A. The DataFrames have different lengths.

B. You used 'how="left"' instead of 'how="inner"'.

C. You forgot to import pandas as pd.

D. The 'id' column is missing in one or both DataFrames.

Solution

1. Step 1: Understand KeyError meaning

   KeyError means the specified column 'id' does not exist in one or both DataFrames.

2. Step 2: Check other options for relevance

   Join type or import issues cause different errors; DataFrame length does not cause KeyError.

3. Final Answer:

   The 'id' column is missing in one or both DataFrames. -> Option D

4. Quick Check:

   KeyError 'id' = missing column [OK]

Hint: KeyError on column means column missing in DataFrame [OK]

Common Mistakes:

• Assuming join type causes KeyError
• Ignoring import errors
• Thinking DataFrame length affects merge keys

5. You have two DataFrames:

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

You perform pd.merge(df1, df2, on='key', how='left'). How many rows will the result have?

hard

A. 5

B. 4

C. 6

D. 3

Solution

1. Step 1: Count rows in left DataFrame

   df1 has 4 rows with keys [1, 2, 2, 3].

2. Step 2: Understand left join with duplicate keys

   Each df1 row matches all df2 rows with the same key. Key=2 appears twice in df1 and twice in df2, creating 2x2=4 rows for key=2.

3. Step 3: Calculate total rows

   Key=1 and key=3 have no matches, so they remain as single rows with NaN for val2. Total rows = 1 (key=1) + 4 (key=2 matches) + 1 (key=3) = 6.

4. Final Answer:

   6 -> Option C

5. Quick Check:

   Duplicates multiply rows in left join [OK]

Hint: Duplicates in keys multiply rows in left join output [OK]

Common Mistakes:

• Ignoring duplicate keys causing row multiplication
• Counting only unique keys instead of rows
• Assuming unmatched keys are dropped