Understanding Python's slice() Function
python slice function: Learn how to use Python's slice() function to create slice objects, apply them to sequences, and implement slicing in custom classes.

The python slice function, slice(), creates a slice object that describes how to extract a portion of a sequence. It is the underlying mechanism behind the familiar seq[start:stop:step] syntax. Understanding it helps you write more flexible code, especially when you need to reuse slicing logic or support slicing in your own classes.
The slice() Built-in Function and Its Parameters
The slice() function takes up to three arguments: start, stop, and step. All three are optional, but you must provide at least one argument. If you pass only one argument, it becomes stop. If you pass two, they become start and stop. The full form is slice(start, stop, step).
s1 = slice(5) # stop = 5
s2 = slice(2, 8) # start = 2, stop = 8
s3 = slice(1, 10, 2) # start = 1, stop = 10, step = 2Each argument can be None, which means the same as omitting it in the bracket syntax. For example, slice(None, 5) is equivalent to [:5], and slice(2, None) is equivalent to [2:]. The step argument defaults to None as well, which Python treats as 1.
The returned slice object has three readable attributes: start, stop, and step. These attributes are useful when you need to inspect or reuse the slice later.
s = slice(1, 10, 2)
print(s.start) # 1
print(s.stop) # 10
print(s.step) # 2Creating Slice Objects and Using Them in Indexing
A slice object can be passed directly to a sequence's indexing operation. This is exactly what Python does when you write seq[start:stop:step]; the interpreter constructs a slice object internally. You can do the same explicitly.
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
my_slice = slice(2, 8, 2)
result = numbers[my_slice]
print(result) # [2, 4, 6]The explicit form is useful when the slice definition is dynamic or needs to be reused. For instance, you might define a slice once and apply it to multiple sequences, or build it from user input.
def extract_middle(seq):
middle = slice(len(seq)//4, 3*len(seq)//4)
return seq[middle]
data = list(range(20))
print(extract_middle(data)) # [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]How Python Resolves start, stop, and step for Sequences
When you apply a slice to a sequence, Python computes the actual indices using the sequence's length. The rules follow the same logic as the bracket syntax:
startdefaults to 0 ifstepis positive, or tolen(seq) - 1ifstepis negative.stopdefaults tolen(seq)for positive step, or to-len(seq) - 1for negative step.- Negative indices are treated as offsets from the end:
-1refers to the last element. - Out-of-range indices are clamped to the sequence boundaries.
For example, slice(None, None, -1) reverses the sequence because it starts at the last element and moves backward to the first.
letters = ['a', 'b', 'c', 'd']
reversed_letters = letters[slice(None, None, -1)]
print(reversed_letters) # ['d', 'c', 'b', 'a']If step is 0, Python raises ValueError: slice step cannot be zero. This is true both for the bracket syntax and for the slice() function.
Practical Uses: Copying, Reversing, and Extracting Subsets
Slice objects are commonly used for three operations: copying a sequence, reversing it, and extracting a contiguous or stepped subset.
A full slice [:] creates a shallow copy of a list. Using slice(None) or slice(None, None) does the same.
original = [1, 2, 3]
copy = original[slice(None)]
copy.append(4)
print(original) # [1, 2, 3]
print(copy) # [1, 2, 3, 4]Reversing a sequence with [::-1] is equivalent to slice(None, None, -1). This works on any sequence that supports slicing, including strings and tuples.
text = "hello"
print(text[slice(None, None, -1)]) # "olleh"For extracting a subset, you can combine a slice with a comprehension or loop when you need to process the selected elements further. The slice itself returns a new sequence, so the original remains unchanged.
monthly_sales = [120, 85, 90, 110, 95, 130]
first_quarter = monthly_sales[slice(0, 3)]
print(first_quarter) # [120, 85, 90]Using Slice Objects in Custom Classes
If you define a class that represents a collection, you can support slicing by implementing __getitem__ to handle slice objects. This is a common pattern for custom containers, wrappers, or data structures.
class EvenNumbers:
def __init__(self, limit):
self._numbers = list(range(0, limit, 2))
def __getitem__(self, key):
if isinstance(key, slice):
return self._numbers[key]
return self._numbers[key]
def __len__(self):
return len(self._numbers)
evens = EvenNumbers(10)
print(evens[1:4]) # [2, 4, 6]
print(evens[::2]) # [0, 4, 8]In __getitem__, you can inspect the slice's attributes to implement custom behavior, such as returning a different type or applying a transformation. For example, you might return a view instead of a copy, or log access.
class LoggedList:
def __init__(self, data):
self._data = data
def __getitem__(self, key):
if isinstance(key, slice):
print(f"Slicing with {key.start}:{key.stop}:{key.step}")
return self._data[key]
return self._data[key]Common Mistakes and Edge Cases with Slices
One frequent mistake is assuming that a slice always includes the stop index. It does not; the slice ends at stop - 1 when step is positive. This off-by-one behavior is the same as range().
Another edge case is using a slice with a negative step and default boundaries. seq[::-1] works, but seq[5:1:-1] excludes index 1. To include the first element when stepping backward, you need to omit stop or use None.
data = [0, 1, 2, 3, 4, 5]
print(data[5:0:-1]) # [5, 4, 3, 2, 1] - missing 0
print(data[5:None:-1]) # [5, 4, 3, 2, 1, 0]Slices on strings return new strings, not lists. If you need a list of characters, convert explicitly with list().
word = "python"
print(word[1:4]) # "yth"
print(list(word[1:4])) # ['y', 't', 'h']Finally, be aware that a slice always copies the selected elements for built-in sequences like lists and tuples. If you need to avoid copying, consider using itertools.islice, which iterates lazily without creating a new container.
Performance and Memory Considerations When Slicing
Slicing a list creates a new list containing references to the original elements. This operation is O(k), where k is the number of elements in the slice. For large slices, this can consume significant memory, especially if you only need to iterate once.
If you are working with a large sequence and only need to process a subset without storing it, use itertools.islice instead of a slice object. It returns an iterator that yields elements on demand.
from itertools import islice
large_data = range(10_000_000)
for item in islice(large_data, 1000, 2000):
# process item without creating a 1000-element list
passFor custom classes, you can control whether slicing returns a copy or a view. If your class wraps a mutable sequence and you want slicing to return a lightweight view, implement __getitem__ to return a proxy object that references the original data. This trade-off affects memory usage and the semantics of subsequent modifications.
When performance matters, measure the actual behavior in your context. The overhead of creating a slice object is negligible compared to copying a large list. The main cost is the copy itself, so choose the approach that matches your memory and iteration requirements.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.