Pandas DataFrame: How to replicate a row N times

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


In the world of data analysis with Python, Pandas is a cornerstone that provides powerful tools for data manipulation and analysis. An operation frequently needed by data analysts and scientists is the replication of rows within a DataFrame. This can be necessary for various reasons, such as preparing data for statistical tests, oversampling in machine learning, or simply duplicating entries for reporting. This guide walks you through different methods to replicate a row in a Pandas DataFrame multiple times, progressing from simple to more advanced techniques, complete with code examples.

Introduction to DataFrame Row Replication

Before diving deep, let’s first understand what a DataFrame is. A DataFrame is a two-dimensional labeled data structure with columns that can be of different types, similar to a SQL table or a spreadsheet. Replicating a row involves creating copies of the specified row and adding them to the DataFrame. Let’s start with the simplest scenario – replicating a single row a specified number of times.

Basic Row Replication

Assuming you have a Pandas DataFrame df, and you want to replicate the second row (index 1) three times. Here’s a straightforward way to do it:

import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
replicated_df = pd.concat([df.iloc[[1]]]*3, ignore_index=True)

This code will output:

   A  B
0  2  5
1  2  5
2  2  5

This method works well for a simple scenario but starts to falter as complexity increases.

Using loc for More Control

Another way to replicate rows is by using the loc method for a little more control over which rows are replicated. This can be beneficial if you need to replicate multiple specific rows. For instance:

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df_replicated = df.loc[df.index.repeat(3)]


   A  B
0  1  4
1  1  4
2  1  4
3  2  5
4  2  5
5  2  5
6  3  6
7  3  6
8  3  6

Using loc, combined with index.repeat, allows for replication of every row in the DataFrame, providing a neat and flexible way to duplicate rows as needed. This method adds an edge by giving the option to easily fine-tune which rows get replicated and how many times.

Advanced Replication Techniques

Moving on to more advanced techniques, let’s consider replicating rows based on a condition or distributing the replication unevenly across different rows.

Conditional Row Replication

If you wish to replicate rows based on certain conditions, such as a column value exceeding a certain threshold, you can combine the use of boolean indexing with loc and index.repeat.

df = pd.DataFrame({'A': [1, 10, 3], 'B': [4, 50, 6]})
df_replicated = df.loc[df['A'] > 5].index.repeat(3)


    A   B
0  10  50
1  10  50
2  10  50

This example demonstrates how to selectively replicate rows that meet a certain criterion, offering a dynamic approach to row replication based on DataFrame contents.

Uneven Replication based on a List

Perhaps you need each row to be replicated a different number of times. This can be achieved by specifying a list of replication factors corresponding to each row:

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
reps = [1, 3, 2]
df_replicated = pd.DataFrame(pd.NA, index=range(sum(reps)), columns=df.columns)
cur_idx = 0
for i, rep in enumerate(reps):
    df_replicated.iloc[cur_idx:cur_idx+rep] = df.iloc[i]
    cur_idx += rep

Although this method requires more steps, it offers maximum flexibility, allowing for row-specific replication counts.


In this tutorial, we’ve explored various methods to replicate a row in a Pandas DataFrame multiple times, from basic use cases to more complex scenarios involving conditional and uneven replication. Depending on your specific needs, Pandas provides the flexibility to efficiently handle row replication through a combination of methods and functions. Understanding these techniques is a valuable skill for any data analyst or scientist working with Python.