Lists are useful in different ways compared to other datatypes because of how versatile they are. In this article we'll take a look at one of the most common operations with lists - finding the index of an element.
We will take a look at different scenarios of finding an element, i.e. finding the first, last, and all occurrences of an element. As well as what happens when the element we're looking for doesn't exist.
Using the index() Function
All of the operations we mentioned in the last paragraph can be done with the built-in
index() function. The syntax for this function is
index(element[, start[, end]]).
element parameter naturally represents the element we're looking for. The
end parameters are optional and represent the range of indices in which we look for the
The default value for
0 (searching from the beginning), and the default value for
end is the number of elements in the list (searching to the end of the list).
The function returns the first position of the
element in the list that it could find, regardless of how many equal elements there are after the first occurrence.
Finding the First Occurrence of an Element
index() function without setting any values for
end will give us the first occurrence of the
element we're looking for:
my_list = ['a', 'b', 'c', 'd', 'e', '1', '2', '3', 'b'] first_occurrence = my_list.index('b') print("First occurrence of 'b' in the list: ", first_occurrence)
Which would give us the expected output:
First occurrence of 'b' in the list: 1
Finding All Occurrences of an Element
To find all occurrences of an element, we can use the optional parameter
start so that we search in only certain segments of the list.
For example, let's say that we would the first occurrence of an element at index
3. In order to find the next one, we would need to continue our search for the first appearance of that element after index
3. We would repeat this process, changing where our search begins, as long as we found new occurrences of the element:
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a'] all_occurrences =  last_found_index = -1 element_found = True while element_found: try: last_found_index = my_list.index('a', last_found_index + 1) all_occurrences.append(last_found_index) except ValueError: element_found = False if len(all_occurrences) == 0: print("The element wasn't found in the list") else: print("The element was found at: " + str(all_occurrences))
Running this code would give us:
The element was found at: [1, 5, 7]
We had to use a
try block here, since the
index() function throws an error when it can't find the specified
element in the given range. This might be unusual to developers who are more used to other languages since functions like these usually return
null when the element can't be found.
However, in Python we have to be careful and use a
try block when we use this function.
Another, more neat way of doing this same thing would be by using list comprehension and ignoring the
index() function altogether:
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a'] all_occurrences = [index for index, element in enumerate(my_list) if element == 'a'] print("The element was found at: " + str(all_occurrences))
Which would give us the same output as before. This approach has the added benefit of not using the
Finding the Last Occurrence of an Element
If you need to find the last occurrence of an element in the list, there are two approaches you can use with the
- Reverse the list and look for the first occurrence in the reversed list
- Go through all the occurrences of the element, and only keep track of the last occurrence
Regarding the first approach, if we knew the first occurrence of the
element in a reversed list, we could find the position of the last occurrence in the original one. More specifically, we can do this by subtracting
reversed_list_index - 1 from the length of the original list:
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a'] reversed_list_index = my_list[::-1].index('n') # or alteratively: # reversed_list_index2 = list(reversed(my_list)).index('n') original_list_index = len(my_list) - 1 - reversed_list_index print(original_list_index)
Which would give us the desired output:
As for the second approach, we could tweak the code we used to find all occurrences and only keep track of the last occurrence we found:
my_list = ['b', 'a', 2, 'n', False, 'a', 'n', 'a'] last_occurrence = -1 element_found = True while element_found: try: last_occurrence = my_list.index('n', last_occurrence + 1) except ValueError: element_found = False if last_occurrence == -1: print("The element wasn't found in the list") else: print("The last occurrence of the element is at: ", last_occurrence)
Which would give us the same output:
We have taken a look at some of the most common uses for the
index() function, and how to avoid it in some cases.
Keep the potentially unusual behavior of the
index() function in mind, where it throws an error instead of returning
None when an element isn't found in the list.