Slicing in depth

You have used items[0] to get one element. A slice gets a stretch of them: the first three, the last two, every other one, the whole thing backwards. Slices work the same way on lists, strings, tuples and ranges, and once the rule clicks you will stop reaching for loops to do these jobs.

The slice rule

seq[start:stop:step] takes the items from start up to, but not including, stop, moving by step. This is the same half-open rule as range. Every part is optional.

letters = ["a", "b", "c", "d", "e", "f"]

print(letters[1:4])
print(letters[:2], letters[4:])
print(letters[::2])

['b', 'c', 'd']
['a', 'b'] ['e', 'f']
['a', 'c', 'e']

• Leave out start and it begins at the start (or the end, when the step is negative).
• Leave out stop and it runs to the end (or to the beginning, for a negative step).
• Leave out step and it is 1.

Think of the indexes as sitting between the items. In letters[1:4], index 1 is the gap before "b" and index 4 the gap before "e", so you get b, c, d. A handy consequence is that letters[:k] and letters[k:] split the list at k into two parts with nothing lost or repeated.

Negative indexes and steps

Negative numbers count from the end: -1 is the last item, -2 the one before. So letters[-2:] is “the last two” and letters[:-2] is “everything except the last two”. A negative step walks backwards, and [::-1] is the standard way to reverse a sequence.

letters = ["a", "b", "c", "d", "e", "f"]

print(letters[-2:], letters[:-2])
print(letters[::-1])
print(letters[4:1:-1])

['e', 'f'] ['a', 'b', 'c', 'd']
['f', 'e', 'd', 'c', 'b', 'a']
['e', 'd', 'c']

When going backwards, start should be the larger index: letters[4:1:-1] gives e, d, c, stopping before index 1.

If you only need to walk a sequence backwards in a loop, reversed(letters) does it without building a copy. The slice [::-1] is for when you want the reversed sequence itself.

Slices are forgiving. Out-of-range bounds are clipped rather than raising IndexError, so a slice past the end is just empty. A single index like letters[10] is not so lenient.

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[10:20])
print(letters[4:100])

[]
['e', 'f']

Strings, tuples and copies

Strings and tuples slice too, and give back a string or a tuple.

text = "Python"
print(text[1:4], text[::-1])
print((10, 20, 30, 40)[1:3])

yth nohtyP
(20, 30)

A slice of a list is a new list, which is why letters[:] is a common way to copy one. Remember that it is a shallow copy, as the lists lesson showed.

letters = ["a", "b", "c"]
copy = letters[:]
copy[0] = "z"
print(letters[0], copy[0])

a z

A slice can also be named with the built-in slice(start, stop, step) and reused:

letters = ["a", "b", "c", "d", "e", "f"]
middle = slice(1, -1)
print(letters[middle])

['b', 'c', 'd', 'e']

Slice assignment

Lists, being mutable, let you assign to a slice and change several items at once. With a plain slice (no step), the replacement can be any length, so the list grows or shrinks to fit.

nums = [0, 1, 2, 3, 4, 5]
nums[1:3] = [10, 20, 30]
print(nums)

[0, 10, 20, 30, 3, 4, 5]

Two items became three. del nums[1:3] deletes a stretch, and assigning to an empty slice such as nums[2:2] inserts without removing anything.

nums = ["w", 10, "x", 30, "y"]
del nums[1:3]
print(nums)
nums[2:2] = ["new"]
print(nums)

['w', 30, 'y']
['w', 30, 'new', 'y']

With an extended slice (a step other than 1), the sizes must match exactly:

nums = [0, 1, 2, 3, 4, 5]
nums[::2] = ["a", "b", "c"]
print(nums)

['a', 1, 'b', 3, 'c', 5]

A replacement of the wrong size gives a ValueError:

nums = [0, 1, 2, 3, 4, 5]
nums[::2] = [1]

ValueError: attempt to assign sequence of size 1 to extended slice of size 3

Common pitfalls

• Forgetting that stop is excluded. items[0:3] has three items, indexes 0 to 2.
• Reversing with a wrong start. items[1:5:-1] is empty because it walks backwards from a smaller index. Use items[::-1] or put the larger index first.
• Thinking a = b[:] is a deep copy. It copies one level. Nested lists are still shared.
• Expecting slice errors on bad bounds. Slices clip silently, which can hide an off-by-one mistake. Single indexes raise IndexError.
• Trying to assign into a string slice. text[0:2] = "ab" raises TypeError, because strings are immutable.

word = "abcdefgh"
print(word[2:5])
print(word[-3:])
print(word[::3])
print(word[6:1:-2])

cde
fgh
adg
gec

[3, 4, 5, 1, 2]
[4, 5, 1, 2, 3]
[3, 4, 5, 1, 2]
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

data = [1, 2, 3, 4, 5]

k = 2
print(data[k:] + data[:k])
print(data[-k:] + data[:-k])

k = 7 % len(data)
print(data[k:] + data[:k])

print(data[::-1])
print(data)

data[:] = data[::-1]
print(data)

[3, 4, 5, 1, 2]
[4, 5, 1, 2, 3]
[3, 4, 5, 1, 2]
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

items = [1, 2, 3, 4, 5, 6, 7]
size = 3

for start in range(0, len(items), size):
    print(items[start : start + size])

[1, 2, 3]
[4, 5, 6]
[7]

Summary

• seq[start:stop:step] excludes stop, accepts negative numbers, and clips out-of-range bounds.
• seq[::-1] reverses, reversed(seq) walks backwards in a loop, and seq[:] makes a shallow copy of a list.
• Assigning to a list slice can replace, insert or delete. An extended slice needs a replacement of equal size.

Next: comprehensions.