How does Python's slice notation work? That is: when I write code like a[x:y:z]
, a[:]
, a[::2]
etc., how can I understand which elements end up in the slice?
See Why are slice and range upper-bound exclusive? to learn why xs[0:2] == [xs[0], xs[1]]
, not [..., xs[2]]
.
See Make a new list containing every Nth item in the original list for xs[::N]
.
See How does assignment work with list slices? to learn what xs[0:2] = ["a", "b"]
does.
Best Answer
The syntax is:
There is also the
step
value, which can be used with any of the above:The key point to remember is that the
:stop
value represents the first value that is not in the selected slice. So, the difference betweenstop
andstart
is the number of elements selected (ifstep
is 1, the default).The other feature is that
start
orstop
may be a negative number, which means it counts from the end of the array instead of the beginning. So:Similarly,
step
may be a negative number:Python is kind to the programmer if there are fewer items than you ask for. For example, if you ask for
a[:-2]
anda
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.Relationship with the
slice
objectA
slice
object can represent a slicing operation, i.e.:is equivalent to:
Slice objects also behave slightly differently depending on the number of arguments, similar to
range()
, i.e. bothslice(stop)
andslice(start, stop[, step])
are supported. To skip specifying a given argument, one might useNone
, so that e.g.a[start:]
is equivalent toa[slice(start, None)]
ora[::-1]
is equivalent toa[slice(None, None, -1)]
.While the
:
-based notation is very helpful for simple slicing, the explicit use ofslice()
objects simplifies the programmatic generation of slicing.