python - Understanding slice notation

itemprop="text">

I need a good explanation (references
are a plus) on Python's slice notation.

To me,
this notation needs a bit of picking up.

It
looks extremely powerful, but I haven't quite got my head around
it.

itemprop="text">

class="normal">Answer

It's
pretty simple
really:

a[start:stop] # items
            start through stop-1
a[start:] # items start through the rest of the
            array
a[:stop] # items from the beginning through stop-1
a[:] # a
            copy of the whole
            array

There is also
the step value, which can be used with any of the
above:

a[start:stop:step]
            # start through not past stop, by
            step

The key point to
remember is that the :stop value represents the first value
that is not in the selected slice. So, the difference between
stop and start is the number of
elements selected (if step is 1, the
default).

The other feature is that
start or stop may be a
negative number, which means it counts from the end of the array
instead of the beginning.
So:

a[-1] # last item in the
            array
a[-2:] # last two items in the array

a[:-2] #
            everything except the last two
            items

Similarly,
step may be a negative
number:

a[::-1] # all items in the
            array, reversed
a[1::-1] # the first two items, reversed
a[:-3:-1] #
            the last two items, reversed
a[-3::-1] # everything except the last two items,
            reversed

Python
is kind to the programmer if there are fewer items than you ask for. For example, if you
ask for a[:-2] and a only contains one
element, you get an empty list instead of an error. Sometimes you would prefer the
error, so you have to be aware that this may
happen.

Relation to
slice() object

The
slicing operator [] is actually being used in the above code
with a slice() object using the :
notation (which is only valid within []),
i.e.:

a[start:stop:step]

is
equivalent to:

a[slice(start,
            stop, step)]

Slice
objects also behave slightly differently depending on the number of arguments, similarly
to range(), i.e. both slice(stop) and
slice(start, stop[, step]) are supported.
To skip
specifying a given argument, one might use None, so that e.g.
a[start:] is equivalent to a[slice(start,
None)] or a[::-1] is equivalent to
a[slice(None, None,
-1)].

While the
:-based notation is very helpful for simple slicing, the
explicit use of slice() objects simplifies the programmatic
generation of slicing.