What is pandas explode() method in Python?

pandas is a powerful library for data manipulation and analysis in Python. Among its plethora of functions and methods, explode() stands out as a handy tool for dealing with nested or list-like structures within DataFrame columns. Let's explore what explode() does and how it can be effectively utilized.

What is the explode() method?

The explode() method in pandas transforms a column containing lists (or other iterable-like structures) into multiple rows, duplicating the index values. This is particularly useful when dealing with data that has nested lists or arrays within a single DataFrame column.

Syntax

The syntax for the explode() method with DataFrame is as follows:

DataFrame.explode(column, ignore_index=False)

Parameters

  • column: Specifies the name of the column to explode.

  • ignore_index: If True, the resulting DataFrame will have a new RangeIndex, ignoring the original index. The default is False.

A RangeIndex is a type of index in pandas that represents a range of integer values, typically starting from 0 and incrementing by 1 for each row. It is the default index type for a DataFrame when one isn't explicitly specified.

Here's the range of the ignore_index parameter as described in the documentation:

  • True: If set to True, the resulting index will be labeled 0, 1, ..., n - 1, where n is the number of rows in the resulting DataFrame. In other words, a new RangeIndex will be generated for the resulting DataFrame, starting from 0 and incrementing by 1 for each row.

  • False: If set to False (the default), the resulting DataFrame will retain the original index values from the input DataFrame.

Setting ignore_index to True is useful when you want to reset the row indexes of the resulting DataFrame to a sequential range, especially after operations like exploding a column containing lists. This ensures that the resulting DataFrame has a clean and ordered sequence of indexes starting from 0.

Code example: explode()

Here is a coding example of transforming a column containing a list into multiple rows using the explode() method in pandas:

import pandas as pd
# Creating a DataFrame with a column containing lists
data = {'ID': [1, 2, 3],
        'Items': [['A', 'B'], ['C'], ['D', 'E', 'F']]}
df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)
# Exploding the 'Items' column
df_exploded = df.explode('Items')
print("\nDataFrame after exploding 'Items' column:")
print(df_exploded)
# Exploding the 'Items' column with ignore_index=True
df_exploded_ignore_index = df.explode('Items', ignore_index=True)
print("\nDataFrame after exploding 'Items' column with ignore_index=True:")
print(df_exploded_ignore_index)

Explanation

  • Line 1: We import the pandas library as pd.

  • Lines 4–6: We create a DataFrame df using dictionary data containing two keys 'ID' and 'Items', with corresponding lists as values.

  • Line 8: We print the original DataFrame df.

  • Line 11: We use the explode() method on the DataFrame df with the column name 'Items'. This method expands the lists in the 'Items' column into multiple rows, duplicating the index values accordingly.

  • Line 13: We print the DataFrame df_exploded after the explosion.

  • Line 17: We set the ignore_index parameter to True to ensure that the resulting DataFrame has a new RangeIndex, ignoring the original index values.

  • Line 19: We print the DataFrame df_exploded_ignore_index after the explosion with ignore_index.

Multi-column explode

In addition to exploding a single column containing lists or other iterable-like structures, pandas also supports exploding multiple columns simultaneously. This feature is particularly useful when you have multiple columns with nested or list-like structures that you want to expand into separate rows while maintaining relationships across these columns.

Syntax

The syntax for multi-column explode is similar to that of single-column explode, with the addition of specifying multiple columns to explode:

DataFrame.explode(column_list, ignore_index=False)

Parameters

  • column_list: Specifies a list of column names to explode. pandas will expand each specified column's iterable-like structures into separate rows while keeping the relationships between the exploded columns intact.

  • ignore_index: (Optional) If True, the resulting DataFrame will have a new RangeIndex, ignoring the original index. The default is False.

Here's an example demonstrating multi-column explode:

import pandas as pd
# Creating a DataFrame with multiple columns containing lists
data = {'ID': [1, 2, 3],
        'Items_1': [['A', 'B'], ['C'], ['D', 'E', 'F']],
        'Items_2': [['X', 'Y'], ['Z'], ['W', 'V', 'U']]}
df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)
# Exploding the 'Items_1' and 'Items_2' columns simultaneously
df_exploded_multi = df.explode(['Items_1', 'Items_2'])
print("\nDataFrame after multi-column explode:")
print(df_exploded_multi)

Explanation

  • Lines 4–6: Here, we define a dictionary data containing three keys: 'ID', 'Items_1', and 'Items_2'. Each key corresponds to a list of values. The lists under 'Items_1' and 'Items_2' represent the nested or list-like structures we want to explode.

  • Line 8: This line creates a DataFrame df using the dictionary data we defined earlier. The DataFrame has three columns: 'ID', 'Items_1', and 'Items_2', with corresponding data from the data dictionary.

  • Lines 9–10: These lines simply print out the original DataFrame df to the console, showing the structure and content of the DataFrame before performing any operations.

  • Line 13: Here, we use the explode() method on the DataFrame df to explode both columns 'Items_1' and 'Items_2' simultaneously. This operation creates separate rows for each item in both columns while maintaining the relationship between the items across these columns.

  • Lines 14–15: These lines print out the DataFrame df_exploded_multi after the multi-column explode operation. It displays the result of exploding both 'Items_1' and 'Items_2' columns into separate rows, allowing us to see the expanded DataFrame.

Conclusion

The explode() method in pandas offers a convenient way to deal with nested or list-like data structures within DataFrame columns. Whether it's flattening nested data, unpacking lists, or expanding one-to-many relationships, understanding how to leverage explode() effectively can greatly enhance your data manipulation workflows.

Free Resources

Copyright ©2026 Educative, Inc. All rights reserved