What is the difference between list.append() and list.extend() in Python?

### What a list actually holds A CPython list is a sequence of pointers to objects. It never contains values “inline” — it contains references. Both `append` and `extend` add references to the end of that sequence; the only question is *how many* and *to what*. ### append: exactly one more element `list.append(obj)` stores one additional reference, to `obj` itself, whatever `obj` is. The list grows by exactly one, and `len(lst)` goes up by one, every time, regardless of the argument: ```python a = [1, 2] a.append([3, 4]) # one new element, which happens to be a list assert a == [1, 2, [3, 4]] assert len(a) == 3 assert a[2][0] == 3 ``` Note that `a[2]` **is** the same object that was passed in — no copy is made. Mutating `a[2]` afterwards is visible through both names. ### extend: one element per item of an iterable `list.extend(iterable)` iterates its argument and appends every item it yields. The list grows by however many items the iterable produced — zero for an empty one, `k` for a `k`-item sequence, and possibly a very large number for a generator: ```python b = [1, 2] b.extend([3, 4]) # two new elements assert b == [1, 2, 3, 4] b.extend(x * x for x in range(3)) assert b == [1, 2, 3, 4, 0, 1, 4] ``` Because the parameter is *any* iterable, the two classic surprises are strings and dicts. A `str` is an iterable of one-character strings, so `lst.extend("hi")` appends `'h'` and `'i'` rather than `"hi"`; a `dict` iterates its keys, so `lst.extend({"a": 1})` appends `"a"`. Neither raises — the data is simply wrong downstream. `append` has no such trap: it never looks inside its argument. ### The operators `lst += other` is the in-place form and is defined in terms of `extend`, so it accepts any iterable and mutates the existing object. `lst = lst + other` is different in two ways: it builds a brand-new list and rebinds the name, and `+` on a list requires another list on the right — `[1, 2] + "xy"` raises `TypeError`. Inside a function that received a list as an argument this distinction decides whether the caller sees the change: `+=` mutates the caller's list, `+` leaves it alone. ### Both return None Every mutating list method — `append`, `extend`, `insert`, `remove`, `reverse`, `clear` — returns `None` by deliberate design, to signal “I changed the object rather than producing a new one”. That rules out chaining: `lst.append(1).append(2)` fails with `AttributeError: 'NoneType' object has no attribute 'append'`, and `new = old.append(x)` binds `None` — an extremely common beginner bug. When you want a new list, use `old + [x]` or a comprehension. ### Cost, and which to reach for Both are cheap. `append` adds one reference; `extend` adds `k` references and costs O(k) — the work is proportional to what you are adding, not to what is already in the list. Between the two, the rule is a data-shape rule and not a performance rule: **append when you have one more item; extend when you have a batch of items.** Writing a `for` loop that calls `append` once per item of another sequence is not wrong, but `extend` expresses it in one call and does the whole loop inside the interpreter's C code, so it is meaningfully faster for large batches. One readability note: `extend` also documents intent. `results.extend(page)` says “splice this page of records into the running list”, while `results.append(page)` says “record this page as one unit”. Choosing the wrong one produces a list whose nesting depth is off by one, and the failure usually surfaces far away — in a consumer that iterates the result and gets lists where it expected records.