Python Lists: How to Create, Index, Append, Sort, and Iterate

Lists Are Ordered, Mutable Sequences

The list is the single most-used collection type in Python. If you're keeping an ordered set of values that might change — add, remove, sort, update — a list is almost always the right choice.

You create one with square brackets:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

Lists can hold anything, even other lists. In practice, most lists end up holding one kind of thing — a list of users, a list of numbers — because that's what's easiest to reason about.

Indexing

Each item has a position, starting at 0. Access with square brackets:

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

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry' — negative indexes count from the end
print(fruits[-2])   # 'banana'

Asking for an index that doesn't exist raises IndexError. If you might be out of range, either check the length first or wrap the access in a try.

Slicing

Slicing gives you a range of items. The syntax is list[start:stop:step], same as strings:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2] — from the start
print(nums[7:])       # [7, 8, 9] — to the end
print(nums[::2])      # [0, 2, 4, 6, 8] — every other item
print(nums[::-1])     # reversed copy

Two things worth locking in:

• Slicing always returns a new list. Modifying the slice doesn't affect the original.
• The stop index is exclusive — nums[2:5] gives indices 2, 3, and 4, not 5.

How to Append, Extend, and Insert Items

The three "adding to a list" methods do different things, and mixing them up is a common source of bugs:

items = ["a", "b", "c"]

items.append("d")       # add ONE item to the end
items.insert(0, "z")    # insert ONE item at a specific index
items.extend(["e", "f"])  # add EACH item from another iterable

print(items)

• append(x) adds x as a single element — even if x is a list. items.append([1, 2]) adds the list itself as one entry.
• extend(iterable) adds each item from the iterable. items.extend([1, 2]) adds two entries.
• insert(i, x) inserts at a specific index, shifting everything at or after i one position to the right.

+= with a list on the right works like extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

And for removing:

items = ["a", "b", "c", "b", "d"]

items.remove("b")       # removes the first occurrence of "b"
print(items)

last = items.pop()      # removes and returns the last item
print(last, items)

second = items.pop(0)   # remove and return the item at index 0
print(second, items)

If you try to remove() something that isn't in the list, Python raises ValueError. If you need "remove if present," either check in first or use a try.

You can also delete by index with del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

Length, Membership, Counting

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4 — index of the first 23

in is the readable way to check whether a list contains a value. If you'll be asking that question many times over a large list, use a set instead — set membership is O(1) where list membership is O(n).

Sorting

Two ways, and the choice matters:

nums = [5, 2, 9, 1, 7]

# In place — modifies the list, returns None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# Returns a new sorted list, leaves the original alone.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

Both accept reverse=True for descending order:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

And a key function for custom ordering:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

key is applied to each item, and the result is what gets compared. Common cases: sorting by length, by a specific attribute, or by the lowercase form of a string.

Reversing

Three flavours, depending on what you need:

items = [1, 2, 3, 4]

# In place — modifies the list, returns None.
items.reverse()
print(items)

# Slicing — returns a new reversed list.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed() — returns a lazy iterator.
for n in reversed([1, 2, 3, 4]):
    print(n)

Use in-place when you don't need the original. Use slicing when you want a new copy. Use reversed() when you just need to iterate in reverse without materializing a new list.

The Shared-Reference Trap

Lists are mutable, and variables are references. That means two variables can point at the same list:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4] — a changed too!

b = a didn't copy the list; it made b a second name for the same list. If you want a copy, ask for one:

a = [1, 2, 3]
b = a.copy()   # or list(a), or a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

This bites every Python programmer at least once. Remember: = between two lists doesn't copy.

Looping and Building

You already know the basic pattern from the for loop page:

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

That's readable and will always be fine. Once you're comfortable, the list comprehension equivalent does the same thing in one line:

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

We'll cover comprehensions in detail two pages from now.

A Quick Cheat Sheet

Methods worth knowing, at a glance:

• append(x) — add to end
• extend(iter) — add each item from an iterable
• insert(i, x) — insert at index i
• pop() / pop(i) — remove and return
• remove(x) — remove first occurrence of x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x) — position of first x
• count(x) — number of x's
• copy() — shallow copy

Up Next

Lists are the workhorse. Next we'll look at tuples — their immutable cousin — and when reaching for a tuple instead is the better call.