Add Rows to a Pandas DataFrame in Python

You will learn how to add complete rows to a Pandas DataFrame, how .loc and pd.concat() work for this task, and why collecting rows first is usually the fastest design.

A Pandas DataFrame is a two-dimensional table: rows represent records and columns represent fields of each record.

To add a complete row, provide values for every relevant column. For a small, incremental workflow, assign a list or dictionary with .loc:

df.loc[len(df)] = ["A", 10.0, 20.0]

However, repeatedly growing a DataFrame inside a loop is inefficient. DataFrames are designed primarily for analyzing already-collected tabular data. Each expansion may require Pandas to create a larger internal structure and copy existing data.

When many rows are involved, store each row in a normal Python list first, then create one DataFrame at the end. This is both clearer and usually much faster.

Think of a DataFrame as a printed spreadsheet. Adding a line to a small sheet is easy, but repeatedly reprinting the entire sheet every time you add a line becomes wasteful.

A Python list is like a temporary notebook where you quickly write down incoming records. Once you have finished collecting them, you turn the notebook into one clean spreadsheet by creating a DataFrame once.

For a small number of rows, use .loc with the next index.

import pandas as pd

df = pd.DataFrame(columns=["lib", "qty1", "qty2"])

df.loc[len(df)] = ["lib_a", 10.0, 5.0]
df.loc[len(df)] = ["lib_b", 7.5, 12.0]

print(df)

Output:

     lib  qty1  qty2
0  lib_a  10.0   5.0
1  lib_b   7.5  12.0

The list on the right must follow the DataFrame column order.

A dictionary is often safer because each value is explicitly named:

df.loc[len(df)] = {
    "lib": "lib_c",
    "qty1": 3.0,
    "qty2": 8.0,
}

For a batch of rows, use pd.concat():

new_rows = pd.DataFrame([
    {"lib": "lib_d", "qty1": , : },
    {: , : , : },
])

df = pd.concat([df, new_rows], ignore_index=)

Consider this code:

import pandas as pd

df = pd.DataFrame(columns=["lib", "qty1", "qty2"])
row = {"lib": "central", "qty1": 10.0, "qty2": 4.0}

df.loc[len(df)] = row

Step by step:

1. pd.DataFrame(columns=[...]) creates a DataFrame with three named columns and no rows.
2. row is a dictionary containing values for one record.
3. len(df) is 0 because the DataFrame is empty.
4. df.loc[0] selects row index 0. Since it does not exist yet, Pandas creates it.
5. Pandas matches dictionary keys such as "qty1" to DataFrame column names and stores the values.

After the assignment, df contains one row:

       lib  qty1  qty2
0  central  10.0   4.0

Adding rows is useful when a program receives records gradually, such as:

• Reading a small number of form submissions before displaying them in an admin report.
• Recording results from a short API polling job.
• Building a table of validation errors while processing an upload.
• Combining summary records created by separate functions.
• Adding manually entered adjustments to a small inventory table.

For large CSV files, databases, event streams, or API responses with many records, collect or load data in batches rather than extending a DataFrame one row at a time.

In production code, developers commonly avoid mutation of a DataFrame in a long loop. Instead, they use one of these patterns:

Collect dictionaries, then build once

records = []

for item in api_items:
    records.append({
        "lib": item["name"],
        "qty1": item["available"],
        "qty2": item["reserved"],
    })

df = pd.DataFrame(records, columns=["lib", "qty1", "qty2"])

This is the preferred approach when the final number of rows is unknown.

Validate before collecting

records = []

for item in api_items:
    if "name" not in item:
        continue

    records.append({"lib": item["name"], "qty1": 0, "qty2": 0})

The early continue acts as a guard clause: invalid input is skipped before it can create a malformed row.

Combine already-built tables

df = pd.concat([january_df, february_df], ignore_index=)

Using DataFrame.append() in new code

# Do not use in modern Pandas
# df = df.append(new_row, ignore_index=True)

DataFrame.append() was deprecated in Pandas 1.4 and removed in Pandas 2.0. Use pd.concat() or collect records in a list.

Repeatedly concatenating inside a large loop

# Works, but can become slow for many rows
for row in rows:
    df = pd.concat([df, pd.DataFrame([row])], ignore_index=True)

Avoid this when processing many records. Build records first and call pd.DataFrame(records) once.

Supplying list values in the wrong order

df.loc[len(df)] = [10.0, 5.0, "lib_a"]  # Wrong order

Pandas assigns list values by position, not by meaning. Use the exact column order or use a dictionary.

Creating accidental new columns

df.loc[(df), ] =   

Lists and dictionaries also differ when representing a row:

import pandas as pd

columns = ["lib", "qty1", "qty2"]
df = pd.DataFrame(columns=columns)

Add one small row:

df.loc[len(df)] = ["lib_a", 10.0, 5.0]

Add one named row:

df.loc[len(df)] = {"lib": "lib_a", "qty1": 10.0, "qty2": 5.0}

Add a batch:

new_df = pd.DataFrame(records)
df = pd.concat([df, new_df], ignore_index=True)

Preferred for many rows:

records = []
records.append({"lib": "lib_a", "qty1": 10.0, "qty2": 5.0})
df = pd.DataFrame(records, columns=["lib", "qty1", "qty2"])

Rules:

How do I add a row to a Pandas DataFrame?

For a small number of rows, assign it with .loc, such as df.loc[len(df)] = {"name": "Ana", "score": 95}.

What is the best way to add many rows in Pandas?

Append dictionaries or lists to a Python list, then call pd.DataFrame(records) once after the loop.

Why is adding rows one at a time slow in Pandas?

A DataFrame may need to allocate and copy data when it grows. Repeating that work for every row is more expensive than building the table once.

Should I use DataFrame.append()?

No. It was deprecated in Pandas 1.4 and removed in Pandas 2.0. Use pd.concat() or a list of records instead.

Does df.loc[len(df)] always add a new row?

It adds or replaces the row whose label equals len(df). It is reliable for a simple default sequential index, but is less suitable after custom indexing or row deletion.

Can a dictionary omit a DataFrame column when adding a row?

Yes. Columns not supplied generally receive missing values such as NaN. Include all required fields if the row must be complete.

• Pandas DataFrame indexes — explains row labels, .loc, and why sequential indexes matter.
• Pandas Series — a single DataFrame row or column is commonly represented as a Series.
• pd.concat() — combines DataFrames vertically or horizontally.
• Python lists — the preferred temporary container for accumulating many records.
• Python dictionaries — useful for named, readable row data.
• Data cleaning with Pandas — helps validate missing values and column types after creating a table.
• Reading CSV files with Pandas — a common alternative to manually constructing DataFrames.