# python – How to find all occurrences of an element in a list

## python – How to find all occurrences of an element in a list

You can use a list comprehension:

```
indices = [i for i, x in enumerate(my_list) if x == whatever]
```

The iterator `enumerate(my_list)`

yields pairs `(index, item)`

for each item in the list. Using `i, x`

as loop variable target unpacks these pairs into the index `i`

and the list item `x`

. We filter down to all `x`

that match our criterion, and select the indices `i`

of these elements.

While not a solution for lists directly, `numpy`

really shines for this sort of thing:

```
import numpy as np
values = np.array([1,2,3,1,2,4,5,6,3,2,1])
searchval = 3
ii = np.where(values == searchval)[0]
```

returns:

```
ii ==>array([2, 8])
```

This can be significantly faster for lists (arrays) with a large number of elements vs some of the other solutions.

#### python – How to find all occurrences of an element in a list

A solution using `list.index`

:

```
def indices(lst, element):
result = []
offset = -1
while True:
try:
offset = lst.index(element, offset+1)
except ValueError:
return result
result.append(offset)
```

Its much faster than the list comprehension with `enumerate`

, for large lists. It is also much slower than the `numpy`

solution *if* you already have the array, otherwise the cost of converting outweighs the speed gain (tested on integer lists with 100, 1000 and 10000 elements).

**NOTE:** A note of caution based on Chris_Rands comment: this solution is faster than the list comprehension if the results are sufficiently sparse, but if the list has many instances of the element that is being searched (more than ~15% of the list, on a test with a list of 1000 integers), the list comprehension is faster.