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.

What is the Python List Methods Reference?

Searchable reference for all Python list methods — append, extend, insert, remove, pop, sort, reverse — showing each method's signature, return value, and whether it mutates the list in place. It runs free in your browser on Gera Tools, with nothing uploaded.

Python List Methods Reference

Name: Python List Methods Reference
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

Get one useful tool a week

Like this tool? Enter your email and we'll send you one genuinely useful Gera tool a week — plus a link to come back to this one. No spam, one-click 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.

Complete method table

Method	Signature	Returns	Mutates?
`append`	`append(x)`	`None`	Yes
`extend`	`extend(iterable)`	`None`	Yes
`insert`	`insert(i, x)`	`None`	Yes
`remove`	`remove(x)`	`None`	Yes
`pop`	`pop(index=-1)`	removed element	Yes
`clear`	`clear()`	`None`	Yes
`sort`	`sort(*, key=None, reverse=False)`	`None`	Yes
`reverse`	`reverse()`	`None`	Yes
`index`	`index(x, start, end)`	`int` position	No
`count`	`count(x)`	`int` tally	No
`copy`	`copy()`	new `list`	No

In-place vs returns-a-value: the core distinction

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)

remove vs pop

remove(value) deletes the first occurrence of a value by equality — it raises ValueError if the value is absent. pop(index) deletes and returns the element at a given index, defaulting to the last element.

items = [10, 20, 30, 20]
items.remove(20)   # items -> [10, 30, 20]  (first 20 removed, no return value)

val = items.pop(0)  # val = 10, items -> [30, 20]

Sorting: key and reverse

list.sort() sorts in place using the natural ordering. Use key to sort by a derived value, and reverse=True for descending order:

words = ["banana", "apple", "cherry"]
words.sort(key=len)         # -> ['apple', 'banana', 'cherry']  (by length)
words.sort(reverse=True)    # -> ['cherry', 'banana', 'apple']

sorted(items) does the same but returns a new list and leaves the original unchanged.

Notes

pop(0) removes the first element but is O(n) — prefer collections.deque for FIFO queues.
copy() is a shallow copy — nested mutable objects are shared between original and copy; use copy.deepcopy for a fully independent clone.
len, sorted, reversed, min, max are built-in functions, not list methods.
list.sort() is guaranteed stable in Python 3 — equal elements keep their original relative order.