The following code is the solution:
>>> ["foo", "bar", "baz"].index("bar") 1
Note that while this is perhaps the cleanest way to answer the question as asked,
index is a rather weak component of the
list API, and I can’t remember the last time I used it in anger. It’s been pointed out to me in the comments that because this answer is heavily referenced, it should be made more complete. Some caveats about
list.index follow. It is probably worth initially taking a look at the documentation for it:
list.index(x[, start[, end]])
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.
Linear time-complexity in list length
index call checks every element of the list in order, until it finds a match. If your list is long, and you don’t know roughly where in the list it occurs, this search could become a bottleneck. In that case, you should consider a different data structure. Note that if you know roughly where to find the match, you can give
index a hint. For instance, in this snippet,
l.index(999_999, 999_990, 1_000_000) is roughly five orders of magnitude faster than straight
l.index(999_999), because the former only has to search 10 entries, while the latter searches a million:
>>> import timeit >>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000) 9.356267921015387 >>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000) 0.0004404920036904514
Only returns the index of the first match to its argument
A call to
index searches through the list in order until it finds a match, and stops there. If you expect to need indices of more matches, you should use a list comprehension or generator expression.
>>> [1, 1].index(1) 0 >>> [i for i, e in enumerate([1, 2, 1]) if e == 1] [0, 2] >>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1) >>> next(g) 0 >>> next(g) 2
Most places where I once would have used
index, I now use a list comprehension or generator expression because they’re more generalizable. So if you’re considering reaching for
index, take a look at these excellent Python features.
Throws if element not present in list
A call to
index results in a
ValueError if the item’s not present.
>>> [1, 1].index(2) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: 2 is not in list
If the item might not be present in the list, you should either
- Check for it first with
item in my_list(clean, readable approach), or
- Wrap the
indexcall in a
try/exceptblock which catches
ValueError(probably faster, at least when the list to search is long, and the item is usually present.)
One thing that is really helpful in learning Python is to use the interactive help function:
>>> help(["foo", "bar", "baz"]) Help on list object: class list(object) ... | | index(...) | L.index(value, [start, [stop]]) -> integer -- return first index of value |
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
for i, j in enumerate(['foo', 'bar', 'baz']): if j == 'bar': print(i)
index() function only returns the first occurrence, while
enumerate() returns all occurrences.
As a list comprehension:
[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']
Here’s also another small solution with
itertools.count() (which is pretty much the same approach as enumerate):
from itertools import izip as zip, count # izip for maximum efficiency [i for i, j in zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']
This is more efficient for larger lists than using
$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']" 10000 loops, best of 3: 174 usec per loop $ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']" 10000 loops, best of 3: 196 usec per loop
To get all indexes:
indexes = [i for i,x in enumerate(xs) if x == 'foo']
index() returns the first index of value!
| L.index(value, [start, [stop]]) -> integer — return first index of value
def all_indices(value, qlist): indices =  idx = -1 while True: try: idx = qlist.index(value, idx+1) indices.append(idx) except ValueError: break return indices all_indices("foo", ["foo","bar","baz","foo"])
A problem will arise if the element is not on the list. This function handles the issue:
# if element is found it returns index of element else returns None def find_element_in_list(element, list_element): try: index_element = list_element.index(element) return index_element except ValueError: return None
You have to set a condition to check if the element you’re searching is in the list
if 'your_element' in mylist: print mylist.index('your_element') else: print None
If you want all indexes, then you can use NumPy:
import numpy as np array = [1, 2, 1, 3, 4, 5, 1] item = 1 np_array = np.array(array) item_index = np.where(np_array==item) print item_index # Out: (array([0, 2, 6], dtype=int64),)
It is a clear, readable solution.
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:
>>> l = ["foo", "bar", "baz"] >>> l.index('bar') 1
There are a couple of issues with this method:
- if the value isn’t in the list, you’ll get a
- if more than one of the value is in the list, you only get the index for the first one
If the value could be missing, you need to catch the
You can do so with a reusable definition like this:
def index(a_list, value): try: return a_list.index(value) except ValueError: return None
And use it like this:
>>> print(index(l, 'quux')) None >>> print(index(l, 'bar')) 1
And the downside of this is that you will probably have a check for if the returned value
is not None:
result = index(a_list, value) if result is not None: do_something(result)
More than one value in the list
If you could have more occurrences, you’ll not get complete information with
>>> l.append('bar') >>> l ['foo', 'bar', 'baz', 'bar'] >>> l.index('bar') # nothing at index 3? 1
You might enumerate into a list comprehension the indexes:
>>> [index for index, v in enumerate(l) if v == 'bar'] [1, 3] >>> [index for index, v in enumerate(l) if v == 'boink'] 
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:
indexes = [index for index, v in enumerate(l) if v == 'boink'] for index in indexes: do_something(index)
Better data munging with pandas
If you have pandas, you can easily get this information with a Series object:
>>> import pandas as pd >>> series = pd.Series(l) >>> series 0 foo 1 bar 2 baz 3 bar dtype: object
A comparison check will return a series of booleans:
>>> series == 'bar' 0 False 1 True 2 False 3 True dtype: bool
Pass that series of booleans to the series via subscript notation, and you get just the matching members:
>>> series[series == 'bar'] 1 bar 3 bar dtype: object
If you want just the indexes, the index attribute returns a series of integers:
>>> series[series == 'bar'].index Int64Index([1, 3], dtype='int64')
And if you want them in a list or tuple, just pass them to the constructor:
>>> list(series[series == 'bar'].index) [1, 3]
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:
>>> [i for i, value in enumerate(l) if value == 'bar'] [1, 3]
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.
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:
key_list[key_list.index(old)] = new
In Lib/http/cookiejar.py, seems to be used to get the next month:
mon = MONTHS_LOWER.index(mon.lower())+1
In Lib/tarfile.py similar to distutils to get a slice up to an item:
members = members[:members.index(tarinfo)]
numtopop = before.index(markobject)
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.
Getting all the occurrences and the position of one or more (identical) items in a list
With enumerate(alist) you can store the first element (n) that is the index of the list when the element x is equal to what you look for.
>>> alist = ['foo', 'spam', 'egg', 'foo'] >>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo'] >>> foo_indexes [0, 3] >>>
Let’s make our function findindex
This function takes the item and the list as arguments and return the position of the item in the list, like we saw before.
def indexlist(item2find, list_or_string): "Returns all indexes of an item in a list or a string" return [n for n,item in enumerate(list_or_string) if item==item2find] print(indexlist("1", "010101010"))
[1, 3, 5, 7]
for n, i in enumerate([1, 2, 3, 4, 1]): if i == 1: print(n)
Hope you learned something from this post.
Follow Programming Articles for more!