Pandas DataFrame: Get indexes of rows where column meets certain condition

Updated: February 20, 2024 By: Guest Contributor Post a comment


Working with data in Python often involves the use of Pandas, a powerful and flexible data analysis and manipulation library. Pandas DataFrames are central to many data science and analytics tasks, allowing for efficient storage and manipulation of tabular data. A common requirement when working with DataFrames is to identify rows based on specific conditions. This tutorial will guide you through various techniques to retrieve index positions of DataFrame rows where certain conditions on column values are met.


Before we dive into the examples, ensure you have Pandas installed in your environment:

pip install pandas

Also, import Pandas in your script:

import pandas as pd

Preparing a Simple DataFrmae

Through out this tutorial, we’ll use this DataFrame for practice:

import pandas as pd

data = {"Name": ["Anna", "Bob", "Cathy", "David"], "Age": [28, 34, 22, 42]}
df = pd.DataFrame(data)

This prints:

    Name  Age
0   Anna   28
1    Bob   34
2  Cathy   22
3  David   42

Basic Example

To get the index of rows where the age is over 30:

index_over_30 = df.index[df['Age'] > 30].tolist() print(index_over_30)

This will output:

[1, 3]

Using `query` Method

Another way to select rows based on conditions is using the `query` method. This method allows for a more SQL-like query:

over_30 = df.query('Age > 30').index.tolist() print(over_30)


[1, 3]

Boolean Indexing with Multiple Conditions

You can also retrieve indexes using boolean indexing with multiple conditions. For instance, to find indexes of people aged over 30 whose names start with ‘B’:

condition = (df['Age'] > 30) & (df['Name'].str.startswith('B')) index_meeting_condition = df.loc[condition].index.tolist() print(index_meeting_condition)



Using `loc` and `iloc` Methods

Both `loc` and `iloc` can be used to select data by label or position, which can be handy when filtering rows based on conditions:

over_30_loc = df.loc[df['Age'] > 30].index.to_list() print(over_30_loc)

Similarly, using `iloc` (however, remember that `iloc` works with integer positions):

over_30_iloc = df.iloc[(df['Age'] > 30).values].index.tolist() print(over_30_iloc)

Advanced Filtering Using `apply`

For more complex conditions, you might want to use the `apply` method. This allows you to define an arbitrary function to evaluate each row:

def custom_condition(row): return row['Age'] > 30 & row['Name'].startswith('D') custom_indexes = df[df.apply(custom_condition, axis=1)].index.tolist() print(custom_indexes)



Filtering with Regular Expressions

When dealing with textual data, regular expressions can be particularly useful. You can use them to filter rows based on complex patterns in string columns:

import re def regex_condition(s): return bool(re.match('^[B].*', s)) regex_indexes = df[df['Name'].apply(regex_condition)].index.tolist() print(regex_indexes)



Combining Methods for Complex Filtering

All the techniques shown can be combined in various ways to achieve complex filtering. Let’s look at a compound example:

complex_condition = (df['Age'].apply(lambda x: x > 30)) & (df['Name'].apply(lambda s: s.startswith('D'))) complex_indexes = df.loc[complex_condition].index.tolist() print(complex_indexes)



Performance Considerations

When working with large DataFrames, consider performance. Vectorized operations are usually preferred due to their efficiency over methods like `apply`. Testing and profiling different methods based on your specific use case is advisable.


This guide has covered several techniques to find the indexes of DataFrame rows where a column meets a certain condition. Whether you’re performing simple or complex queries, Pandas provides powerful tools to efficiently select data based on your criteria.