Question

我有一个看起来像这样的系列：

            delivery
2007-04-26  706           23
2007-04-27  705           10
            706         1089
            708           83
            710           13
            712           51
            802            4
            806            1
            812            3
2007-04-29  706           39
            708            4
            712            1
2007-04-30  705            3
            706         1016
            707            2
...
2014-11-04  1412          53
            1501           1
            1502           1
            1512           1
2014-11-05  1411          47
            1412        1334
            1501          40
            1502         433
            1504         126
            1506         100
            1508           7
            1510           6
            1512          51
            1604           1
            1612           5
Length: 26255, dtype: int64

其中查询为：df.groupby([df.index.date, 'delivery']).size()

对于每一天，我需要提取出量最多的交货号码。我觉得它会像：

df.groupby([df.index.date, 'delivery']).size().idxmax(axis=1)

但是，这只会返回整个数据帧的idxmax;相反，我需要每天的第二级idmax（不是日期而是交付号），而不是整个数据帧（即它返回一个向量）。

关于如何实现这一目标的任何想法？

Answer 1

您的示例代码不起作用，因为idxmax是在groupby操作之后执行的（所以在整个数据帧上）

我不确定如何在多级索引上使用idxmax，所以这是一个简单的解决方法。

设置数据：

import pandas as pd
d= {'Date': ['2007-04-26', '2007-04-27', '2007-04-27', '2007-04-27',
             '2007-04-27', '2007-04-28', '2007-04-28'], 
        'DeliveryNb': [706, 705, 708, 450, 283, 45, 89],
        'DeliveryCount': [23, 10, 1089, 82, 34, 100, 11]}

df = pd.DataFrame.from_dict(d, orient='columns').set_index('Date')
print df

输出

            DeliveryCount  DeliveryNb
Date                                 
2007-04-26             23         706
2007-04-27             10         705
2007-04-27           1089         708
2007-04-27             82         450
2007-04-27             34         283
2007-04-28            100          45
2007-04-28             11          89

创建自定义功能：

诀窍是使用reset_index（）方法（这样你就可以轻松获得组的整数索引）

def func(df):
    idx = df.reset_index()['DeliveryCount'].idxmax()
    return df['DeliveryNb'].iloc[idx]

应用它：

g = df.groupby(df.index)
g.apply(func)

结果：

Date
2007-04-26    706
2007-04-27    708
2007-04-28     45
dtype: int64

Answer 2

假设你有这个系列：

            delivery
2001-01-02  0           2
            1           3
            6           2
            7           2
            9           3
2001-01-03  3           2
            6           1
            7           1
            8           3
            9           1
dtype: int64

如果您希望每个日期的一次投放具有最大值，则可以使用idxmax：

dates = series.index.get_level_values(0)
series.loc[series.groupby(dates).idxmax()]

产量

            delivery
2001-01-02  1           3
2001-01-03  8           3
dtype: int64

如果您希望每个日期的所有投放具有最大值use transform to generate a boolean mask：

mask = series.groupby(dates).transform(lambda x: x==x.max()).astype('bool')
series.loc[mask]

产量

            delivery
2001-01-02  1           3
            9           3
2001-01-03  8           3
dtype: int64

这是我用来生成series的代码：

import pandas as pd
import numpy as np

np.random.seed(1)
N = 20
rng = pd.date_range('2001-01-02', periods=N//2, freq='4H')
rng = np.random.choice(rng, N, replace=True)
rng.sort()
df = pd.DataFrame(np.random.randint(10, size=(N,)), columns=['delivery'], index=rng)
series = df.groupby([df.index.date, 'delivery']).size()

Answer 3

如果您有以下数据框（如果需要，您可以随时重置索引：df = df.reset_index()：

  Date  Del_Count  Del_Nb
0  1/1      14      19   <
1           11      17
2  2/2      25      29   <
3           21      27
4           22      28
5  3/3      34      36
6           37      37
7           31      39   <

要查找每个日期的最大值并提取相关的Del_Count，您可以使用：

df = df.ix[df.groupby(['Date'], sort=False)['Del_Nb'].idxmax()][['Date','Del_Count','Del_Nb']]

哪个会如此：

 Date  Del_Count  Del_Nb
0  1/1         14      19
2  2/2         25      29
7  3/3         31      39

Python pandas idxmax用于数据帧中的多个索引

3 个答案: