Python Slice Object: Syntax and Usage

The Python slice object is created by the slice() built-in function and by the extended slice syntax inside square brackets. It represents a range of indices with optional start, stop, and step values. Many developers use slicing daily without ever touching the underlying object, but understanding it becomes essential when you need to pass slice definitions around, implement custom sequence types, or normalize index ranges for complex data structures.

How Slice Objects Are Created

The most common way to create a slice object is through the colon syntax in subscription expressions:

seq = [10, 20, 30, 40, 50]
part = seq[1:4]   # equivalent to seq[slice(1, 4)]

The expression seq[1:4] internally creates a slice object with start=1, stop=4, and step=None. You can also call slice() directly:

s = slice(1, 4)
print(s.start, s.stop, s.step)  # 1 4 None

All three parameters are optional. If you omit start, it defaults to None, which the sequence interprets as the beginning. Similarly, stop=None means the end, and step=None means 1. The slice object stores these raw values without resolving them against a specific sequence length.

Attributes and the indices() Method

Every slice object has three public attributes: start, stop, and step. These attributes are read-only and reflect the values passed to the constructor. For example:

s = slice(2, 8, 2)
print(s.start, s.stop, s.step)  # 2 8 2

A slice object also provides the indices(length) method, which is crucial for custom sequence implementations. It normalizes the slice to a concrete range of non-negative integers for a sequence of a given length. The method returns a tuple (start, stop, step) where start and stop are clamped to valid bounds and step is never zero.

s = slice(-3, None, 2)
print(s.indices(10))  # (7, 10, 2)

Here, -3 becomes 7 because the sequence has 10 elements, and None for stop becomes 10. The indices() method is the same logic that list slicing uses internally. If you implement a custom sequence, calling indices() on the received slice object is the safest way to iterate over the selected elements.

Using Slice Objects in Custom Sequence Classes

When you define a class that supports indexing, __getitem__ may receive either an integer or a slice object. Distinguishing between them is the first step:

class LogFile:
    def __init__(self, lines):
        self._lines = lines

    def __getitem__(self, key):
        if isinstance(key, slice):
            start, stop, step = key.indices(len(self._lines))
            return [self._lines[i] for i in range(start, stop, step)]
        elif isinstance(key, int):
            return self._lines[key]
        else:
            raise TypeError("Invalid index type")

This pattern is common in data structures that wrap a list or another sequence. By using indices(), you avoid reimplementing negative-index handling and bounds clamping. The same approach works for __setitem__ and __delitem__ when you want to support slice assignment or deletion.

Practical Patterns: Reusable Slices and Slice Assignment

A slice object can be stored in a variable and reused across multiple sequences. This is useful when the same index range appears repeatedly in your code:

middle = slice(1, -1)

numbers = [1, 2, 3, 4, 5]
print(numbers[middle])  # [2, 3, 4]

letters = ['a', 'b', 'c', 'd']
print(letters[middle])  # ['b', 'c']

The slice object captures the intent, and the actual indices are resolved per sequence. This reduces duplication and makes the code more readable when the slice definition is nontrivial.

Slice assignment uses a slice object on the left side of an assignment. It replaces the selected elements with the elements from the right-hand side:

items = [1, 2, 3, 4, 5]
items[1:4] = [20, 30]
print(items)  # [1, 20, 30, 5]

The right-hand side must be an iterable. The length of the replacement can differ from the slice length, which changes the size of the list. This behavior is defined by the sequence type, not by the slice object itself.

Performance and Memory Considerations

Creating a slice object is a lightweight operation. It stores three references and does not copy any data. The cost of slicing a list is dominated by the copy of the selected elements, not by the slice object creation. For large sequences, slicing creates a new list with the same size as the slice, which can be memory-intensive. If you only need to iterate over a range without storing it, consider using itertools.islice or a manual loop instead of creating a slice.

The indices() method performs a small amount of arithmetic and does not depend on the sequence length beyond the provided argument. Calling it repeatedly in a loop is fine, but you can compute the tuple once and reuse it if you need to access the same slice multiple times on the same sequence.

Common Pitfalls and Edge Cases

A slice with step=0 raises ValueError at creation time:

slice(1, 5, 0)  # ValueError: slice step cannot be zero

This is a deliberate guard because a zero step would cause an infinite loop in iteration. Negative steps are allowed and reverse the traversal. When using negative steps, the default values for start and stop are different: start=None becomes the last index, and stop=None becomes the sentinel before the beginning. The indices() method handles this correctly.

Empty slices are valid. For example, slice(5, 2) on a list returns an empty list because the start is greater than the stop with a positive step. The slice object itself does not know whether it will produce an empty result; that depends on the sequence length and the step direction.

Slice objects compare equal if their start, stop, and step attributes are equal. They are hashable, so you can use them as dictionary keys, though this is rarely needed.

Advanced Usage: Combining Slices and Library Integration

Some libraries, notably NumPy, use slice objects directly for array indexing. In NumPy, arr[1:10:2] passes a slice object to the array's __getitem__. The same slice object can be applied to multiple arrays of the same shape, which is useful for extracting matching subarrays. The slice object is also used in the operator module's itemgetter to create callables that extract a slice from any sequence:

from operator import itemgetter

mid_three = itemgetter(slice(2, 5))
print(mid_three([1, 2, 3, 4, 5, 6]))  # [3, 4, 5]

This pattern is handy when you need to pass a reusable extraction function to a higher-order function like map or sorted. The slice object remains the underlying mechanism, and understanding its attributes and indices() method lets you predict behavior across different sequence types.

When you implement a custom sequence, always delegate to indices() rather than trying to manually adjust negative indices. This keeps your code consistent with built-in sequences and avoids subtle off-by-one errors. The slice object is a small but fundamental part of Python's data model, and using it explicitly gives you precise control over index ranges without scattering magic numbers through your code.