With wide data it can be easier to first reshape with wide_to_long. This creates 2 columns ['Duration', 'Value'], and the MultiIndex tells us which number it was. There is no reliance on any specific column ordering.

import pandas as pd

df = pd.wide_to_long(df, i='Sequence', j='num', stubnames=['Duration', 'Value'])
df.loc[[df.Duration.idxmax()]]

              Duration  Value
Sequence num                 
1008     3         981     82

Without using numpy wizardry:

• First, there are some really great solutions to this problem, by others.
• Data will be that provided in the question, as df

# find the max value in the Duration columns
max_value = max(df.filter(like='Dur', axis=1).max().tolist())

# get a Boolean match of the dataframe for max_value
df_max = df[df == mv]

# get the row index
max_index = df_max.dropna(how='all').index[0]

# get the column name
max_col = df_max.dropna(axis=1, how='all').columns[0]

# get column index
max_col_index = df.columns.get_loc(max_col)

# final
df.iloc[max_index, [0, max_col_index, max_col_index + 1]]

Output:

Sequence     1008
Duration3     981
Value3         82
Name: 7, dtype: int64

Update

• Last night, actually 4 a.m., I dismissed a better solution, because I was overly tired.
  • I used max_value = max(df.filter(like='Dur', axis=1).max().tolist()), to return the maximum value within the Duration columns
  • Instead of max_col_name = df.filter(like='Dur', axis=1).max().idxmax(), to return the column name where the maximum value occurs
  • I did that because my addled brain told me I was returning the max value of the column names, instead of the maximum value in the column. For example:

test = ['Duration5', 'Duration2', 'Duration3']
print(max(test))
>>> 'Duration5'

• This is why being overtired, is a poor problem solving condition
• With sleep, and coffee, a more efficient solution
  • Similar to others, in the use of idmax

New & Improved Solution:

# column name with max duration value
max_col_name = df.filter(like='Dur', axis=1).max().idxmax()

# index of max_col_name
max_col_idx =df.columns.get_loc(max_col_name)

# row index of max value in max_col_name
max_row_idx = df[max_col_name].idxmax()

# output with .loc
df.iloc[max_row_idx, [0, max_col_idx, max_col_idx + 1 ]]

Output:

Sequence     1008
Duration3     981
Value3         82
Name: 7, dtype: int64

Methods used:

• pandas.DataFrame.max
• pandas.DataFrame.filter
• pandas.DataFrame.idxmax
• pandas.Index.get_loc
• pandas.DataFrame.iloc

You can obtain the index of the maximum value of a column using:

>>> idx = df['Duration3'].idxmax()
>>> idx
7

And the relevant columns only using:

>>> df_cols = df[['Sequence', 'Duration3', 'Value3']]
>>> df_cols.loc[idx]
Sequence     1008
Duration3     981
Value3         82
Name: 7, dtype: int64

So, simply wrap all that up into one nice function:

def get_max(df, i):
    idx = df[f'Duration{i}'].idxmax()
    df_cols = df[['Sequence', f'Duration{i}', f'Value{i}']]
    return df_cols.loc[idx]

And loop over 1..3:

>>> max_rows = [get_max(i) for i in range(1, 4)]
>>> print('\n\n'.join(map(str, max_rows)))
Sequence     1003
Duration1     685
Value1         57
Name: 2, dtype: int64

Sequence     1010
Duration2     722
Value2         63
Name: 9, dtype: int64

Sequence     1008
Duration3     981
Value3         82
Name: 7, dtype: int64

If you want to reduce these 3 down to a single maximum row, you can do the following:

>>> pairs = enumerate(max_rows, 1)
>>> by_duration = lambda x: x[1][f'Duration{x[0]}']
>>> i, max_row = max(pairs, key=by_duration)
>>> max_row
Sequence     1008
Duration3     981
Value3         82
Name: 7, dtype: int64

Here is another way ,

m=df.set_index('Sequence') #set Sequence as index
n=m.filter(like='Duration') #gets all columns with the name Duration
s=n.idxmax()[n.eq(n.values.max()).any()]
#output Duration3    1008
d = dict(zip(m.columns[::2],m.columns[1::2])) #create a mapper dict
#{'Duration1': 'Value1', 'Duration2': 'Value2', 'Duration3': 'Value3'}
final=m.loc[s.values,s.index.union(s.index.map(d))].reset_index()

   Sequence  Duration3  Value3
0      1008        981      82

If I understand the question correctly, given the followind dataframe:

df = pd.DataFrame(data={'Seq': [1, 2, 3], 'Dur1': [2, 7, 3],'Val1': ['x', 'y', 'z'],'Dur2': [3, 5, 1], 'Val2': ['a', 'b', 'c']})
    Seq  Dur1 Val1  Dur2 Val2
0    1     2    x     3    a
1    2     7    y     5    b
2    3     3    z     1    c

These 5 lines of code solve your problem:

dur_col = [col_name for col_name in df.columns if col_name.startswith('Dur')] # ['Dur1', 'Dur2'] 
max_dur_name = df.loc[:, dur_col].max().idxmax()
val_name = "Val" + str([int(s) for s in max_dur_name if s.isdigit()][0])

filter_col = ['Seq', max_dur_name, val_name]

df_res = df[filter_col].sort_values(max_dur_name, ascending=False).head(1)

And you get:

   Seq  Dur1 Val1 
1    2     7    y  

Code explanation:

I automatically get the columns that start with 'Dur', and I find the column name with a longer duration:

dur_col = [col_name for col_name in df.columns if col_name.startswith('Dur')] # ['Dur1', 'Dur2'] 
max_dur_name = df.loc[:, dur_col].max().idxmax()
val_name = "Val" + str([int(s) for s in max_dur_name if s.isdigit()][0])

Choose the columns I'm interested in:

filter_col = ['Seq', max_dur_name, val_name]

Filter the columns that interest me, I order for max_dur_name and I get the search result:

df_res = df[filter_col].sort_values(max_dur_name, ascending=False).head(1)

# output:
   Seq  Dur1 Val1 
1    2     7    y   

A bit similar to @Massifox's answer, but I think is different enough to be worthy to be added.

mvc = df[[name for name in df.columns if 'Duration' in name]].max().idxmax()
mvidx = df[mvc].idxmax()
valuecol = 'Value' + mvc[-1]
df.loc[mvidx, ['Sequence', mvc, valuecol]]

1. First I get the column name mvc where the maximum value is located (mvc is 'Durantion3' following your example).
2. Then I get the row index mvidx of the maximum value (mvidx is 7).
3. Then I build the correct Value column (valuecol is 'Value3').

4. Finally with loc I select the desired output, which is:

   Sequence     1008
   Duration3     981
   Value3         82
   Name: 7, dtype: int64
   

if len(df[df[dur1]>=df[dur2].max()])==0:
    if len(df[df[dur2]>=df[dur3].max()])==0:
        print(df[df[dur3].idmax()][[seq,dur3,val3]])
    else:
        print(df[df[dur2].idmax()][[seq,dur2,val2]])
else:
   if len(df[df[dur1]>=df[dur3].max()])==0:
       print(df[df[dur3].idmax()][[seq,dur3,val3]])
   else:
       print(df[df[dur1].idmax()][[seq,dur1,val1]])