Python.GroupBy（）.Sum（）Having子句

因此，我有一个数据框，有3列“订单ID”、“订单数量”和“填充数量”

我想对每个订单的填充数量求和，然后将其与订单数量进行比较，理想情况下，只要聚合填充数量大于订单数量，我将只返回一个提供订单ID的数据帧

在SQL中，我想我要找的是

SELECT * FROM DataFrame GROUP BY Order ID, Order Qty HAVING sum(Fill Qty)>Order Qty

到目前为止，我有：

SumFills= DataFrame.groupby(['Order ID','Order Qty']).sum()

输出：

---

---

---

上面已经聚合了，我希望返回[4,5,6]的列表/数组，因为这些列表/数组具有

sum（fill qty）>Order qty

查看原始数据帧：

In [57]: print original_df
    Order Id  Fill Qty  Order Qty
0          1       419        334
1          2       392        152
2          3       167        469
3          4       470        359
4          5       447        441
5          6       154        190
6          7       365        432
7          8       209        181
8          9       140        136
9         10       112        358
10        11       384        302
11        12       307        376
12        13       119        237
13        14       147        342
14        15       279        197
15        16       280        137
16        17       148        381
17        18       313        498
18        19       193        328
19        20       291        193
20        21       100        357
21        22       161        286
22        23       453        168
23        24       349        283

创建并查看新的数据框，对填充数量求和：

In [58]: new_df = original_df.groupby(['Order Id','Order Qty'], as_index=False).sum()

In [59]: print new_df
    Order Id  Order Qty  Fill Qty
0          1        334       419
1          2        152       392
2          3        469       167
3          4        359       470
4          5        441       447
5          6        190       154
6          7        432       365
7          8        181       209
8          9        136       140
9         10        358       112
10        11        302       384
11        12        376       307
12        13        237       119
13        14        342       147
14        15        197       279
15        16        137       280
16        17        381       148
17        18        498       313
18        19        328       193
19        20        193       291
20        21        357       100
21        22        286       161
22        23        168       453
23        24        283       349

仅将新数据帧切片到填充数量>订单数量的行：

In [60]: new_df = new_df.loc[new_df['Fill Qty'] > new_df['Order Qty'],:]

In [61]: print new_df
    Order Id  Order Qty  Fill Qty
0          1        334       419
1          2        152       392
3          4        359       470
4          5        441       447
7          8        181       209
8          9        136       140
10        11        302       384
14        15        197       279
15        16        137       280
19        20        193       291
22        23        168       453
23        24        283       349

---

您的数据是否有多个订单ID相同的行？如果是这样，所有这些行的订单数量是否保持静态？每个订单将有一条记录，因此每个订单ID都有一个与之关联的订单数量是的。没有问题，您介意将此标记为已解决吗？谢谢

In [60]: new_df = new_df.loc[new_df['Fill Qty'] > new_df['Order Qty'],:]

In [61]: print new_df
    Order Id  Order Qty  Fill Qty
0          1        334       419
1          2        152       392
3          4        359       470
4          5        441       447
7          8        181       209
8          9        136       140
10        11        302       384
14        15        197       279
15        16        137       280
19        20        193       291
22        23        168       453
23        24        283       349