What Can Lists Do in Python?

A list is an ordered, mutable sequence, and its method set covers everything you normally need to do with a collection.

items = ["apple", "banana", "cherry"]

items.append("date")        # add one item to the end
items.insert(0, "first")    # insert at a position
items.remove("banana")      # remove the first matching value
print(items)                 # ['first', 'apple', 'cherry', 'date']

print(items.index("cherry"))    # 2 - the position
print("date" in items)           # True - membership

items.sort()
print(items)                 # ['apple', 'cherry', 'date', 'first']
items.reverse()
print(items)                 # ['first', 'date', 'cherry', 'apple']
print(len(items))             # 4

The order of the calls matters for the output. After append and insert the list is first, apple, banana, cherry, date; removing banana leaves first, apple, cherry, date, so index reports cherry at position 2.

Two methods that raise rather than return a default are worth knowing. remove raises ValueError if the value is not present, and index raises ValueError too. The list.index lookup and the value scan behind remove are both linear in the length of the list, which is why membership tests on a long list should use a set instead.

Two more behaviours to know. sort and reverse modify the list in place and return None, so you must not write result = items.sort() expecting a sorted list. And list.pop removes and returns an element, defaulting to the last one, so items.pop() both shortens the list and hands you the removed value — useful as a stack operation.

List items are addressed by position, counting from zero, and negative positions count from the end.

numbers = [10, 20, 30]

print(numbers[0], numbers[-1])     # 10 30

numbers[1] = 25                     # change an item in place
print(numbers)                      # [10, 25, 30]

try:
    print(numbers[10])
except IndexError as err:
    print("IndexError:", err)

# A slice never raises, it just stops
print(numbers[1:10])                 # [25, 30]

Indexing past the end raises IndexError with the message list index out of range, and the error handler catches it. The last line is the contrast worth emphasising: the slice numbers[1:10] on a three-element list is perfectly legal and returns the two elements that exist. Slices clamp to the available data, single-index access does not.

Assigning to a position changes the list in place, because lists are mutable. The new value can be of any type, so a Python list can hold a mixture of ints, strings and objects — which is convenient and also means you cannot assume a homogeneous list unless you enforce it with type hints.

Two more details. The last index is len(items) - 1, and Python does not support negative index arithmetic like items[-1] meaning the last element in other languages — here it does mean the last element, which is the convention. And inserting or removing an item in the middle of a list is O(n) because every following element has to shift, which is one of the reasons a deque is preferred for a queue or a stack with heavy insertions.

Mutable means the contents can be changed after the list exists — items can be added, removed or replaced without creating a new list. Sequence means the items are in a defined order and are addressed by position, and that the list supports the sequence protocol: len, indexing, slicing and iteration.

That combination is what makes a list the default choice for a collection that will change, and what distinguishes it from a tuple, which is ordered and indexable but immutable.

The complexity picture is what an interviewer is really probing. The constant-time operations are index access, assignment to an existing index, len, append, pop from the end, and membership checks against a set. The linear-time operations are insert and remove in the middle, because everything after the changed position has to shift; index and count, which scan until they find a match; the in operator on a list, which scans the whole list; and sort, which is O(n log n) comparisons.

Two practical consequences. If you need repeated membership tests, build a set from the list once — lookup becomes O(1) instead of O(n). And if you need heavy insertion and removal at both ends, a collections.deque is the right structure, because it is optimised for exactly that.

One more detail that surprises people: list multiplication repeats the references, not the values. So [[]] * 3 gives three references to the same inner list, and appending to one of them changes all three. To build three separate lists you need a comprehension such as [[] for _ in range(3)].