獲取 Dataframe Pandas 中最大值的列和行索引

Question

我想知道是否有辦法找到數據框中最大值的位置（列和行索引）。 因此，例如，如果我的數據框如下所示：

   A         B         C         D         E
0  100       9         1         12        6
1  80        10        67        15        91
2  20        67        1         56        23
3  12        51        5         10        58
4  73        28        72        25        1

如何使用 Pandas 獲得如下所示的結果： [0, 'A'] ？

Answer 1

使用np.argmax

NumPy的argmax可能會有所幫助：

>>> df.stack().index[np.argmax(df.values)]
(0, 'A')

在步驟中

df.values是一個二維NumPy數組：

>>> df.values
array([[100,   9,   1,  12,   6],
       [ 80,  10,  67,  15,  91],
       [ 20,  67,   1,  56,  23],
       [ 12,  51,   5,  10,  58],
       [ 73,  28,  72,  25,   1]])

argmax為您提供“flattened”數組最大值的索引：

>>> np.argmax(df.values)
0

現在，您可以使用此索引查找堆疊數據框上的行列位置：

>>> df.stack().index[0]
(0, 'A')

快速替代

如果您需要快速，請盡可能少地執行。 僅在NumPy數組上工作以找到索引np.argmax似乎是最好的：

v = df.values
i, j = [x[0] for x in np.unravel_index([np.argmax(v)], v.shape)]
[df.index[i], df.columns[j]]

結果：

[0, 'A']

計時

時序最適合lareg數據幀：

df = pd.DataFrame(data=np.arange(int(1e6)).reshape(-1,5), columns=list('ABCDE'))

排序最慢到最快：

面具：

%timeit df.mask(~(df==df.max().max())).stack().index.tolist()
33.4 ms ± 982 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

棧IDMAX

%timeit list(df.stack().idxmax())
17.1 ms ± 139 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

棧argmax

%timeit df.stack().index[np.argmax(df.values)]
14.8 ms ± 392 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

哪里

%%timeit
i,j = np.where(df.values == df.values.max())
list((df.index[i].values.tolist()[0],df.columns[j].values.tolist()[0]))

4.45 ms ± 84.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Argmax-unravel_index

%%timeit

v = df.values
i, j = [x[0] for x in np.unravel_index([np.argmax(v)], v.shape)]
[df.index[i], df.columns[j]]

499 µs ± 12 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

相比

d = {'name': ['Mask', 'Stack-idmax', 'Stack-argmax', 'Where', 'Argmax-unravel_index'],
     'time': [33.4, 17.1, 14.8, 4.45, 499],
     'unit': ['ms', 'ms', 'ms', 'ms', 'µs']}


timings = pd.DataFrame(d)
timings['seconds'] = timings.time * timings.unit.map({'ms': 1e-3, 'µs': 1e-6})
timings['factor slower'] = timings.seconds / timings.seconds.min()
timings.sort_values('factor slower')

輸出：

                   name    time unit   seconds  factor slower
4  Argmax-unravel_index  499.00   µs  0.000499       1.000000
3                 Where    4.45   ms  0.004450       8.917836
2          Stack-argmax   14.80   ms  0.014800      29.659319
1           Stack-idmax   17.10   ms  0.017100      34.268537
0                  Mask   33.40   ms  0.033400      66.933868

因此，對於大型數據幀，“Argmax-unravel_index”版本似乎要快一到兩個數量級，即通常速度最重要的地方。

Answer 2

對於具有MultiIndex Series使用stack對於idxmax的索引使用MultiIndex ：

print (df.stack().idxmax())
(0, 'A')

print (list(df.stack().idxmax()))
[0, 'A']

詳情：

print (df.stack())
0  A    100
   B      9
   C      1
   D     12
   E      6
1  A     80
   B     10
   C     67
   D     15
   E     91
2  A     20
   B     67
   C      1
   D     56
   E     23
3  A     12
   B     51
   C      5
   D     10
   E     58
4  A     73
   B     28
   C     72
   D     25
   E      1
dtype: int64

Answer 3

mask + max

df.mask(~(df==df.max().max())).stack().index.tolist()
Out[17]: [(0, 'A')]

Answer 4

在我看來，對於更大的數據集，stack（）變得效率低下，讓我們使用np.where來返回索引位置：

i,j = np.where(df.values == df.values.max())
list((df.index[i].values.tolist()[0],df.columns[j].values.tolist()[0]))

輸出：

[0, 'A']

大數據的計時：

df = pd.DataFrame(data=np.arange(10000).reshape(-1,5), columns=list('ABCDE'))

np.where方法

> %%timeit i,j = np.where(df.values == df.values.max())
> list((df.index[i].values.tolist()[0],df.columns[j].values.tolist()[0]))

1000個循環，最佳3：每循環364μs

其他堆棧方法

> %timeit df.mask(~(df==df.max().max())).stack().index.tolist()

100個循環，最佳3：每循環7.68毫秒

> %timeit df.stack().index[np.argmax(df.values)`]

10個循環，最佳3：50.5 ms每個循環

> %timeit list(df.stack().idxmax())

1000循環，最佳3：每循環1.58毫秒

更大的數據幀：

df = pd.DataFrame(data=np.arange(100000).reshape(-1,5), columns=list('ABCDE'))

分別：

1000 loops, best of 3: 1.62 ms per loop
10 loops, best of 3: 18.2 ms per loop
100 loops, best of 3: 5.69 ms per loop
100 loops, best of 3: 6.64 ms per loop

Answer 5

這應該工作：

def max_df(df):
    m = None
    p = None
    for idx, item in enumerate(df.idxmax()):
        c = df.columns[item]
        val = df[c][idx]
        if m is None or val > m:
            m = val
            p = idx, c
    return p

這使用idxmax函數，然后比較它返回的所有值。

用法示例：

>>> df

     A  B
0  100  9
1   90  8
>>> max_df(df)

(0, 'A')

這是一個單行（為了好玩）：

def max_df2(df):
    return max((df[df.columns[item]][idx], idx, df.columns[item]) for idx, item in enumerate(df.idxmax()))[1:]

Answer 6

print('Max value:', df.stack().max())
print('Parameters :', df.stack().idxmax())

這是imho的最佳方式。

Answer 7

簡單、快速、一個班輪：

loc = [df.max(axis=1).idxmax(), df.max().idxmax()]

（對於大型數據幀， .stack() 可能會很慢。）