How to slice a list in Python

1items[start:stop]Recommended

The one rule that trips everyone up: a slice is half-open. It includes start and excludes stop. The upside is that the length of a slice is simply stop - start, and items[:n] plus items[n:] always reassemble the original with no overlap and no gap.

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

print(items[1:4])
print(len(items[1:4]))
print(items[0:2])
print(items[4:1])

Prints ['b', 'c', 'd'], 3, ['a', 'b'], then []. A slice whose start is at or past its stop isn't an error — it's just an empty list.

2Omitting ends and using negative indices

Leave start off and it defaults to the beginning; leave stop off and it defaults to the end. Negative numbers count backwards from the end, which is how you write "the last three" (items[-3:]) and "everything but the last" (items[:-1]) without touching len().

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

print(items[:3])     # first three
print(items[2:])     # index 2 to the end
print(items[-3:])    # last three
print(items[:-1])    # everything but the last
print(items[2:99])   # stop past the end — clamped, no error
print(items[99:])    # start past the end — empty list

try:
    items[99]
except IndexError as exc:
    print("IndexError:", exc)

The last two lines are the contrast worth remembering: items[2:99] quietly clamps and returns ['c', 'd', 'e'], while the plain index items[99] raises IndexError: list index out of range. Slices are forgiving; indexing is not. That's a feature when you want "up to 10 results" from a list that might only hold three — but it also means a typo'd bound fails silently.

3The step argument

The third slot is the step: items[start:stop:step]. A step of 2 takes every other item; a negative step walks the list backwards, which makes items[::-1] the standard one-liner for a reversed copy.

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

print(items[::2])    # every other item
print(items[1::2])   # every other item, starting at index 1
print(items[2:8:3])  # start, stop and step together
print(items[::-1])   # a reversed copy
print(items[::-2])   # backwards, every other item

Output: [0, 2, 4, 6, 8], [1, 3, 5, 7, 9], [2, 5], [9, 8, 7, 6, 5, 4, 3, 2, 1, 0], [9, 7, 5, 3, 1]. Note that [::-1] returns a new reversed list — use items.reverse() if you want to reverse in place instead.

4Slice assignment (and items[:] as a copy)

items[:] read as a value is a shallow copy — a new list holding the same objects. Assigned to, a slice edits the list in place: the replacement doesn't have to be the same length, so one statement can replace, insert, or (with del) delete a run of items.

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

copy = items[:]           # shallow copy — a brand-new list
copy[0] = "z"
print(items, copy)

items[1:3] = ["B", "C", "C2"]   # replace two items with three
print(items)

items[1:1] = ["new"]      # insert without removing anything
print(items)

del items[0:2]            # delete a slice in place
print(items)

The copy ends up ['z', 'b', 'c', 'd', 'e'] while the original stays ['a', ...]. Shallow is the catch: with rows = [[1, 2], [3, 4]], rows[:] gives a new outer list but the inner lists are the same objects, so mutating one shows up in both. Use copy.deepcopy() when that matters. Also note items[:] = [...] is not the same as items = [...]: the first mutates the list every other reference can see, the second just rebinds your name.

5Common slice idioms at a glance

Every row below is real output for items = ["a", "b", "c", "d", "e"]:

6Common variation: islice and slice objects

Slice syntax needs __getitem__, so it doesn't work on generators — squares()[1:5] raises TypeError: 'generator' object is not subscriptable. itertools.islice takes the same start/stop/step arguments and consumes the iterator lazily, so it works on infinite sources. And when the same slice shows up in several places, slice() lets you name it once and reuse it.

from itertools import islice

def squares():
    n = 0
    while True:
        yield n * n
        n += 1

# A generator has no __getitem__, so squares()[1:5] is a TypeError.
print(list(islice(squares(), 1, 5)))
print(list(islice(squares(), 0, 10, 3)))

# A slice object is a named, reusable slice you can pass around.
LAST_THREE = slice(-3, None)
print(["a", "b", "c", "d", "e"][LAST_THREE])
print(LAST_THREE.start, LAST_THREE.stop, LAST_THREE.step)

Prints [1, 4, 9, 16], [0, 9, 36, 81], ['c', 'd', 'e'], then -3 None None. Two limits worth knowing: islice rejects negative indices (it can't see the end of a stream), and it consumes what it skips, so the source iterator has advanced by the time it's done.