Mysterious interaction between Python's slice bounds and "stride"

Question

I understand that given an iterable such as

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

I can turn it into a list and slice off the ends at arbitrary points with, for example

>>> it[1:-2]
[2, 3, 4, 5, 6, 7]

or reverse it with

>>> it[::-1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

or combine the two with

>>> it[1:-2][::-1]
[7, 6, 5, 4, 3, 2]

However, trying to accomplish this in a single operation produces in some results that puzzle me:

>>> it[1:-2:-1] 
[]
>>>> it[-1:2:-1] 
[9, 8, 7, 6, 5, 4]
>>>> it[-2:1:-1]
[8, 7, 6, 5, 4, 3]

Only after much trial and error, do I get what I'm looking for:

>>> it[-3:0:-1]
[7, 6, 5, 4, 3, 2]

This makes my head hurt (and can't help readers of my code):

>>> it[-3:0:-1] == it[1:-2][::-1]
True

How can I make sense of this? Should I even be pondering such things?

---

FWYW, my code does a lot of truncating, reversing, and listifying of iterables, and I was looking for something that was faster and clearer (yes, don't laugh) than list(reversed(it[1:-2])).

Answer 1

This is because in a slice like -

list[start:stop:step]

start is inclusive, resultant list starts at index start.

stop is exclusive, that is the resultant list only contains elements till stop - 1 (and not the element at stop).

So for your caseit[1:-2] - the 1 is inclusive , that means the slice result starts at index 1 , whereas the -2 is exclusive , hence the last element of the slice index would be from index -3.

Hence, if you want the reversed of that, you would have to do it[-3:0:-1] - only then -3 would be included in the sliced result, and the sliced result would go upto 1 index.

Answer 2

The important things to understand in your slices are

• Start will be included in the slice

• Stop will NOT be included in the slice

• If you want to slice backwards, the step value should be a negative value.

Basically the range which you specify is a half-open (half-closed) range.

---

When you say it[-3:0:-1] you are actually starting from the third element from the back, till we reach 0 (not including zero), step one element at a time backwards.

>>> it[-3:0:-1]
[7, 6, 5, 4, 3, 2]

Instead, you can realize the start value like this

>>> it[len(it)-3 : 0 : -1]
[7, 6, 5, 4, 3, 2]

Answer 3

I think the other two answers disambiguate the usage of slicing and give a clearer image of how its parameters work.

---

But, since your question also involves readability -- which, let's not forget, is a big factor especially in Python -- I'd like to point out how you can improve it slightly by assigning slice() objects to variables thus removing all those hardcoded : separated numbers.

Your truncate and reverse slice object could, alternatively, be coded with a usage implying name :

rev_slice = slice(-3, 0, -1)

In some other config-like file. You could then use it in its named glory within slicing operations to make this a bit more easy on the eyes :

it[rev_slice]  # [7, 6, 5, 4, 3, 2] 

This might be a trivial thing to mention, but I think it's probably worth it.

Answer 4

Why not create a function for readability:

def listify(it, start=0, stop=None, rev=False):
    if stop is None:
        the_list = it[start:]
    else:
        the_list = it[start:stop]
    if rev:
        return the_list[::-1]
    else:
        return the_list

listify(it, start=1, stop=-2)  # [2, 3, 4, 5, 6, 7]
listify(it, start=1, stop=-2, rev=True)  # [7, 6, 5, 4, 3, 2]

Answer 5

A good way to intuitively understand the Python slicing syntax is to see how it maps to the corresponding C for loop.

A slice like

x[a:b:c]

gives you the same elements as

for (int i = a; i < b; i += c) {
  ...
}

The special cases are just default values:

• a defaults to 0
• b defaults to len(x)
• c defaults to 1

Plus one more special case:

• if c is negative, then a and b are swapped and the < is inverted to a >