Getting a list of indices where pandas boolean series is True

Using boolean indexing

>>> s = pd.Series([True, False, True, True, False, False, False, True]) >>> s[s].index Int64Index([0, 2, 3, 7], dtype='int64') 

If need a np.array object, get the .values

>>> s[s].index.values array([0, 2, 3, 7]) 

Using np.nonzero

>>> np.nonzero(s) (array([0, 2, 3, 7]),) 

Using np.flatnonzero

>>> np.flatnonzero(s) array([0, 2, 3, 7]) 

Using np.where

>>> np.where(s)[0] array([0, 2, 3, 7]) 

Using np.argwhere

>>> np.argwhere(s).ravel() array([0, 2, 3, 7]) 

Using pd.Series.index

>>> s.index[s] array([0, 2, 3, 7]) 

Using Python's built-in filter

>>> [*filter(s.get, s.index)] [0, 2, 3, 7] 

Using list comprehension

>>> [i for i in s.index if s[i]] [0, 2, 3, 7] 

As an addition to rafaelc's answer, here are the according times (from quickest to slowest) for the following setup

import numpy as np import pandas as pd s = pd.Series([x > 0.5 for x in np.random.random(size=1000)]) 

Using np.where

>>> timeit np.where(s)[0] 12.7 µs ± 77.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

Using np.flatnonzero

>>> timeit np.flatnonzero(s) 18 µs ± 508 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

Using pd.Series.index

The time difference to boolean indexing was really surprising to me, since the boolean indexing is usually more used.

>>> timeit s.index[s] 82.2 µs ± 38.9 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each) 

Using boolean indexing

>>> timeit s[s].index 1.75 ms ± 2.16 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

If you need a np.array object, get the .values

>>> timeit s[s].index.values 1.76 ms ± 3.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

If you need a slightly easier to read version <-- not in original answer

>>> timeit s[s==True].index 1.89 ms ± 3.52 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

Using pd.Series.where <-- not in original answer

>>> timeit s.where(s).dropna().index 2.22 ms ± 3.32 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) >>> timeit s.where(s == True).dropna().index 2.37 ms ± 2.19 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 

Using pd.Series.mask <-- not in original answer

>>> timeit s.mask(s).dropna().index 2.29 ms ± 1.43 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) >>> timeit s.mask(s == True).dropna().index 2.44 ms ± 5.82 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 

Using list comprehension

>>> timeit [i for i in s.index if s[i]] 13.7 ms ± 40.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 

Using Python's built-in filter

>>> timeit [*filter(s.get, s.index)] 14.2 ms ± 28.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 

Using np.nonzero <-- did not work out of the box for me

>>> timeit np.nonzero(s) ValueError: Length of passed values is 1, index implies 1000. 

Using np.argwhere <-- did not work out of the box for me

>>> timeit np.argwhere(s).ravel() ValueError: Length of passed values is 1, index implies 1000. 

Also works: s.where(lambda x: x).dropna().index, and it has the advantage of being easy to chain pipe - if your series is being computed on the fly, you don't need to assign it to a variable.

Note that if s is computed from r: s = cond(r) than you can also use: r.where(lambda x: cond(x)).dropna().index.

You can use pipe or loc to chain the operation, this is helpful when s is an intermediate result and you don't want to name it.

s = pd.Series([True, False, True, True, False, False, False, True], index=list('ABCDEFGH')) out = s.pipe(lambda s_: s_[s_].index) # or out = s.pipe(lambda s_: s_[s_]).index # or out = s.loc[lambda s_: s_].index 

print(out) Index(['A', 'C', 'D', 'H'], dtype='object')