Skip to content

Slicing Lists in Python: A Comprehensive How-To Guide

Updated: at 03:12 AM

Slicing is a very useful technique in Python that allows you to extract subsets or slices from sequences like lists, tuples, and strings. Slicing provides an efficient and convenient way to get a specific subset range from a list without having to loop through and index each item individually.

In this comprehensive guide, you will learn what list slicing is, how it works under the hood, and how to leverage slicing operations to extract, modify or analyze subsets of list data in Python.

We will cover the basics of slicing syntax, slice object internals, and practical applications with code examples. You will also learn advanced techniques like multidimensional slicing on nested lists and gotchas to avoid when slicing mutables.

By the end, you will have a deep understanding of slicing in Python and be able to use it proficiently in your own programs for efficient data extraction and processing. The knowledge is useful for Python developers, data scientists, and anyone working with sequential data structures.

Table of Contents

Open Table of Contents

What is List Slicing in Python?

List slicing in Python is an operation that allows you to retrieve a range of items from a list by specifying start and end indices. It returns a new list containing the extracted elements.

The basic syntax for slicing a list is:

new_list = original_list[start:end]


For example:

fruits = ['apple', 'banana', 'mango', 'orange']
fruits_subset = fruits[1:3]

# ['banana', 'mango']

This slices fruits from index 1 (inclusive) to index 3 (exclusive) and assigns the new sliced list to fruits_subset.

Some key properties of slicing lists in Python:

We’ll explore these in more detail with examples next.

How List Slicing Works in Python

Slicing notation in Python is implemented through slice objects. A slice object represents the start, stop, and step values given to slice a sequence, and contains metadata about the slicing operation.

The slice object is created by calling slice() built-in and passed to the sequence indexing operator [].

For example:

my_list[ start:end ]
           ↑       ↑
  These values get enclosed in slice()

# slice(start, end, step)

Understanding what happens internally helps explain the behavior and flexibility of slicing notation in Python.

When a slice object is passed to the indexing operator, the sequence looks up its _ _getitem_ _ method to handle the slice and extract the subset items accordingly.

Now let’s look at different ways to slice lists using this slice object notation.

Omitting Start and End Indices

If you omit start index, 0 is taken by default:

nums = [1, 2, 3, 4, 5]

# slice(0, 3, None)
# [1, 2, 3]

# slice(3, len(nums), None)
# [4, 5]

Similarly, if you omit end, it slices all the way to the end by default:

nums = [1, 2, 3, 4, 5]

# slice(0, 3, None)
# [1, 2, 3]

# slice(3, len(nums), None)
# [4, 5]

You can also omit both to make a full slice copy of the entire list:

nums = [1, 2, 3, 4, 5]

# slice(0, len(nums), None)
# [1, 2, 3, 4, 5]

Negative Indices

Python allows negative indices for slicing, which refer to positions counted backwards from the end of the list.

For example:

nums = [1, 2, 3, 4, 5]

# slice(-3, -1, None)
# [3, 4]

Here, -3 refers to index 2 from start and -1 refers to index 4 from start when counted backwards from the end.

Negative indices provide an easy way to slice items from the end of a list without needing to know the exact length.

Stepping or Stride Value

You can also specify a step or stride value to skip items while slicing:

nums = [1, 2, 3, 4, 5]

# slice(0, len(nums), 2)
# [1, 3, 5]

The third argument 2 specifies a step of 2. So it extracts every alternate item from index 0 to end.

Stepping works with negative stride too:

nums = [1, 2, 3, 4, 5]

# slice(len(nums)-1, -1, -1)
# [5, 4, 3, 2, 1]

Here, step -1 reverses the list by going backwards from end to start.

Empty Slices

If start index >= end index, slicing returns an empty list since no items exist in that range:

nums = [1, 2, 3]
# []

# []

The slice is essentially invalid in these cases.

Multidimensional Slicing

Slicing also works on nested lists (lists within lists) to extract subsets from sublists:

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

# [[4, 5, 6], [7, 8, 9]]

# [2, 3]

You can slice both the outer and inner lists separately.

This multidimensional slicing provides a very flexible way to extract sections from matrix or grid-like data structures in Python.

Practical Examples of List Slicing in Python

Now let’s look at some practical examples of how list slicing can be used in real code.

1. Getting a sublist with specific indices

Use simple slicing to extract part of a list:

words = ['Apple', 'Banana', 'Mango', 'Orange', 'Strawberry']

# Extract 2nd to 4th items
sublist = words[1:4]

# ['Banana', 'Mango', 'Orange']

2. Omitting indices for start/end defaults

Utilize default start and end values:

words = ['Apple', 'Banana', 'Mango', 'Orange', 'Strawberry']

# From index 1 to end
end_sublist = words[1:]

# From start to index 3
start_sublist = words[:3]

# ['Banana', 'Mango', 'Orange', 'Strawberry']

# ['Apple', 'Banana', 'Mango']

3. Negative index for slicing from end

Get the last 3 items by negative index:

words = ['Apple', 'Banana', 'Mango', 'Orange', 'Strawberry']

last_three = words[-3:]

# ['Mango', 'Orange', 'Strawberry']

4. Skipping items with step value

Extract every 3rd item:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

every_3rd = numbers[::3]

# [1, 4, 7, 10]

5. Reversing list with negative step

Reverse the entire list:

numbers = [1, 2, 3, 4, 5]

reversed_list = numbers[::-1]

# [5, 4, 3, 2, 1]

6. Copying a list

Make a full slice copy:

original = [1, 2, 3, 4, 5]

copy_list = original[:]

# Modify copy

# [1, 2, 3, 4, 5]

# [1, 2, 3, 4, 5, 6]

7. Removing list section in-place

Delete section by assigning an empty slice:

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Delete indexes 3 to 5
del data[3:6]

# [1, 2, 3, 6, 7, 8, 9]

8. Multidimensional slice on matrix

Extract subsets from nested lists:

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

# Get 1st row
row1 = matrix[0]

# Get item at indexes (1, 2)
item = matrix[1][2]

# [1, 2, 3]

# 6

These are some common use cases for slicing lists in Python. The key strengths are efficiently extracting sections, reversing, stepping through items, and working with multidimensional data.

Slicing Gotchas and Best Practices

While slicing syntax is very flexible, there are some best practices to keep in mind:

Following best practices will help you avoid subtle bugs and write clean, efficient list slicing code.


This guide covered the fundamentals of slicing in Python - from basic syntax, to internals, practical examples, advanced techniques, and common gotchas.

Key takeaways:

You should now be able to leverage slicing for efficient data extraction, processing, and analysis in your Python code. Slicing is a universally useful technique for Python developers.

Some next topics to explore further are NumPy array slicing, Pandas dataframe slicing, and generator expressions for lazy slicing.

I hope you found this guide helpful in deepening your understanding of this core Python language feature. Let me know if you have any other questions!