Indexing Lists with the Index Operator

A Slice Is a Range of Positions

A list slice extracts a portion of a list by specifying a start position and a stop position. The syntax is t[start:stop]. The start index belongs to the selected portion, but the stop index does not. This start-included, stop-excluded rule lets you describe exactly where a selection begins and where it ends.

Tracing t[1:3]

t = ['a', 'b', 'c', 'd', 'e']
selected = t[1:3]
print(selected)

['b', 'c']

Omitted Slice Boundaries

A slice does not require both boundary indices. If the start is omitted, the slice begins at the beginning of the list. If the stop is omitted, the slice continues from the given start index onward. If both are omitted, t[:] creates a copy of the entire list.

t = ['a', 'b', 'c', 'd', 'e']
print(t[:3])
print(t[3:])
print(t[:])

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

Replacing a Slice In Place

Slice assignment uses the form t[start:stop] = new_list. Instead of extracting elements, this operation replaces the selected slice in the original list. For example, t[1:3] selects the elements at indices 1 and 2, so assigning ['x', 'y'] replaces those two elements while the other elements remain unchanged.

t = ['a', 'b', 'c', 'd'] t[1:3] = ['x', 'y'] print(t)

When the List Changes Size

The replacement list does not have to be the same length as the slice being replaced. A longer replacement makes the original list grow, while a shorter replacement makes it shrink. In t[1:3] = ['x', 'y', 'z'], two selected elements are replaced by three elements, so the list gains one element. Elements after the replaced slice shift to make room.

t = ['a', 'b', 'c', 'd', 'e', 'f']
t[1:3] = ['x', 'y', 'z']
print(t)

['a', 'x', 'y', 'z', 'd', 'e', 'f']

Steps Beyond the Basic Slice

The full slice syntax is t[start:stop:step]. If step is omitted, it defaults to 1, so every element in the selected range is included. A step of 2 selects every other element, and a step of 3 selects every third element. A negative step reverses the selection.

t = ['a', 'b', 'c', 'd', 'e', 'f']
print(t[0:6:2])

['a', 'c', 'e']

Common Slice Mistakes

• Including the stop index in the result

  The stop index is excluded. The slice includes indices 1 and 2 only.

  Fix: Read the expression as starting at index 1 and ending immediately before index 3.

• Treating t[:n] as including index n

  t[:n] selects the first n elements, which are the positions before index n.

  Fix: For t[:3], count positions 0, 1, and 2.

• Assuming slice assignment must preserve list length

  The replacement has three elements, while the selected slice has two.

  Fix: Compare the replacement length with the selected slice length. A longer replacement grows the list.

• Forgetting that slice assignment modifies the original list

  Slice assignment replaces elements in the original list.

  Fix: Inspect the list after the assignment; elements outside the slice remain, while selected elements are replaced.

Predict Before Running

t = ['a', 'b', 'c', 'd', 'e']
print(t[1:3])

Slice Checklist

1. Write the slice as start, stop, and optional step.
2. Identify the element at the start index, if a start is present.
3. Stop immediately before the stop index, if a stop is present.
4. If a boundary is omitted, apply the corresponding beginning or end shortcut.
5. For slice assignment, count the selected elements and compare that count with the replacement list.
6. Predict the result before running the code, then execute the code to verify the prediction.