Neat Features in Python: Slicing and Sliding (Stepping)

NOTE: The article is written for Python 2.4-2.7. It is untested on Python 3.0+ and may contain errors for that series.

Anyone following my twitter feed can tell you that I am a great fan of the Python programming language. It is an incredible programming language and it is filled with many neat language features that truly help programmer productivity and code readability. For a quick tutorial, visit the informal Python tutorial here. If you would like to suggest a feature to cover, please don’t hesitate to let me know. Leave a comment and let’s have a discussion!

Introduction

The first feature in Python that I would like to cover is slicing and sliding. Although, slicing is a very well-known feature of the Python programming language; the companion “sliding” or “stepping” feature is not particularly documented in places where it should be (like here) and I rarely see any usage of it in regular Python code. Slicing and sliding together make for some sweet list manipulation action! Slicing and sliding is the equivalent to Batman and Robin, one is feared and loved while the sidekick occasionally pops up here and there to complement Batman hehe. I have seen usage of term stepping (perhaps more frequently) and sliding, use the term you prefer. They are perfectly interchangeable.  In my opinion though, slicing and sliding sounds so much better together (hehe one letter change and the letters are consecutive ZOMG!) and since the features are tied together why not make the names sound similar. I am going to stick with slicing and sliding until someone convinces me not to.

Definition

Slicing is the ability to create a list (in the abstract data type sense) from another list by cutting pieces of that other list.

Fig 1. Slicing

Off course, you can do this by looping through the list and picking the elements you want to put in your new list but slicing is great because it provides a cleaner and more readable syntax to do just that. The syntax looks like this:

l[start:end] # slices from start to end - 1
l[start:] # slices from start through the rest of the list
l[:end] # slices from the beginning to end - 1
l[:] # slices through the entire list i.e. does a copy of the list

Example

>>> l = range(5) # produces this list: [0,1,2,3,4]
>>> print l
[0, 1, 2, 3, 4]
>>> l[2:4]
[2, 3]
>>> l[2:]
[2, 3, 4]
>>> l[:4]
[0, 1, 2, 3]
>>> l[:]
[0, 1, 2, 3, 4]

So what is sliding or stepping? Sliding allows you to specify an increment between the elements to cut from your list.  If you wanted to slice every 2 elements, instead of specifying an increment of 1, you specify 2.

Fig 2. Slice and Slide

The syntax looks like this:

l[start:end:step] # slices from start to end - 1 but slide by the step value
l[::] # slices through the entire list i.e. does a copy of the list

Example

>>> l = range(10)
>>> print l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[::2]
[0, 2, 4, 6, 8]
>>> l[::3]
[0, 3, 6, 9]
>>> l[::-1] # ZOMG
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> l[::-2] # BUT WATCH OUT!
[9, 7, 5, 3, 1]

Why it is awesome?

So why is this awesome? Well as you can see from above, you can select every two elements of the list, reverse a list, reverse a slice of the list… well you can basically do a lot of things that would have required you to create a loop to retrieve specific slices of a list. Your code for grabbing elements from a list is significantly shorter and more concise. Add in the sliding (or stepping) notation and you suddenly have a very powerful method of manipulating lists.

Slice Objects

Now that slicing and sliding has been explained, the underlying implementation of the above syntax is done by calling the slice method with the same parameters: slice([start,] stop[, step]). However, this method will return a slice object. This object conveniently holds a start, stop and step read-only variables that you can access. You can pass around slice objects easily and reuse the variables. (Clean code yay!) You apply a slice object by doing the following:

>>> # The following is equivalent to list[1::2]
>>> s = slice(1, None, 2) # None is the default for empty.
>>> l = range(5)
>>> print l
[0, 1, 2, 3, 4]
>>> l[s] # Apply the slice!
[1, 3]

Bonus: Interview Question for Python Candidates:

Reverse a list in one line and explain how it works?
It works through the use of a stepping parameter. We slice the whole but we specify that we want to step in the negative direction by 1, i.e. slide backwards from the end of the list by 1 step.

print mylist[::-1]

Interesting Links

Dive into Python List Page.
Slicing and sliding was introducing in Python 2.3.5, here are the release notes.
Slicing tutorial
The slice object

8 thoughts on “Neat Features in Python: Slicing and Sliding (Stepping)

  1. Nice writeup about Python’s extended slice syntax. I liked the diagrams and abundance of example code.

    However, this is hardly a hidden feature in Python. Almost every Python function that deals with subsequences supports a step option, including range(start, stop, step), and it’s the second result for the search “Python slice”. Also using the term stepping is not only more consistent with the documentation, but is also the commonly used terminology in many other languages.

    1. Alright! I guess it’s not as hidden as I thought it was. This article series is probably better suited to new Python programmers for whom finding information about various things is a little hard. I’ll update the post to note that stepping is the more consistent term. Thanks for the feedback!

  2. Helpful post. I’d like to ask if there’s a way to do like this: a[~s] for a is a list, s is a slice object here. For example a=range(10), I’d like some way as a[~[3:7]] to get the rest elements other than [3:7].

Leave a Reply

Your email address will not be published.