Python 从数据帧groupby中提取具有计数的新列

我正在处理这样一个数据帧：

     Day  Hour         Prio  Value
0      1     6     Critical      1
1      1    16     Critical      1
2      1    17      Content      1
3      1    17          Low      1
6      1    19     Critical      1
7      1    20         High      1
8      2    10         High      1
9      2    10          Low      2

现在我想按天和小时分组，同时生成表示列

Prio

中每个值的计数的新列，该列当前位于列

value

中。所以我想实现这个结构：

     Day  Hour  Critical  Content  Low  High
0      1     6         1        0    0     0
1      1    16         1        0    0     0
2      1    17         0        1    1     0
6      1    19         1        0    0     0
7      1    20         0        0    0     1
8      2    10         0        0    2     1

我现在尝试了不同的事情，但都不太成功。我的目标是将此数据框与另一个包含其他列的数据框按天和小时合并，以便进一步聚合它们。特别是我需要优先级中每天/小时的百分比份额（至少始终存在一个非零值）

在过去的解决方案中，我迭代每一行以提取单个值，但这相当缓慢。我想让它尽可能高效，因为数据应该在bokeh服务器应用程序中实时更新。也许有一种解决方案不需要使用

itertuples

或类似的东西？谢谢大家!

df.groupby(['Day','Hour','Prio']).sum().unstack().fillna(0).astype(int)
#           Value                  
#Prio     Content Critical High Low
#Day Hour                          
#1   6          0        1    0   0
#    16         0        1    0   0
#    17         1        0    0   1
#    19         0        1    0   0
#    20         0        0    1   0
#2   10         0        0    1   2

如果需要，您可以进一步重置索引。

或者您可以尝试

pd.pivot_table(df,values='Value',index=['Day','Hour'],columns=['Prio'],aggfunc='sum')\
     .fillna(0).astype(int)


Out[22]: 
Prio      Content  Critical  High  Low
Day Hour                              
1   6           0         1     0    0
    16          0         1     0    0
    17          1         0     0    1
    19          0         1     0    0
    20          0         0     1    0
2   10          0         0     1    2

---

让我们使用

设置索引

，

取消堆栈

，

重置索引

，以及

重命名轴

：

df.set_index(['Day','Hour','Prio'])['Value']\
  .unstack().fillna(0)\
  .astype(int).reset_index()\
  .rename_axis(None,1)

输出：

   Day  Hour  Content  Critical  High  Low
0    1     6        0         1     0    0
1    1    16        0         1     0    0
2    1    17        1         0     0    1
3    1    19        0         1     0    0
4    1    20        0         0     1    0
5    2    10        0         0     1    2

---

考虑将结果转换为<代码> int <代码>，因为它们应该代表计数。我尝试了这个解决方案，但是经过时间测试，它给出了14.6毫秒每循环，对于5.84毫秒的每个循环，用@ Dyz的解决方案感谢<代码> PIVOTHOLT表< /代码>函数，这显示了与

取消堆栈

方法类似的出色性能，这两种方法正是我所需要的。因为我想计算相对值，所以我不需要将它们转换成整数，就不需要了。

unstack

是这里缺少的链接，我不知道没有它我怎么活下去。您的解决方案以及透视表都工作得非常好，与我之前的方法相比，性能非常好。谢谢