{"id":10696,"date":"2018-10-03T19:27:24","date_gmt":"2018-10-03T16:27:24","guid":{"rendered":"https:\/\/railsware.com\/blog\/?p=10696"},"modified":"2025-01-22T15:29:44","modified_gmt":"2025-01-22T12:29:44","slug":"indexing-and-slicing-for-lists-tuples-strings-sequential-types","status":"publish","type":"post","link":"https:\/\/railsware.com\/blog\/indexing-and-slicing-for-lists-tuples-strings-sequential-types\/","title":{"rendered":"Indexing and Slicing for Lists, Tuples, Strings, other Sequential Types in Python"},"content":{"rendered":"\n

List is arguably the most useful and ubiquitous type in Python. One of the reasons it’s so handy is Python slice notation. In short, slicing is a flexible tool to build new lists out of an existing list.<\/p>\n\n\n\n

Python supports slice notation for any sequential data type like lists, strings, tuples, bytes, bytearrays, and ranges. Also, any new data structure can add its support as well. This is greatly used (and abused) in NumPy and Pandas libraries, which are so popular in Machine Learning and Data Science. It\u2019s a good example of “learn once, use everywhere”.<\/p>\n\n\n\n

In this article, we will focus on indexing and slicing operations over Python’s lists. Most of the examples we will discuss can be used for any sequential data type. Only mutable assignment and deletion operations are not applicable to immutable sequence types like tuples, strings, bytes, and ranges.<\/p>\n\n\n

\n
\"Using<\/figure><\/div>\n\n\n

Indexing<\/h2>\n\n\n\n

Before discussing slice notation, we need to have a good grasp of indexing for sequential types.<\/p>\n\n\n\n

In Python, list is akin to arrays in other scripting languages(Ruby, JavaScript, PHP). It allows you to store an enumerated set of items in one place and access an item by its position – index.<\/p>\n\n\n\n

Let’s take a simple example:<\/p>\n\n\n\n

>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']\n<\/pre>\n\n\n\n
Here we defined a list of colors. Each item in the list has a value(color name) and an index(its position in the list). Python uses zero-based<\/strong> indexing. That means, the first element(value ‘red’) has an index 0, the second(value ‘green’) has index 1, and so on.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
To access an element by its index we need to use square brackets:<\/p>\n\n\n\n
>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']\n>>> colors[0]\n'red'\n>>> colors[1]\n'green'\n>>> colors[5]\n'black'\n<\/pre>\n\n\n\n
Negative indexes<\/h3>\n\n\n\n
Using indexing we can easily get any element by its position. This is handy if we use position from the head of a list. But what if we want to take the last element of a list? Or the penultimate element? In this case, we want to enumerate elements from the tail of a list.<\/p>\n\n\n\n
To address this requirement there is negative indexing. So, instead of using indexes from zero and above, we can use indexes from -1 and below.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
In negative indexing system -1 corresponds to the last element of the list(value ‘black’), -2 to the penultimate (value ‘white’), and so on.<\/p>\n\n\n\n
>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black']\n>>> colors[-1]\n'black'\n>>> colors[-2]\n'white'\n>>> colors[-6]\n'red'\n<\/pre>\n\n\n\n
Assignment<\/h3>\n\n\n\n
Before we used indexing only for accessing the content of a list cell. But it’s also possible to change cell content using an assignment operation:<\/p>\n\n\n\n
>>> basket = ['bread', 'butter', 'milk']\n>>> basket[0] = 'cake'\n>>> basket\n['cake', 'butter', 'milk']\n>>> basket[-1] = 'water'\n>>> basket\n['cake', 'butter', 'water']\n<\/pre>\n\n\n\n
We can freely use positive or negative indexing for assignment.<\/p>\n\n\n\n
Deletion<\/h3>\n\n\n\n
We can also easily delete any element from the list by using indexing and del<\/code> statement:<\/p>\n\n\n\n
>>> basket = ['bread', 'butter', 'milk']\n>>> del basket[0]\n>>> basket\n['butter', 'milk']\n>>> del basket[1]\n>>> basket\n['butter']\n<\/pre>\n\n\n\n
Indexing for other Sequential Types<\/h3>\n\n\n\n
Read-only indexing operations work perfectly well for all sequential types. But assignment and deletion operations are not applicable to immutable sequential types.<\/p>\n\n\n\n
Slice Notation<\/h2>\n\n\n\n
As it was shown, indexing allows you to access\/change\/delete only a single cell of a list. What if we want to get a sublist of the list. Or we want to update a bunch of cells at once? Or we want to go on a frenzy and extend a list with an arbitrary number of new cells in any position?<\/p>\n\n\n\n
Those and lots of other cool tricks can be done with slice notation. Let’s look at this subject – feel free to follow along on your own editor or with an online Python compiler<\/a>.<\/p>\n\n\n\n
Basic Usage of Slices<\/h3>\n\n\n\n
Let’s create a basic list:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
What if we want to take a sublist from the nums<\/code> list? This is a snap when using slice:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> some_nums = nums[2:7]\n>>> some_nums\n[30, 40, 50, 60, 70]\n<\/pre>\n\n\n\n
So, here is our first example of a slice: 2:7<\/em>. The full slice syntax is: start:stop:step<\/em>. start<\/code> refers to the index of the element which is used as a start of our slice. stop<\/code> refers to the index of the element we should stop just before to finish our slice. step<\/code> allows you to take each nth-element within a start:stop<\/em> range.<\/p>\n\n\n\n
In our example start<\/code> equals 2<\/code>, so our slice starts from value 30<\/code>. stop<\/code> is 7<\/code>, so the last element of the slice is 70<\/code> with index 6<\/code>. In the end, slice creates a new list(we named it some_nums<\/code>) with selected elements.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
We did not use step<\/code> in our slice, so we didn\u2019t skip any element and obtained all values within the range.<\/p>\n\n\n\n
With slices we can extract an arbitrary part of a list, e.g.:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[0:4]\n[10, 20, 30, 40]\n<\/pre>\n\n\n\n
Here we start from the first element(index 0<\/code>) and take a list till the element with index 4<\/code>.<\/p>\n\n\n\n
Taking n first elements of a list<\/h3>\n\n\n\n
Slice notation allows you to skip any element of the full syntax. If we skip the start<\/code> number then it starts from 0<\/code> index:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[:5]\n[10, 20, 30, 40, 50]\n<\/pre>\n\n\n\n
So, nums[:5]<\/em> is equivalent to nums[0:5]<\/em>. This combination is a handy shortcut to take n first elements of a list.<\/p>\n\n\n\n
Taking n last elements of a list<\/h3>\n\n\n\n
Negative indexes allow us to easily take n-last elements of a list:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[-3:]\n[70, 80, 90]\n<\/pre>\n\n\n\n
Here, the stop<\/code> parameter is skipped. That means you take from the start<\/code> position, till the end of the list. We start from the third element from the end (value 70<\/code> with index -3<\/code>) and take everything to the end.<\/p>\n\n\n\n
We can freely mix negative and positive indexes in start<\/code> and stop<\/code> positions:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[1:-1]\n[20, 30, 40, 50, 60, 70, 80]\n>>> nums[-3:8]\n[70, 80]\n>>> nums[-5:-1]\n[50, 60, 70, 80]\n<\/pre>\n\n\n\n
Taking all but n last elements of a list<\/h3>\n\n\n\n
Another good usage of negative indexes:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[:-2]\n[10, 20, 30, 40, 50, 60, 70]\n<\/pre>\n\n\n\n
We take all but the last two elements of original list.<\/p>\n\n\n\n
Taking every nth-element of a list<\/h3>\n\n\n\n
What if we want to have only every 2-nd element of nums<\/code>? This is where the step<\/code> parameter comes into play:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[::2]\n[10, 30, 50, 70, 90]\n<\/pre>\n\n\n\n
Here we omit start<\/code>\/stop<\/code> parameters and use only step<\/code>. By providing start<\/code> we can skip some elements:<\/p>\n\n\n\n
>>> nums[1::2]\n[20, 40, 60, 80]\n<\/pre>\n\n\n\n
And if we don’t want to include some elements at the end, we can also add the stop<\/code> parameter:<\/p>\n\n\n\n
>>> nums[1:-3:2]\n[20, 40, 60]\n<\/pre>\n\n\n\n
Using Negative Step and Reversed List<\/h3>\n\n\n\n
We can use a negative step<\/code> to obtain a reversed list:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[::-1]\n[90, 80, 70, 60, 50, 40, 30, 20, 10]\n<\/pre>\n\n\n\n
Negative step<\/code> changes a way, slice notation works. It makes the slice be built from the tail of the list. So, it goes from the last element to the first element. That’s why we get a reversed list with a negative step.<\/p>\n\n\n\n
Due to this peculiarity, start<\/code> and stop<\/code> should be provided from right to left as well. E.g., if you want to have a reversed list which starts from 80<\/code>:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[-2::-1]\n[80, 70, 60, 50, 40, 30, 20, 10]\n<\/pre>\n\n\n\n
So, we start from the -2<\/code> element (value 80<\/code>) and go from right to left collecting all the elements in a reversed list.<\/p>\n\n\n\n
We can use stop<\/code> value to stop taking before some element. E.g., let’s not include 20<\/code> and 10<\/code> values:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[-2:1:-1]\n[80, 70, 60, 50, 40, 30]\n<\/pre>\n\n\n\n
We use 1<\/code> for stop<\/code> index, which is the element with value 20<\/code>. So, we go from 80 till 30, not including value 20<\/code>.<\/p>\n\n\n\n
It’s a bit baffling that with a negative step<\/code>, stop<\/code> index is located before start<\/code>. Negative step<\/code> turns everything upside down.<\/p>\n\n\n\n
Of course, we can use an arbitrary negative step<\/code>:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[-2:1:-3]\n[80, 50]\n<\/pre>\n\n\n\n
Slice and Copying<\/h3>\n\n\n\n
One important thing to notice – is that list slice creates a shallow copy of the initial list. That means, we can safely modify the new list and it will not affect the initial list:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> first_five = nums[0:5]\n>>> first_five[2] = 3\n>>> first_five\n[10, 20, 3, 40, 50]\n>>> nums\n[10, 20, 30, 40, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
Despite our mutating the element under index 2<\/code>, it does not affect the nums<\/code> list, because first_five<\/code> list – is a partial copy of nums<\/code> list.<\/p>\n\n\n\n
There is the shortest form of slice notation – just colons nums[:]<\/em>.<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums_copy = nums[:]\n>>> nums_copy[0] = 33\n>>> nums_copy\n[33, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums\n[10, 20, 30, 40, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
It creates a shallow copy of the whole list and is a good shorthand when you need a copy of the original list.<\/p>\n\n\n\n
Slice Object<\/h3>\n\n\n\n
But what if we want to use the same slice over and over again. Is there a way to create a slice object instead of using just the syntactic form?<\/p>\n\n\n\n
This can be done using slice<\/code> function:<\/p>\n\n\n\n
>>> five_items_after_second = slice(2, 2 + 5)\n>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> colors = ['red', 'green', 'blue', 'yellow', 'white', 'black', 'silver']\n>>> nums[five_items_after_second]\n[30, 40, 50, 60, 70]\n>>> colors[five_items_after_second]\n['blue', 'yellow', 'white', 'black', 'silver']\n<\/pre>\n\n\n\n
slice<\/code> function accepts arguments in the same order as in slice notation, and if you need to skip some element, just use None<\/code>:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> all_but_two_last = slice(None, -2)\n>>> nums[all_but_two_last]\n[10, 20, 30, 40, 50, 60, 70]\n>>> reversed = slice(None, None, -1)\n>>> nums[reversed]\n[90, 80, 70, 60, 50, 40, 30, 20, 10]\n<\/pre>\n\n\n\n
Slice Assignment<\/h3>\n\n\n\n
Python supports slice assignment operation, which allows us to make a bunch of neat operations over an existing list. Unlike previous slice operations, these mutate the original object in place. That’s why they are not applicable to immutable sequential types.<\/p>\n\n\n\n
Substitute part of a list<\/h4>\n\n\n\n
Slice assignment allows you to update a part of a list with new values:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[:4] = [1,2,3,4]\n>>> nums\n[1, 2, 3, 4, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
Here we do not change the number of elements in the list. Only some list values are updated.<\/p>\n\n\n\n
Replace and Resize part of the list<\/h4>\n\n\n\n
We can replace part of a list with a bigger chunk instead:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[:4] = [1,2,3,4,5,6,7]\n>>> nums\n[1, 2, 3, 4, 5, 6, 7, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
In this case we extend the original list.<\/p>\n\n\n\n
It’s also possible to replace a bigger chunk with a smaller number of items:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[:4] = [1]\n>>> nums\n[1, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
Replace Every n-th Element<\/h4>\n\n\n\n
Adding step<\/code> allows to replace each n-th element with a new value:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[::2] = [1,1,1,1,1]\n>>> nums\n[1, 20, 1, 40, 1, 60, 1, 80, 1]\n<\/pre>\n\n\n\n
Using slice assignment with step<\/code> sets a limitation on the list we provide for assignment. The provided list should exactly match the number of elements to replace. If the length does not match, Python throws the exception:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[::2] = [1,1,1]\nTraceback (most recent call last):\n  File \"\", line 1, in \nValueError: attempt to assign sequence of size 3 to extended slice of size 5\n<\/pre>\n\n\n\n
We can also use negative step<\/code>:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[::-2] = [1,2,3,4,5]\n>>> nums\n[5, 20, 4, 40, 3, 60, 2, 80, 1]\n<\/pre>\n\n\n\n
By providing start<\/code> and stop<\/code> values we can narrow the replacement area:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> nums[1:5:2] = [2, 4]\n>>> nums\n[10, 2, 30, 4, 50, 60, 70, 80, 90]\n<\/pre>\n\n\n\n
Slice Deletion<\/h3>\n\n\n\n
We can also use del<\/code> statement to remove a slice out of a list:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> del nums[3:7]\n>>> nums\n[10, 20, 30, 80, 90]\n<\/pre>\n\n\n\n
Here we\u2019ve removed a bunch of elements in the middle of nums<\/code> list.<\/p>\n\n\n\n
We can also provide step<\/code> parameter to slice and remove each n-th element:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> del nums[::2]\n>>> nums\n[20, 40, 60, 80]\n<\/pre>\n\n\n\n
With the full syntax, we can set boundaries for the elements to be removed:<\/p>\n\n\n\n
>>> nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n>>> del nums[1:7:2]\n>>> nums\n[10, 30, 50, 70, 80, 90]\n<\/pre>\n\n\n\n
So, we start deletion from 20(index 1) and remove each 2-nd element till the value 80(index 7).<\/p>\n\n\n\n
And because slice deletion mutates the underlying object, it\u2019s not applicable to immutable sequential types.<\/p>\n\n\n\n
Summary<\/h2>\n\n\n\n
We discussed two key list operations: indexing and slicing. Both concepts are crucial to efficient Python use.<\/p>\n\n\n\n
This article prepared background for tackling indexing and slicing in NumPy<\/code> ndarrays<\/code> and Pandas<\/code> Series<\/code> and DataFrame<\/code> objects. There are a lot of similarities between these structures, but there are also a lot of subtle differences and gotchas which will be discussed in upcoming articles dedicated to the machine learning techniques the Railsware team makes use of.<\/p>\n\n\n\n
Read more<\/h2>\n\n\n\n
\n  \n