Pandas: How to ‘RIGHT JOIN’ 2 DataFrames (with examples)

Updated: February 21, 2024 By: Guest Contributor Post a comment


When working with data in Python, Pandas is a powerhouse library that facilitates data manipulation and analysis. One of the crucial operations when dealing with multiple datasets is joining them based on common identifiers or keys to enrich or merge datasets. While SQL enthusiasts are familiar with terms like INNER JOIN, LEFT JOIN, and RIGHT JOIN, this tutorial focuses on how to perform a RIGHT JOIN between two DataFrames in Pandas.

Before diving into the specifics of a RIGHT JOIN, it’s important to understand the terminology. A RIGHT JOIN operation between two DataFrames means that all rows from the right DataFrame, and any matching rows in the left DataFrame, will be merged together in the result. Where there is no match, the result will have NaN (Not a Number) in the place of missing values from the left DataFrame.

Let’s start with basics and gradually move to more advanced examples to showcase the power of RIGHT JOINs in Pandas.


To begin, let’s perform a simple RIGHT JOIN. First, ensure you have Pandas installed:

pip install pandas

Then, create two sample DataFrames:

import pandas as pd
data1 = { 'id': [1, 2, 3], 'name': ['Alice', 'Bob', 'Charlie'] }
data2 = { 'id': [2, 3, 4], 'city': ['New York', 'Los Angeles', 'Chicago'] }
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)

To perform a RIGHT JOIN, we use the merge() function and specify how='right'. Additionally, we declare the column on which to join:

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

This will output:

   id     name         city
0  2      Bob      New York
1  3     Charlie  Los Angeles
2  4      NaN       Chicago

Notice how all rows from df2 (right DataFrame) are present, and matching ids from df1 are merged. The row with id 4, which does not have a match in df1, is filled with NaN for the name column.

Using RIGHT JOIN with Multiple Keys

In some scenarios, a single key might not be enough to accurately join two datasets. Pandas allows for RIGHT JOINs based on multiple keys for a more precise merge. Here’s how:

import pandas as pd
data1 = { 'id': [1, 2, 3], 'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 35] }
data2 = { 'id': [2, 3, 4], 'city': ['New York', 'Los Angeles', 'Chicago'], 'age': [30, 35, 40] }
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
result = df1.merge(df2, on=['id', 'age'], how='right')


   id     name  age         city
0  2      Bob   30     New York
1  3   Charlie 35  Los Angeles
2  4      NaN   40      Chicago

This example performed a RIGHT JOIN on both the id and age columns. By doing this, it ensures that rows are matched based on both criteria, enhancing the accuracy of the merge.

Handling Missing Data

After performing a RIGHT JOIN, you might have missing data where matches could not be found. Pandas provide several methods to handle such scenarios (e.g., fillna()) efficiently. For instance, to replace NaN values with a placeholder:

result.fillna('Not Available', inplace=True)


   id           name  age         city
0  2            Bob   30     New York
1  3         Charlie  35  Los Angeles
2  4  Not Available   40      Chicago

This method replaces all NaN values with ‘Not Available’, making the data cleaner and easier to understand.

Advanced Usage: Conditional Joins and Filtering

Pandas doesn’t natively support conditional joins like SQL. However, you can achieve similar functionality by first filtering your DataFrames based on your conditions before performing the join. For example, if you wish to RIGHT JOIN only rows where the age is greater than 30:

filtered_df1 = df1[df1['age'] > 30]
result = filtered_df1.merge(df2, on='id', how='right')

Notice how this approach filters df1 for ages greater than 30 before performing the RIGHT JOIN with df2. This pattern can be particularly useful for complex data manipulation tasks.


In conclusion, RIGHT JOINs in Pandas are a powerful method to merge datasets based on common keys, allowing you to enrich and combine your data effectively. Whether dealing with simple or complex data structures, understanding how to properly utilize this functionality can significantly enhance your data analysis projects. Remember, the way you handle missing data and the conditions you apply before joining can profoundly affect your dataset’s outcome and quality.