Pandas DataFrame: Find row with the closest value to a given number (4 ways)

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


When analyzing data, finding the row in a Pandas DataFrame that contains a value closest to a given number can be a common but vital task. This capability could help in a range of scenarios, from finding the nearest dataset entry to a reference point, to pinpointing exact or near-exact matches for comparison purposes. This tutorial is structured to guide you from basic implementations to more advanced techniques for identifying rows based on proximity to a specific value.


Before we dive into the methods, ensure you have the following prerequisites covered:

  • An environment to run Python code (Jupyter Notebook, Google Colab, Python script, etc.)
  • Pandas library installed. If not, you can install it using pip install pandas.

Basic Method: Using abs and idxmin

Let’s start with a straight-forward approach to finding the row with the closest numeric value to a given target. Assume we have a DataFrame df with a column ColumnA where we want to find the closest value to target_value.

import pandas as pd

df = pd.DataFrame({
    'ColumnA': [7, 14, 21, 28, 35, 42]
target_value = 25

# Calculate the absolute difference
abs_difference = abs(df['ColumnA'] - target_value)

# Finding the index of the minimum value
closest_index = abs_difference.idxmin()

# Retrieve the row
closest_row = df.iloc[closest_index]



ColumnA    28
Name: 3, dtype: int64

This example illustrates how simple it is to find the row with the value closest to the target using basic arithmetic operations and DataFrame methods.

Intermediate Method: Custom Function with apply

For a bit more flexibility, you can create a custom function that checks for the closest value and then use apply to check each row. This is particularly handy when dealing with multiple columns.

def find_closest(row, target_value, column_name):
    return abs(row[column_name] - target_value)

df['difference'] = df.apply(find_closest, args=(25, 'ColumnA'), axis=1)
closest_row = df.loc[df['difference'].idxmin()]



ColumnA       28
difference     3
Name: 3, dtype: int64

This method provides more control and can easily be adapted to different scenarios by changing the function’s parameters.

Advanced Method: Combining with NumPy

For cases where performance is critical, combining Pandas with NumPy can offer a significant speed boost, especially for large DataFrames. NumPy offers efficient array computations, which can be leveraged to find the closest value.

import pandas as pd

import numpy as np

df = pd.DataFrame({"ColumnA": np.arange(1, 100)})
target_value = 33

# Convert the target column to a NumPy array
values = df["ColumnA"].to_numpy()

# Find the index of the closest value
closest_index = (np.abs(values - target_value)).argmin()

# Retrieve the row
closest_row = df.iloc[closest_index]



ColumnA    33
Name: 32, dtype: int64

By taking advantage of NumPy’s argmin method combined with Pandas, you can achieve both the flexibility of Pandas and the speed of NumPy.

Advanced Method: Using a Custom Comparator with sort_values

Another advanced approach is employing a custom comparator to sort the DataFrame based on the proximity to the target value and then selecting the top row. This method is useful when you may want to find not just the closest value but maybe the top n closest values.

df['difference'] = abs(df['ColumnA'] - target_value)
df_sorted = df.sort_values(by='difference')
closest_rows = df_sorted.head(n)

# For finding the single closest row
closest_row = closest_rows.iloc[0]


This method allows for a more nuanced approach, providing the capability to filter for several close matches rather than a singular best match.


Finding the row in a Pandas DataFrame that is closest to a given value is an essential operation in data analysis. This tutorial provided a solid foundation, from straightforward arithmetic to more sophisticated methods involving custom functions and integration with NumPy, demonstrating a variety of strategies depending on your specific needs. These approaches enable both the identification of single closest matches and the exploration of multiple close matches, offering flexibility in data analysis tasks.