Why does list.sort() return None?

list.sort() sorts the list in place and deliberately returns None to signal that it mutated the object rather than producing a new one. This is a Python convention for in-place methods. A common bug is writing items = items.sort(), which assigns None; to get a sorted copy use sorted(items), which returns a new list and leaves the original unchanged.

What is the difference between append and extend?

append(x) adds its single argument as one new element at the end, so appending a list nests it. extend(iterable) iterates its argument and adds each element individually, so extending with a list concatenates. lst.append([1,2]) gives [..., [1,2]] while lst.extend([1,2]) gives [..., 1, 2].

What is the difference between remove and pop?

remove(value) deletes the first element equal to value and returns None, raising ValueError if the value is absent. pop(index=-1) removes the element at the given index, defaulting to the last, and returns that element. Use remove when you know the value, pop when you know the position or want the removed item back.

How do I copy a list?

list.copy() returns a shallow copy — a new list whose elements are the same objects. The same effect comes from list(original) or original[:]. A shallow copy is independent at the top level but shares nested mutable objects, so changing a nested list affects both copies. Use copy.deepcopy for a fully independent clone.

Is this the complete list of list methods?

Yes. Python's list type has a small, fixed set of methods — append, extend, insert, remove, pop, clear, index, count, sort, reverse, and copy — all of which are listed here with their mutation behavior. Built-in functions like len, sorted, and reversed operate on lists but are not list methods; see the Built-in Functions reference for those.

Python List Methods Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Python’s list is a mutable sequence with a small, fixed set of methods. The key thing to know is which ones mutate in place (and return None) versus which ones return a value. This is a searchable offline reference.

How it works

Each method is flagged as in-place or returns a value:

In-place, returns None — append, extend, insert, remove, sort, reverse, clear. These change the list itself; assigning their result (x = x.sort()) is a classic bug that stores None.
Returns a value — pop returns the removed element, index returns a position, count returns a tally, copy returns a new list.

The single most common mistake is items = items.sort(). Use items.sort() to sort in place, or sorted(items) for a new sorted list.

append vs extend

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

b = [1, 2]
b.extend([3, 4])   # b -> [1, 2, 3, 4]      (concatenated)

Notes

sort and reverse mutate in place and return None; their non-mutating counterparts are the built-ins sorted() and reversed().
pop() with no argument removes and returns the last element; pop(0) removes the first (which is O(n) — prefer collections.deque for queues).
copy() is a shallow copy — nested mutable objects are shared.
This reference covers all standard list methods; len, sorted, reversed are built-in functions, not list methods.