append() vs extend() in Python

append adds exactly one item to the end of the list. extend adds every element of the argument, one at a time. That single difference is the whole story.

a = [1, 2]
a.append([3, 4])
print(a)              # [1, 2, [3, 4]] - one new element

b = [1, 2]
b.extend([3, 4])
print(b)              # [1, 2, 3, 4] - the items are added

c = [1, 2]
c.append("hi")
print(c)              # [1, 2, 'hi']

d = [1, 2]
d.extend("hi")
print(d)              # [1, 2, 'h', 'i']

The last two lines are the ones to explain. extend takes any iterable, and a string is an iterable of single characters, so extending with a string adds each letter as its own element. It is a common surprise, and the fix is to wrap the string in a list — d.extend(["hi"]) — or to use append when you want the string as a single item.

The nested-list case in the first two lines is worth dwelling on too. Appending a list gives you a list inside a list, which is often not what someone writing a.append(other_list) intends. When you want to copy the contents, extend is right; when you want to build a structure of lists, a list of lists is right, but then you should be explicit about it.

The performance note: extend with a list is more efficient than appending in a loop, because it copies the elements in one operation rather than reallocating the list's storage repeatedly.

Because a string is an iterable of characters, extend unpacks it and adds each character separately.

items = [1, 2]
items.extend("abc")
print(items)              # [1, 2, 'a', 'b', 'c']

# Add the string as a single item instead
items = [1, 2]
items.append("abc")
print(items)              # [1, 2, 'abc']

# Or wrap it in a list before extending
items = [1, 2]
items.extend(["abc"])
print(items)              # [1, 2, 'abc']

The three versions give three different results, and only the first is usually a bug. Extending with a string is almost never what the author wanted — they wanted one new element that happens to be a string.

The mechanism is that extend takes an iterable, and the rule for every other iterable is the same. Extending with a tuple of three numbers adds three numbers; extending with a set adds its elements in an arbitrary order; extending with a generator consumes it and adds each item it produces.

Two ways to avoid the surprise. Type-check the argument before extending, or use a clearer method name in your own code — a function called add_all versus append_one makes the intent obvious at the call site. And if the input might be a string, normalise it first: items.extend([value] if isinstance(value, str) else value).

All four add to a list, and they differ in what they add and in how they are spelled.

append(item) adds exactly one object at the end. extend(iterable) adds each element of an iterable at the end. insert(index, item) adds one object at a given position, shifting the rest along. And += on a list is the same operation as extend — it mutates the list in place with the elements of the right-hand iterable.

The trap is the += operator, and it has two separate hazards. The first is the type confusion: items += "abc" adds three characters rather than one string, exactly like extend, which surprises people who expect += to behave like a simple addition. The second is subtler. The augmented assignment first tries the in-place operation, and if that fails it falls back to rebinding the name. So a += b on a list mutates the list in place, while a += b on a tuple rebinds the name to a new tuple, because a tuple has no in-place version of the operation. Two lines that look identical can therefore behave completely differently depending on the type of the name.

For an interview, the safe summary is: use append for one item, extend for a known collection of items, insert when the position matters, and prefer explicit method calls over += when the element type might vary — because the explicit version tells the reader exactly what happened.