Working with Sequences in Python

A Boundary That Matters

A list slice looks small, but its boundaries control exactly which elements are selected. In the expression t[start:stop], the start index is included and the stop index is excluded. That single rule lets you select a precise portion of a list and is also the basis for changing several list elements at once.

Mapping Boundaries to Elements

For t[1:3], Python starts at index 1, takes the element there, then continues through index 2. It stops before index 3. With t equal to ['a', 'b', 'c', 'd', 'e', 'f'], the result is ['b', 'c']. The stop value is a boundary rather than an included position.

Shortcuts for List Portions

The start and stop indices are optional. Writing t[:n] selects the first n elements, because the slice begins at the start of the list and stops before index n. Writing t[n:] selects the elements from index n onward. Writing t[:] selects the entire list and creates a copy of it.

t = ['a', 'b', 'c', 'd', 'e', 'f'] first_three = t[:3] from_index_three = t[3:] whole_copy = t[:]

first_three = ['a', 'b', 'c']
from_index_three = ['d', 'e', 'f']
whole_copy = ['a', 'b', 'c', 'd', 'e', 'f']

Replacing a Slice

A slice can appear on the left side of an assignment. The form t[start:stop] = new_list replaces every element in the selected slice with the elements of new_list. This modifies the original list in place. Elements outside the selected slice remain unchanged, while the list can grow or shrink if the replacement has a different length.

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

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

The original slice contains two elements, but the replacement contains three. Therefore, the list grows from six elements to seven. If the replacement list were shorter than the selected slice, the list would shrink instead.

Extending the Mental Model

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

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

Mistakes Beginners Make

• Including the stop index in the result

  The stop index is excluded, so index 3 and the value at that position are not selected.

  Fix: Treat t[1:3] as the range containing indices 1 and 2.

• Confusing t[:n] with t[n:]

  The first form selects the first n elements, while the second starts at index n and continues onward.

  Fix: Use t[:n] for the beginning portion and t[n:] for the portion beginning at index n.

• Assuming slice assignment must preserve list length

  The replacement contains three elements while the selected slice contains two.

  Fix: Compare the replacement length with the selected slice length. A longer replacement grows the list, and a shorter replacement shrinks it.

• Forgetting that slice assignment modifies the original list

  Slice assignment replaces elements in the original list in place.

  Fix: Expect t itself to contain the replacement values after the assignment.

Predict Before Running

t = ['a', 'b', 'c', 'd', 'e', 'f'] print(t[1:4]) print(t[:2]) print(t[4:]) print(t[::2]) t[2:4] = ['x'] print(t)

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

The final check confirms both parts of the mental model: t[2:4] selects indices 2 and 3, and replacing two elements with one causes the list to shrink. Prediction is useful because it exposes an incorrect boundary assumption before that assumption causes a harder debugging problem.

Key Takeaways

1. In t[start:stop], start is included and stop is excluded.
2. t[:n] selects the first n elements, t[n:] selects from index n onward, and t[:] creates a copy of the entire list.
3. Slice assignment replaces multiple elements in the original list.
4. A replacement sequence can make the list grow or shrink when its length differs from the selected slice.
5. The full form t[start:stop:step] supports skipped elements, including reverse selection with a negative step.