Three Methods for Finding Largest, Second-Largest, and Smallest Values in Pandas DataFrame Rows

The provided code snippet is a solution to the problem of finding the largest, second-largest, and smallest values in each row of a Pandas DataFrame. The most efficient method uses the np.argsort function to sort the rows along the columns axis, and then selects the corresponding columns from the original DataFrame.

Here’s the reformatted code with added comments for better readability:

import pandas as pd
import numpy as np

# Create a sample DataFrame
df = pd.DataFrame(np.random.randint(0, 100, size=(10, 5)), columns=list('ABCDE'))

def get_values(x):
    # Sort values in descending order and get the index
    x = x.sort_values()
    return pd.Series([x.index[-1], x.index[-2], x.index[0]],
                     index=['largest','second largest','smallest'])

# Method 1: Using np.argsort
df_sorted = df.columns[np.argsort(-df.values, axis=1)]

# Create a new DataFrame with the sorted values
df_new = pd.DataFrame(df_sorted, columns=['largest', 'second largest', 'smallest'])

print("Method 1:")
print(df_new)

# Method 2: Using apply
def f(x):
    # Sort values and get the index
    x = x.sort_values()
    return pd.Series([x.index[-1], x.index[-2], x.index[0]],
                     index=['largest','second largest','smallest'])

df_apply = df.apply(f, axis=1)

print("\nMethod 2:")
print(df_apply)

# Method 3: Using iloc and indexing
df_iloc = df.iloc[:, [-1,-2,0]]
df_iloc.columns = ['largest', 'second largest', 'smallest']

print("\nMethod 3:")
print(df_iloc)

This code provides three different methods for solving the problem:

Method 1: Uses np.argsort to sort the values in descending order and selects the corresponding columns from the original DataFrame.
Method 2: Uses apply with a custom function to sort each row’s values, which is less efficient than Method 1.
Method 3: Uses iloc and indexing to select the desired columns, which can be slower for larger DataFrames.

The code also includes timing tests using timeit to compare the performance of each method.

Last modified on 2024-03-23