data frame per row select value from column based on value in row efficiently

The current set up of the problem is as follows:

How can I select the value to go into 'time_care_about' by variably selecting from the columns run_time and swim_time based on the value within run_or_swim in a efficient manner.

I'm not great at using Pandas so my current implementation of achieving creating the 'time_care_about' column is

df.apply(lambda x: x[f'{x['run_or_swim']}_time'],axis=1)

So per row it will check run_or_swim, to see if it is 'run' or 'swim', it will then look in the relevant column for the time and then we create the last column.
This is very slow as more columns are added, so is there a more efficient way of performing this? Or have I set up the problem poorly and abusing dataframes functionality.

e.g.
row 1

{x['run_or_swim']} = 'run'
f'{x['run_or_swim']}_time' = 'run_time'
x[f'{x['run_or_swim']}_time'] = x['run_time'] = 1.5

The example extends to ~8 columns this needs to be done for
e.g. run_distance, swim_distance,
run_elevation, swim_elevation

Using the suggestions below suggestions actually caused the time to be slower?
https://stackoverflow.com/questions/65568003/pandas-select-row-value-from-specific-column-based-on-value-from-other-columns

Thanks for any suggestions or links to relevant posts!

By request (and my mistake) extending the problem description:

For this example where iterating over multiple metrics ~ 500 in my use case , apply ends up performing faster than broadcasting.
apply ~ 1.12s
broadcasting ~ 1.45s

The set up I then use is:

for metric in [metric list]:
   df.apply(lambda x: x[f'{x['run_or_swim']}_{metric}'],axis=1)

and

for metric in [metric_list]:
   col_idx = (df.columns.to_numpy() == df[f"Run_or_swim"].add(
                        f'_{metric}').to_numpy()[:, None]).argmax(axis=1)
                    
 
 
    df[f"{metric}_care_about"] =df.values[df.index, col_idx]

Is it also possible to broadcast over the list of metrics?

You can use numpy and broadcasting:

col_idx = (df.columns.to_numpy() == df['Run_or_swim'].add('_time').to_numpy()[:, None]).argmax(axis=1)

df['time_care_about'] = df.values[df.index, col_idx]
print(df)

# Output
  Run_or_swim  run_time  swim_time time_care_about
0         run       1.5       18.0             1.5
1        swim       2.0       22.2            22.2

Using a variation of the indexing lookup:

idx, cols = pd.factorize(df['Run_or_swim']+'_time')

df['time_care_about'] = (df.reindex(cols, axis=1).to_numpy()
                         [np.arange(len(df)), idx]
                         )

Variant removing _time for the original columns:

idx, cols = pd.factorize(df['Run_or_swim'])

df['time_care_about'] = (df.set_axis(df.columns.str.removesuffix('_time'), axis=1)
                           .reindex(cols, axis=1).to_numpy()
                         [np.arange(len(df)), idx]
                        )

Output:

  Run_or_swim  run_time  swim_time  time_care_about
0         run       1.5       18.0              1.5
1        swim       2.0       22.2             22.2

From what I could test, your solution is not that bad I did some tests, and here are 3 other options tested on a random generated data frame with 10000 rows:

The test 0 was using your solution:

Test 0
time_0:  0.109017849

The test 1 was with a loop:

df1['time_care_about'] = np.nan
for i in range(len(df1)):
    if df1['run_or_swim'][i] == 'run':
        df1['time_care_about'][i] = df1['run_time'][i]
    else:
        df1['time_care_about'][i] = df1['swim_time'][i]
# time_1:  2.9705018997

As expected very slow compared to the first option.

The other approach is still slower than yours with 0.1215393543s that is using list comprehension:

df2['time_care_about'] = [df2['run_time'][i] if df2['run_or_swim'][i] == 'run' else df2['swim_time'][i] for i in range(len(df2))]

Last the faster approach by far was using numpy where statement:

df3['time_care_about'] = np.where(df3['run_or_swim'] == 'run', df3['run_time'], df3['swim_time'])

With a time of 0.0020861626s