How Does List Slicing Work?

List slicing works exactly like string slicing: text[start:stop:step], with the stop index excluded and the step controlling the direction and spacing.

items = [0, 1, 2, 3, 4, 5]

print(items[1:4])      # [1, 2, 3]
print(items[:3])       # [0, 1, 2]
print(items[::2])      # [0, 2, 4]
print(items[::-1])     # [5, 4, 3, 2, 1, 0]
print(items[-2:])      # [4, 5]

# A slice always produces a NEW list
copy = items[:]
copy.append(99)
print(items)           # [0, 1, 2, 3, 4, 5] - unchanged
print(copy is items)   # False

The reversal by items[::-1] and the last-two-elements slice by items[-2:] both work because a negative step starts from the end and negative indices count backwards from the end.

The copy semantics at the bottom are the important part for interviews. A slice always builds a new list, so items[:] is an independent shallow copy. Mutating it does not affect the original, and the two are different objects.

But it is a shallow copy. If the list contains mutable objects, those inner objects are still shared between the original and the copy. For a list of lists, items[:] gives you new outer list but the same inner lists. If you need a genuinely independent structure, use copy.deepcopy.

One more thing worth knowing is that you can also assign to a slice, and the lengths do not have to match. Assigning a shorter list to a slice replaces those positions and removes the extras, while assigning a longer one inserts the extra items. That behaviour is occasionally useful, but it is also a classic source of accidental data loss, so slice assignment deserves the same care as slice indexing.

The two operations look symmetric and behave completely differently. items[1] = 5 changes the existing list in place. items[1:2] = [5] also changes the existing list, but it replaces a whole run of positions and can change the length. And items[1:2] on the right-hand side of an expression produces a brand new list that shares nothing with the original.

The reason the right-hand slice is a copy is that a slice expression has to produce a sequence of the requested length, and there is no way to hand back a view into the middle of a list in Python. Python lists are contiguous arrays of pointers, not something like a NumPy array where a slice can be a view onto the same buffer. So the interpreter allocates a new list and copies the references across. The cost is linear in the number of elements copied.

The shallow-versus-deep distinction then follows from the fact that only the references are copied. The new list has its own slots, but the objects those slots point at are the same objects. For a list of lists, slicing copies the outer structure and shares the inner lists, so mutating an inner list is visible through both. copy.deepcopy is the way to get a fully independent structure.

For an interview, the useful summary is that slicing is the idiomatic way to copy a flat list — items[:] or list(items) — but it is only a shallow copy, and for nested data you need copy.deepcopy or a rebuild from immutable pieces.