Lists and List Operations

When you work with lists, tuples, or strings, you often need to extract a portion of the sequence rather than the whole thing. Slicing is the operation that lets you do this. Instead of accessing a single element by its index, slicing lets you specify a range of elements and get them all at once as a new sequence. The key insight is that slicing always returns a new sequence—it does not modify the original, and it does not create a reference to it.

Slicing uses the syntax sequence[start:stop:step]. The start index is where the slice begins (inclusive), the stop index is where it ends (exclusive), and the step determines how many positions to jump between selected elements. If you omit any of these parameters, Python uses sensible defaults: start defaults to 0, stop defaults to the length of the sequence, and step defaults to 1.

The most important rule to remember about slicing is that the start index is inclusive but the stop index is exclusive. This means if you write list[1:4], you get elements at indices 1, 2, and 3—but not 4. This boundary rule is consistent across all sequence types in Python.

In the diagram above, the list contains five fruits at indices 0 through 4. When you slice with [1:4], the start boundary (1) is inclusive, so 'banana' at index 1 is included. The stop boundary (4) is exclusive, so 'elderberry' at index 4 is not included. The result is a new list containing only 'banana', 'cherry', and 'date'.

Python allows you to use negative indices in slices, just as you can with single-element indexing. A negative index counts backward from the end of the sequence: -1 refers to the last element, -2 to the second-to-last, and so on. When you use negative indices in a slice, they follow the same inclusive-start, exclusive-stop rule as positive indices.

In the diagram, you can see that each element has two valid index labels. For a five-element list, index -3 is the same as index 2, index -2 is the same as index 3, and so on. When you write list[-3:-1], you are asking for elements starting at index -3 (inclusive) and ending at index -1 (exclusive). That gives you 'cherry' and 'date', the same result as list[2:4].

The third parameter in a slice is the step value. It controls how many positions to skip between selected elements. A step of 1 (the default) selects every element in the range. A step of 2 selects every other element, a step of 3 selects every third element, and so on. You can also use a negative step to traverse the sequence backward.

The diagram traces through list[1:5:2] on a five-element list. Starting at index 1, Python selects 'banana'. Then it jumps forward by the step value (2 positions), landing at index 3, and selects 'date'. The next jump would land at index 5, which is the stop boundary, so the slice ends. The result is a new list containing ['banana', 'date'].

A critical fact about slicing is that it always returns a new sequence. When you slice a list, you get a brand-new list object. This is different from simple assignment: if you write new_list = old_list, both variables refer to the same list object in memory, and changes to one will affect the other. But if you write new_list = old_list[:], you get a completely independent copy.

This behavior applies to all sequence types. Slicing a tuple returns a new tuple, slicing a string returns a new string, and slicing a list returns a new list. The original sequence is never modified, and the new sequence is completely independent.

One of the elegant features of Python is that slicing works the same way on lists, tuples, and strings. The syntax is identical, the boundary rules are identical, and the step parameter works the same way. The only difference is the type of object you get back: slice a list and you get a list, slice a tuple and you get a tuple, slice a string and you get a string.

When you need to create a copy of a list or other sequence, always use slicing. The most straightforward way is to use the full-range slice [:], which selects the entire sequence and returns a new copy. This works for lists, tuples, and strings, and it makes your intent clear to anyone reading your code.

The slicing approach is simple, readable, and works consistently across all sequence types. It is the Pythonic way to copy sequences and is widely used in real Python code.