Pandas: Insert a row to a specific position in a DataFrame (3 ways)

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


Handling datasets in Python is often synonymous with using the Pandas library. A common task when manipulating data is inserting a new row into an existing DataFrame at a specific position. This tutorial will guide you through multiple approaches to achieve this, ranging from basic to more advanced methods. Understanding how to insert rows dynamically can be crucial in data preprocessing, feature engineering, or even when dynamically updating datasets based on real-time data.


Before we dive into the examples, make sure you have Python and Pandas installed in your environment:

pip install pandas

Creating a Simple DataFrame

Let’s start by creating a DataFrame we will be working with throughout this tutorial:

import pandas as pd

data = {
    "Name": ["John", "Jane", "Doe"],
    "Age": [28, 34, 23],
    "Profession": ["Developer", "Designer", "Manager"],
df = pd.DataFrame(data)

This prints:

   Name  Age Profession
0  John   28  Developer
1  Jane   34  Designer
2  Doe    23  Manager

Method 1: Using pd.concat()

The pd.concat() function is one of the most straightforward methods to insert a row at a specific position. The idea is to split the DataFrame into two parts: before and after the target position, and then concatenate the new row in between.

Here’s how you can achieve it:

new_row = pd.DataFrame({'Name': ['Alice'], 'Age': [30], 'Profession': ['Scientist']})
target_index = 1
df1 = df.iloc[:target_index]
df2 = df.iloc[target_index:]
df_final = pd.concat([df1, new_row, df2]).reset_index(drop=True)

This results in:

    Name  Age Profession
0   John   28  Developer
1  Alice   30  Scientist
2   Jane   34  Designer
3   Doe    23  Manager

Method 2: Using DataFrame.append() and DataFrame.loc

Another approach involves the DataFrame.append() method in combination with DataFrame.loc for reindexing. This method is slightly more complex but offers more control.


new_row = pd.DataFrame({'Name': ['Bob'], 'Age': [26], 'Profession': ['Trader']}, index=[1.5])
df = df.append(new_row, ignore_index=False)
df = df.sort_index().reset_index(drop=True)

This sorts the DataFrame by index and then resets the index, effectively inserting the new row in the correct position:

    Name  Age Profession
0   John   28  Developer
1   Bob    26  Trader
2   Alice  30  Scientist
3   Jane   34  Designer
4   Doe    23  Manager

Method 3: Modifying the DataFrame In-Place

For those looking for an even more direct approach, modifying the DataFrame in-place might be the solution. This involves directly manipulating the DataFrame's indices and values. This method requires careful handling to avoid errors.


target_index = 2
df_tmp = df[:target_index]
df_tmp.loc[target_index] = ['Charlie', 29, 'Entrepreneur']
df = pd.concat([df_tmp, df[target_index:]]).reset_index(drop=True)

This adds a new row at the specified position without creating a new DataFrame:

    Name  Age Profession
0   John   28  Developer
1   Alice  30  Scientist
2 Charlie  29 Entrepreneur
3   Jane   34  Designer
4   Doe    23  Manager

For those needing more precise control over the operation, especially when dealing with large DataFrames, the iloc function can provide an efficient way to manipulate data. This method, however, requires a deep understanding of Pandas indexing.


Inserting a row into a specific position in a DataFrame is a task that can be accomplished through various methods, each with its own set of benefits and drawbacks. Understanding these different approaches allows for more flexible and efficient data manipulation, fitting a wide range of data management scenarios. The choice of method depends largely on the specific requirements of your task and the complexity of your data structure.