Python Find in List – How to Find the Index of an Item or Element in a List
Dionysia Lemonaki
In this article you will learn how to find the index of an element contained in a list in the Python programming language.
There are a few ways to achieve this, and in this article you will learn three of the different techniques used to find the index of a list element in Python.
The three techniques used are:
- finding the index using the index() list method,
- using a for-loop ,
- and finally, using list comprehension and the enumerate() function.
Specifically, here is what we will cover in depth:
What are Lists in Python?
Lists are a built-in data type in Python, and one of the most powerful data structures.
They act as containers and store multiple, typically related, items under the same variable name.
Items are placed and enclosed inside square brackets, [] . Each item inside the square brackets is separated by a comma, , .
From the example above, you can see that lists can contain items that are of any data type, meaning list elements can be heterogeneous.
Unlike arrays that only store items that are of the same type, lists allow for more flexibility.
Lists are also mutable, which means they are changeable and dynamic. List items can be updated, new items can be added to the list, and any item can be removed at any time throughout the life of the program.
An Overview of Indexing in Python
As mentioned, lists are a collection of items. Specifically, they are an ordered collection of items and they preserve that set and defined order for the most part.
Each element inside a list will have a unique position that identifies it.
That position is called the element’s index.
Indices in Python, and in all programming languages, start at 0 and not 1 .
Let’s take a look at the list that was used in the previous section:
The list is zero-indexed and counting starts at 0 .
The first list element, «John Doe» , has an index of 0 .
The second list element, 34 , has an index of 1 .
The third list element, «London» , has an index of 2 .
The forth list element, 1.76 , has an index of 3 .
Indices come in useful for accessing specific list items whose position (index) you know.
So, you can grab any list element you want by using its index.
To access an item, first include the name of the list and then in square brackets include the integer that corresponds to the index for the item you want to access.
Here is how you would access each item using its index:
But what about finding the index of a list item in Python?
In the sections that follow you will see some of the ways you can find the index of list elements.
Find the Index of an Item using the List index() Method in Python
So far you’ve seen how to access a value by referencing its index number.
What happens though when you don’t know the index number and you’re working with a large list?
You can give a value and find its index and in that way check the position it has within the list.
For that, Python’s built-in index() method is used as a search tool.
The syntax of the index() method looks like this:
Let’s break it down:
- my_list is the name of the list you are searching through.
- .index() is the search method which takes three parameters. One parameter is required and the other two are optional.
- item is the required parameter. It’s the element whose index you are searching for.
- start is the first optional parameter. It’s the index where you will start your search from.
- end the second optional parameter. It’s the index where you will end your search.
Let’s see an example using only the required parameter:
In the example above, the index() method only takes one argument which is the element whose index you are looking for.
Keep in mind that the argument you pass is case-sensitive. This means that if you had passed «python», and not «Python», you would have received an error as «python» with a lowercase «p» is not part of the list.
The return value is an integer, which is the index number of the list item that was passed as an argument to the method.
Let’s look at another example:
If you try and search for an item but there is no match in the list you’re searching through, Python will throw an error as the return value — specifically it will return a ValueError .
This means that the item you’re searching for doesn’t exist in the list.
A way to prevent this from happening, is to wrap the call to the index() method in a try/except block.
If the value does not exist, there will be a message to the console saying it is not stored in the list and therefore doesn’t exist.
Another way would be to check to see if the item is inside the list in the first place, before looking for its index number. The output will be a Boolean value — it will be either True or False.
How to Use the Optional Parameters with the index() Method
Let’s take a look at the following example:
In the list programming_languages there are three instances of the «Python» string that is being searched.
As a way to test, you could work backwards as in this case the list is small.
You could count and figure out their index numbers and then reference them like you’ve seen in previous sections:
There is one at position 1 , another one at position 3 and the last one is at position 5 .
Why aren’t they showing in the output when the index() method is used?
When the index() method is used, the return value is only the first occurence of the item in the list. The rest of the occurrences are not returned.
The index() method returns only the index of the position where the item appears the first time.
You could try passing the optional start and end parameters to the index() method.
You already know that the first occurence starts at index 1 , so that could be the value of the start parameter.
For the end parameter you could first find the length of the list.
To find the length, use the len() function:
The value for end parameter would then be the length of the list minus 1. The index of the last item in a list is always one less than the length of the list.
So, putting all that together, here is how you could try to get all three instances of the item:
The output still returns only the first instance!
Although the start and end parameters provide a range of positions for your search, the return value when using the index() method is still only the first occurence of the item in the list.
How to Get the Indices of All Occurrences of an Item in A List
Use a for-loop to Get the Indices of All Occurrences of an Item in A List
Let’s take the same example that we’ve used so far.
That list has three occurrences of the string «Python».
First, create a new, empty list.
This will be the list where all indices of «Python» will be stored.
Next, use a for-loop . This is a way to iterate (or loop) through the list, and get each item in the original list. Specifically, we loop over each item’s index number.
You first use the for keyword.
Then create a variable, in this case programming_language , which will act as a placeholder for the position of each item in the original list, during the iterating process.
Next, you need to specify the set amount of iterations the for-loop should perform.
In this case, the loop will iterate through the full length of the list, from start to finish. The syntax range(len(programming_languages)) is a way to access all items in the list programming_languages .
The range() function takes a sequence of numbers that specify the number it should start counting from and the number it should end the counting with.
The len() function calculates the length of the list, so in this case counting would start at 0 and end at — but not include — 6 , which is the end of the list.
Lastly, you need to set a logical condition.
Essentially, you want to say: «If during the iteration, the value at the given position is equal to ‘Python’, add that position to the new list I created earlier».
You use the append() method for adding an element to a list.
Use List Comprehension and the enumerate() Function to Get the Indices of All Occurrences of an Item in A List
Another way to find the indices of all the occurrences of a particular item is to use list comprehension.
List comprehension is a way to create a new list based on an existing list.
Here is how you would get all indices of each occurrence of the string «Python», using list comprehension:
With the enumerate() function you can store the indices of the items that meet the condition you set.
It first provides a pair ( index, item ) for each element in the list ( programming_languages ) that is passed as the argument to the function.
index is for the index number of the list item and item is for the list item itself.
Then, it acts as a counter which starts counting from 0 and increments each time the condition you set is met, selecting and moving the indices of the items that meet your criteria.
Paired with the list comprehension, a new list is created with all indices of the string «Python».
Conclusion
And there you have it! You now know some of the ways to find the index of an item, and ways to find the indices of multiple occurrences of an item, in a list in Python.
I hope you found this article useful.
To learn more about the Python programming language, check out freeCodeCamp’s Scientific Computing with Python Certification.
You’ll start from the basics and learn in an interacitve and beginner-friendly way. You’ll also build five projects at the end to put into practice and help reinforce what you’ve learned.
Finding the index of an item in a list
Given a list ["foo", "bar", "baz"] and an item in the list "bar" , how do I get its index 1 ?
44 Answers 44
See the documentation for the built-in .index() method of the list:
Return zero-based index in the list of the first item whose value is equal to x. Raises a ValueError if there is no such item.
The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.
Caveats
Linear time-complexity in list length
An index call checks every element of the list in order, until it finds a match. If the list is long, and if there is no guarantee that the value will be near the beginning, this can slow down the code.
This problem can only be completely avoided by using a different data structure. However, if the element is known to be within a certain part of the list, the start and end parameters can be used to narrow the search.
The second call is orders of magnitude faster, because it only has to search through 10 elements, rather than all 1 million.
Only the index of the first match is returned
A call to index searches through the list in order until it finds a match, and stops there. If there could be more than one occurrence of the value, and all indices are needed, index cannot solve the problem:
The list comprehension and generator expression techniques still work if there is only one match, and are more generalizable.
Raises an exception if there is no match
As noted in the documentation above, using .index will raise an exception if the searched-for value is not in the list:
If this is a concern, either explicitly check first using item in my_list , or handle the exception with try / except as appropriate.
The explicit check is simple and readable, but it must iterate the list a second time. See What is the EAFP principle in Python? for more guidance on this choice.
The majority of answers explain how to find a single index, but their methods do not return multiple indexes if the item is in the list multiple times. Use enumerate() :
The index() function only returns the first occurrence, while enumerate() returns all occurrences.
As a list comprehension:
Here’s also another small solution with itertools.count() (which is pretty much the same approach as enumerate):
This is more efficient for larger lists than using enumerate() :
To get all indexes:
index() returns the first index of value!
| index(. )
| L.index(value, [start, [stop]]) -> integer — return first index of value
A problem will arise if the element is not in the list. This function handles the issue:
You have to set a condition to check if the element you’re searching is in the list
If you want all indexes, then you can use NumPy:
It is clear, readable solution.
All of the proposed functions here reproduce inherent language behavior but obscure what’s going on.
Why write a function with exception handling if the language provides the methods to do what you want itself?
Finding the index of an item given a list containing it in Python
For a list ["foo", "bar", "baz"] and an item in the list "bar" , what’s the cleanest way to get its index (1) in Python?
Well, sure, there’s the index method, which returns the index of the first occurrence:
There are a couple of issues with this method:
- if the value isn’t in the list, you’ll get a ValueError
- if more than one of the value is in the list, you only get the index for the first one
No values
If the value could be missing, you need to catch the ValueError .
You can do so with a reusable definition like this:
And use it like this:
And the downside of this is that you will probably have a check for if the returned value is or is not None:
More than one value in the list
If you could have more occurrences, you’ll not get complete information with list.index :
You might enumerate into a list comprehension the indexes:
If you have no occurrences, you can check for that with boolean check of the result, or just do nothing if you loop over the results:
Better data munging with pandas
If you have pandas, you can easily get this information with a Series object:
A comparison check will return a series of booleans:
Pass that series of booleans to the series via subscript notation, and you get just the matching members:
If you want just the indexes, the index attribute returns a series of integers:
And if you want them in a list or tuple, just pass them to the constructor:
Yes, you could use a list comprehension with enumerate too, but that’s just not as elegant, in my opinion — you’re doing tests for equality in Python, instead of letting builtin code written in C handle it:
Is this an XY problem?
The XY problem is asking about your attempted solution rather than your actual problem.
Why do you think you need the index given an element in a list?
If you already know the value, why do you care where it is in a list?
If the value isn’t there, catching the ValueError is rather verbose — and I prefer to avoid that.
I’m usually iterating over the list anyways, so I’ll usually keep a pointer to any interesting information, getting the index with enumerate.
If you’re munging data, you should probably be using pandas — which has far more elegant tools than the pure Python workarounds I’ve shown.
I do not recall needing list.index , myself. However, I have looked through the Python standard library, and I see some excellent uses for it.
There are many, many uses for it in idlelib , for GUI and text parsing.
The keyword module uses it to find comment markers in the module to automatically regenerate the list of keywords in it via metaprogramming.
In Lib/mailbox.py it seems to be using it like an ordered mapping:
In Lib/http/cookiejar.py, seems to be used to get the next month:
In Lib/tarfile.py similar to distutils to get a slice up to an item:
What these usages seem to have in common is that they seem to operate on lists of constrained sizes (important because of O(n) lookup time for list.index ), and they’re mostly used in parsing (and UI in the case of Idle).
While there are use-cases for it, they are fairly uncommon. If you find yourself looking for this answer, ask yourself if what you’re doing is the most direct usage of the tools provided by the language for your use-case.