Slicing in Python is a feature that enables accessing parts of sequences like strings, tuples, and lists. You can also use them to modify or delete the items of mutable sequences such as lists. Slices can also be applied on third-party objects like NumPy arrays, as well as Pandas series and data frames. Slicing enables writing clean, concise, and readable code. This article shows how to access, modify, and delete items with indices and slices, as well as how to use the built-in class slice().

1. Slicing in Python – What
Is It?
This article was originally published at:
https://www.blog.duomly.com/slicing-in-python-what-is-it/
Slicing in Python is a feature that
enables accessing parts of sequences like
strings, tuples, and lists. You can also
use them to modify or delete the items of
mutable sequences such as lists. Slices
can also be applied on third-party
objects like NumPy arrays, as well as
Pandas series and data frames.
Slicing enables writing clean, concise,
and readable code.
This article shows how to access, modify,
and delete items with indices and slices,
as well as how to use the built-in class
slice().

2. Indexing
You can access a single item of a Python
sequence (such as string, tuple, or list)
with the corresponding integer indices.
Indices in Python are zero-based. This
means the index 0 corresponds to the
first (leftmost) item of a sequence, 1 to
the second item, and so on.
Let’s create one string, one tuple, and
one list to illustrate how to use
indices:
>>> str_ = 'Python is awesome!'
>>> str_
'Python is awesome!'
>>> tuple_ = (1, 2, 4, 8, 16, 32, 64, 128)
>>> tuple_
(1, 2, 4, 8, 16, 32, 64, 128)
>>> list_ = [1, 2, 4, 8, 16, 32, 64, 128]
>>> list_
[1, 2, 4, 8, 16, 32, 64, 128]
Indices are provided inside the brackets,
that is with the syntax sequence[index]:

3. >>> str_[0]
'P'
>>> str_[1]
'y'
>>> str_[4]
'o'
>>> tuple_[0]
1
>>> tuple_[1]
2
>>> tuple_[4]
16
>>> list_[0]
1
>>> list_[1]
2
>>> list_[4]
16
As you can see ‘P’ is the first character
of the string ‘Python is awesome!’ and it
corresponds to the index 0, ‘y’ is the
second and has index 1 and so on.
It’s very similar to tuples and lists.
Python provides the possibility to use
negative integer indices as well. This
appears to be very useful in practice,
especially when you want to access the
last (rightmost) item of a sequence.
The index -1 corresponds to the last
item, -2 to the second last, and so on:
>>> str_[-1]

4. '!'
>>> str_[-2]
'e'
>>> str_[-5]
's'
>>> tuple_[-1]
128
>>> tuple_[-2]
64
>>> tuple_[-5]
8
>>> list_[-1]
128
>>> list_[-2]
64
>>> list_[-5]
8
As you can see, the character ‘!’ is the
last item in the string ‘Python is
awesome!’ and it corresponds to the index
-1. It also has the index 17, which is
string_[17] returns ‘!’. The character
‘e’ takes place just in front of it and
has the index -2 and 16.
Again, tuples and lists behave similarly.
You can use indices to modify the items
of the mutable sequence. In Python,
strings and tuples are immutable, but
lists are mutable:
>>> list_[-1] = 100
>>> list_
[1, 2, 4, 8, 16, 32, 64, 100]

5. This example changes the last item of the
list to 100. Since this list has eight
items, you can also access the last item
with the zero-based index 7, that is you
can accomplish the same effect with the
statement list_[7] = 100.

6. Slicing
Slicing is similar to indexing but
returns a sequence of items instead of a
single item. The indices used for slicing
are also zero-based.
There are two variants of the slicing
syntax: sequence[start:stop] and
sequence[start:stop:step]. This article
explains both.
When you use the syntax
sequence[start:stop], you’ll get the new
sequence. It will start with the item
that has the index start (inclusive) and
end before the item with the index stop.
In other words, the statement
sequence[start:stop] returns the items
sequence[start], sequence[stop-1], and
all the items between them:
>>> str_[1:5]
'ytho'
>>> tuple_[2:4]
(4, 8)
>>> tuple_[2:3]
(4,)
>>> tuple_[2:2]
()
As you can see, the returning sequence
can contain only one item when start + 1
== stop or it can be an empty sequence
when start == stop.

7. When you omit start, the value 0 is
taken, that is the resulting sequence
starts at the beginning of the original:
>>> str_[:2]
'Py'
>>> tuple_[:4]
(1, 2, 4, 8)
If you omit to stop, the resulting
sequence stops at the end of the
original:
>>> str_[2:]
'thon is awesome!'
>>> tuple_[4:]
(16, 32, 64, 128)
Consistently, you can omit both start and
stop:
>>> str_[:]
'Python is awesome!'
>>> tuple_[:]
(1, 2, 4, 8, 16, 32, 64, 128)
>>> list_[:]
[1, 2, 4, 8, 16, 32, 64, 100]
That’s how you get a shallow copy of a
sequence.
It’s possible to apply negative values of
start and stop similarly as with indices:

8. >>> str_[-8:]
'awesome!'
>>> tuple_[:-1]
(1, 2, 4, 8, 16, 32, 64)
>>> tuple_[-4:-2]
(8, 16)
>>> tuple_[3:5]
(8, 16)
In the case of tuple_, the value -4 —
when counting backward from -1 —
corresponds to the same item as the value
3 when counting forward from 0. It’s the
same for the values 5 and -2. Again, the
item that corresponds to the index stop
isn’t included in the resulting sequence.
The syntax sequence[start:stop:step] is
similar, but with few more details.
You can use a step to specify the step if
you want to skip some items:
>>> tuple_[1:5:2]
(2, 8)
In this example, step is 2, so you start
with the item that has the index 1 (the
item 2), collect every second item, and
stop before you reach the item with the
index 5 (32). You take the item 2, skip
4, and take 8.
If the step is positive and you omit
start, the resulting sequence again
starts at the beginning of the original.

9. If you omit to stop, the operation stops
at the end of the original. However, if
you omit a step, it’s considered as 1 and
you get the same behavior as with the
syntax sequence[start:stop]:
>>> tuple_[:6:2]
(1, 4, 16)
>>> tuple_[3::2]
(8, 32, 128)
>>> tuple_[1:5:]
(2, 4, 8, 16)
A negative value of step, in combination
with a start greater than stop, can be
used to collect items backward:
>>> tuple_[4:1:-1]
(16, 8, 4)
>>> tuple_[6:1:-2]
(64, 16, 4)
In the cases with negative step and
omitted start, the resulting sequence
starts at the end of the original. If you
omit to stop, the operation stops at the
beginning of the original:
>>> tuple_[:2:-1]
(128, 64, 32, 16, 8)
>>> tuple_[5::-1]
(32, 16, 8, 4, 2, 1)

10. These rules are conveniently applied to
get the shallow copy of a sequence with
the items in the reversed order by
omitting both, start and stop:
>>> tuple_[::-1]
(128, 64, 32, 16, 8, 4, 2, 1)
You can use slices to modify the items of
mutable sequences:
>>> list_[1:6:2]
[2, 8, 32]
>>> list_[1:6:2] = [20, 80, 320]
>>> list_
[1, 20, 4, 80, 16, 320, 64, 100]
In this example, the items with the
indices 1, 3, and 5 are accessed and
modified.
If you use the syntax
sequence[start:stop], it’s possible to
replace a part of a sequence with a
smaller or larger one:
>>> list_[1:5]
[20, 4, 80, 16]
>>> list_[1:5] = [0, 0]
>>> list_
[1, 0, 0, 320, 64, 100]

11. In this example, four items are removed
([20, 4, 80, 16]) and two new ones ([0,
0]) are added instead.
Following this logic, you can delete
parts of mutable sequences by replacing
them with empty sequences like []:
>>> list_[1:3]
[0, 0]
>>> list_[1:3] = []
>>> list_
[1, 320, 64, 100]
It’s also possible to delete parts of
sequences using slices in the del
statement:
>>> list_[:2]
[1, 320]
>>> del list_[:2]
>>> list_
[64, 100]
So, there are two approaches to delete a
part of a list. However, the latter seems
more readable and easily understandable
because using the del statement makes
your intention (to delete something)
obvious.

12. What Are Slices?
The slices are the instances of the
Python built-in class slice. You create
them with the statement slice(start,
stop, step). It’s possible to pass an
instance of a slice instead of
start:stop:step or start:stop:
>>> s = slice(1, 5, 2)
>>> s
slice(1, 5, 2)
>>> s.start, s.stop, s.step
(1, 5, 2)
>>> tuple_[s]
(2, 8)
Again, you can omit step and get the
behavior of start:stop:
>>> s = slice(1, 5)
>>> s.start, s.stop, s.step
(1, 5, None)
>>> tuple_[s]
(2, 4, 8, 16)
If you pass a single argument, slice uses
it as stop and behaves as :stop:
>>> s = slice(5)
>>> s.start, s.stop, s.step
(None, 5, None)
>>> tuple_[s]
(1, 2, 4, 8, 16)

13. You can manipulate slices inside
functions and methods:
>>> def get_items_with_slice(sequence, start,
stop, step):
... return sequence[slice(start, stop, step)]
...
>>> get_items_with_slice([1, 2, 4, 8, 16, 32, 64,
128], 1, 5, None)
[2, 4, 8, 16]
This function uses its own arguments to
create a slice and passes it to get some
data from a sequence.
Finally, here’s an example of how you can
use slices in combination with the Python
special method _getite_() to define a
class whose instances can be used with
the index notation:
>>> class C:
... def __init__(self, *args):
... self.__data = args
... def __getitem__(self, index_or_slice):
... print('index or slice:',
index_or_slice)
... return self.__data[index_or_slice]
...
>>> x = C(1, 2, 4, 8, 16, 32, 128)
>>> x[4]
index or slice: 4
16
>>> x[1:5:2]

14. index or slice: slice(1, 5, 2)
(2, 8)
If you pass an integer to __getitem__(), it
will behave as an index of self.__data.
If you pass start:stop:step
instead, __getitem__() actually obtains a
slice object as an argument.
You can also use __setitem__() to modify
data and __delitem__() to delete data,
potentially combined with slices.

15. Conclusions of Slicing in Python
This article shows how to use slices in
Python. They are very powerful and useful
when you need to extract items from
sequences like strings, tuples, and
lists. Also, some third-party objects
such as NumPy arrays and Pandas series
and data frames.
You can use slices inside functions and
methods. If you want to define classes
with the possibility to access, modify,
or delete data with the
instance[index_or_slice] notation, you
should implement the special
methods __getitem__(), __setitem__(), or
__delitem__() and possibly apply slices.
Thank you for reading!
Table of contents:
• Indexing
• Slicing
• What Are Slices?
• Conclusions