Fix AttributeError: 'DataFrame' object has no attribute 'append'

Your pandas code worked for years, you upgraded, and now:

AttributeError: 'DataFrame' object has no attribute 'append'

Nothing is wrong with your DataFrame. The method is simply gone: DataFrame.append() and Series.append() were deprecated in pandas 1.4 and removed in pandas 2.0. Any df.append(...) call now raises this AttributeError.

The one-line fix is pd.concat. But there's a bigger trap most guides walk you straight into: if you were appending inside a loop, swapping in pd.concat keeps the same quadratic slowness that made append a bad idea in the first place. This guide fixes both — correctly.

Quick Answer

You're on pandas 2.0+, which removed DataFrame.append(). Replace df.append(df2) with pd.concat([df, df2], ignore_index=True). If you were appending in a loop, don't just swap in pd.concat (still O(n²)) — collect rows as dicts in a Python list and build the DataFrame once with pd.DataFrame(rows).

TL;DR

• Pandas 2.0 removed DataFrame.append() / Series.append().
• One frame: pd.concat([df, df2], ignore_index=True).
• In a loop: collect dicts in a list → pd.DataFrame(rows) (O(n)).
• pd.concat in a loop is still O(n²) — don't do it.
• list.append() still works — only the DataFrame method went away.
• Add ignore_index=True to get append's old fresh index.

The Direct Replacement

Wherever you called .append() on a DataFrame or Series, use pd.concat with a list of objects:

import pandas as pd
 
# ❌ removed in pandas 2.0
combined = df.append(df2)
 
# ✅ pandas 2.0+
combined = pd.concat([df, df2], ignore_index=True)

• pd.concat([...]) takes a list — that's how you pass two or more frames.
• ignore_index=True rebuilds a clean 0..n-1 index, matching append's common behavior. Leave it off and you keep the original indices (which can duplicate).

Appending a single row

The old single-row append({...}, ignore_index=True) becomes a concat with a one-row frame:

# ❌ old
df = df.append({"name": "Ada", "score": 95}, ignore_index=True)
 
# ✅ new
new_row = pd.DataFrame([{"name": "Ada", "score": 95}])
df = pd.concat([df, new_row], ignore_index=True)

This works, but if you're doing it repeatedly, read the next section — there's a much faster pattern.

The Real Trap: Appending in a Loop

Here's what most "just use concat" answers miss. Both append and pd.concat create a new DataFrame every call — they copy all existing rows. Inside a loop, that's quadratic:

# ❌ O(n²) — copies the whole growing DataFrame every iteration
df = pd.DataFrame()
for record in records:
    df = pd.concat([df, pd.DataFrame([record])], ignore_index=True)

For 10,000 rows this copies tens of millions of rows in total. The fix is to build the DataFrame once, after collecting rows in a plain list:

# ✅ O(n) — collect dicts, build once
rows = []
for record in records:
    rows.append({"name": record.name, "score": record.score})
 
df = pd.DataFrame(rows)      # single construction

• rows.append(...) is a cheap list.append — no copying.
• pd.DataFrame(rows) builds the frame in one pass at the end.

Concatenating many frames

If you genuinely have many DataFrames (e.g. one per file), collect them in a list and concat once — not in the loop:

frames = [pd.read_csv(f) for f in files]   # list of DataFrames
df = pd.concat(frames, ignore_index=True)  # single concat

Version Check and Timeline

Confirm what you're on and why it changed:

import pandas as pd
print(pd.__version__)     # 2.x → append is gone; 1.x → append still (deprecated)

Edge Cases

Mismatched columns

pd.concat aligns by column name, just like append did. Missing columns become NaN:

a = pd.DataFrame({"x": [1]})
b = pd.DataFrame({"y": [2]})
pd.concat([a, b], ignore_index=True)
#      x    y
# 0  1.0  NaN
# 1  NaN  2.0

If you expect identical columns, validate them before concatenating.

Concatenating along columns

append only added rows. For side-by-side (column) joins, use axis=1 (or a proper merge):

pd.concat([df_left, df_right], axis=1)   # add columns, align on index

Keeping a downgrade temporary

If you must ship today, pip install "pandas<2.0" restores append — but treat it as a stopgap and migrate to pd.concat, since you'll be stuck off security and performance fixes otherwise.

Verification Steps

1. pd.__version__ shows your version; append calls are gone from the code.
2. The previously-failing line now runs with pd.concat.
3. Row counts match: len(result) == len(df) + len(df2).
4. The index is what you expect (ignore_index=True for a clean 0..n-1).
5. Loops build the DataFrame once at the end, not per iteration.

Prevention

• Replace every DataFrame.append / Series.append with pd.concat.
• Never call pd.concat (or append) inside a loop — collect then build once.
• Prefer pd.DataFrame(list_of_dicts) for row accumulation.
• Add ignore_index=True when you want a fresh index.
• Pin a pandas version range in requirements to avoid surprise upgrades.
• Avoid the private _append; it's not a supported API.

Troubleshooting Matrix

Related Guides

• Fix ValueError: too many values to unpack (expected 2)
• Fix ImportError: cannot import name 'Mapping' from 'collections'
• Fix ModuleNotFoundError: No module named 'dotenv'
• Fix TypeError: Object of type datetime is not JSON serializable
• Migrating a codebase to pandas 2.0

External References

• pandas — What's new in 2.0.0 (removals)
• pandas — pd.concat
• pandas — DataFrame constructor
• pandas — Merge, join, concatenate

FAQs

Is pd.concat slower than the old append? For a single call, they're comparable — both copy. The performance win comes from how often you call it: once at the end (fast) versus every loop iteration (slow). The removal nudged people toward the once-at-the-end pattern.

Do I need ignore_index=True every time? Only when you want a fresh 0..n-1 index. If the existing indices are meaningful and unique, leave it off. If they'd collide or you don't care, add it — it's the safest default when stacking rows.

Can I append a dict directly like before? Not with a method call. Wrap it: pd.concat([df, pd.DataFrame([the_dict])], ignore_index=True). Better, collect dicts in a list and do one pd.DataFrame(list_of_dicts).

What about Series.append? Removed as well. Use pd.concat([s1, s2]) for Series. The same list-then-concat guidance applies if you're building a Series incrementally.

Why was append removed at all? It encouraged the quadratic row-by-row pattern and duplicated pd.concat's functionality with subtly different behavior. Removing it simplified the API and steered users toward the faster approach.