dataframe - 使用组合的 Julia Dataframes Groupby 链

Question

我正在尝试执行以下操作:

对于每一列，我想将键与列进行分组，计算出现的次数并仅保留键中最大出现的次数(我不想保留出现的数量，只保留与其对应的值) 。 我有很多列需​​要按行进行分组，我想知道是否有办法将它们链接在一起。

这是一个例子:

│ Row      │ KEY                              │ A             │
│          │ String                           │ String        │
├──────────┼──────────────────────────────────┼───────────────┤
│ 1        │ 44473                            │ ROCK          │
│ 2        │ 4f4ef                            │ CLASSICAL     │
│ 3        │ 0b8bd                            │ POP           │
│ 4        │ 57c94                            │ POP           │
│ 5        │ a7070                            │ RAP - HIP HOP │
│ 6        │ 1d9a3                            │ JAZZ          │
│ 7        │ 947fd                            │ POP           │

我在这里:

 per_key =  DataFrames.groupby(test, [:KEY, :A])
 combine(per_key, nrow => :A)

这给了我:

│ Row  │ KEY                              │ A                  │ nrow  │
│      │ String                           │ String             │ Int64 │
├──────┼──────────────────────────────────┼────────────────────┼───────┤
│ 1    │ 44473ff                          │ ROCK               │ 2     │
│ 2    │ 4f4effc                          │ CLASSICAL          │ 12    │
│ 3    │ 0b8bd64                          │ POP                │ 2     │
│ 4    │ 57c94f5                          │ POP                │ 2     │
│ 5    │ a7070e4                          │ RAP - HIP HOP      │ 1     │
│ 6    │ 1d9a3c7                          │ JAZZ               │ 1     │

如何为每个 KEY 获取最大“nrow”并将相应的值保留在“A”中。

我还必须一一处理许多其他列。

谢谢

Answer 1

我不是 100% 你想要的，但我认为这就是你正在寻找的东西:

julia> using DataFrames, StatsBase

julia> df = DataFrame(key=rand(1:10, 10^6),
                      A = rand(1:10, 10^6),
                      B = rand(1:10, 10^6),
                      C = rand(1:10, 10^6));

julia> gdf = groupby(df, :key);

julia> combine(gdf, valuecols(gdf) .=>
                    (x -> last(maximum(reverse, countmap(x)))) .=>
                    valuecols(gdf))
10×4 DataFrame
│ Row │ key   │ A     │ B     │ C     │
│     │ Int64 │ Int64 │ Int64 │ Int64 │
├─────┼───────┼───────┼───────┼───────┤
│ 1   │ 1     │ 8     │ 8     │ 1     │
│ 2   │ 10    │ 1     │ 2     │ 9     │
│ 3   │ 2     │ 6     │ 7     │ 3     │
│ 4   │ 4     │ 10    │ 7     │ 4     │
│ 5   │ 3     │ 8     │ 3     │ 1     │
│ 6   │ 7     │ 9     │ 7     │ 8     │
│ 7   │ 8     │ 2     │ 3     │ 2     │
│ 8   │ 5     │ 4     │ 3     │ 9     │
│ 9   │ 9     │ 3     │ 2     │ 10    │
│ 10  │ 6     │ 8     │ 4     │ 10    │

(在 master 上，您可以添加 renamecols=false kwarg 以避免最后一个 .=> valuecols(gdf))。

这里的关键函数是 countmap，它可以计算向量中不同值出现的次数，例如:

julia> countmap(gdf[1].A)
Dict{Int64,Int64} with 10 entries:
  7  => 10028
  4  => 10130
  9  => 10007
  10 => 9841
  2  => 10090
  3  => 9985
  5  => 10022
  8  => 10262
  6  => 10103
  1  => 10128

剩下的只是它的包装。您需要reverse将key => value更改为value => key顺序以确保maximum选择正确的组(请注意，如果有两个具有相同计数的组，您的问题将不会有唯一的解决方案)，然后我们使用 last 来提取组(因为您不想保留计数) .

编辑:

现在我意识到argmax适用于字典，所以你可以写:

julia> combine(gdf, valuecols(gdf) .=>
                    argmax∘countmap .=>
                    valuecols(gdf))
10×4 DataFrame
│ Row │ key   │ A     │ B     │ C     │
│     │ Int64 │ Int64 │ Int64 │ Int64 │
├─────┼───────┼───────┼───────┼───────┤
│ 1   │ 1     │ 8     │ 8     │ 1     │
│ 2   │ 10    │ 1     │ 2     │ 9     │
│ 3   │ 2     │ 6     │ 7     │ 3     │
│ 4   │ 4     │ 10    │ 7     │ 4     │
│ 5   │ 3     │ 8     │ 3     │ 1     │
│ 6   │ 7     │ 9     │ 7     │ 8     │
│ 7   │ 8     │ 2     │ 3     │ 2     │
│ 8   │ 5     │ 4     │ 3     │ 9     │
│ 9   │ 9     │ 3     │ 2     │ 10    │
│ 10  │ 6     │ 8     │ 4     │ 10    │