在Julia数据框中计算每个组的连续行之间的差异。

Question

我有一个名为df的数据框：

using DataFrames

df = DataFrame(group = ["A", "A", "A", "A", "B", "B", "B", "B"],
               value = [2,1,4,3,3,5,2,1])

8×2 DataFrame
 Row │ group   value 
     │ String  Int64 
─────┼───────────────
   1 │ A           2
   2 │ A           1
   3 │ A           4
   4 │ A           3
   5 │ B           3
   6 │ B           5
   7 │ B           2
   8 │ B           1

我想要计算每个组中连续行的column value与前一个值的差异。偏移量应为NaN、0或缺失。以下是所需的输出：

8×3 DataFrame
 Row │ group   value  diff    
     │ String  Int64  Float64 
─────┼────────────────────────
   1 │ A           2    NaN
   2 │ A           1     -1.0
   3 │ A           4      3.0
   4 │ A           3     -1.0
   5 │ B           3    NaN
   6 │ B           5      2.0
   7 │ B           2     -3.0
   8 │ B           1     -2.0

我在想，有没有人知道如何在Julia中计算每组连续行之间的差异？

- Quinten

Answer 1

使用DataFrames.jl(您可以将missing替换为任何您喜欢的值)：

julia> select(groupby(df, :group),
              :value => (x -> [missing; diff(x)]) => :diff)
8×2 DataFrame
 Row │ group   diff
     │ String  Int64?
─────┼─────────────────
   1 │ A       missing
   2 │ A            -1
   3 │ A             3
   4 │ A            -1
   5 │ B       missing
   6 │ B             2
   7 │ B            -3
   8 │ B            -1

使用DataFramesMeta.jl：

julia> @chain df begin
           groupby(:group)
           @select :diff = [missing; diff(:value)]
       end
8×2 DataFrame
 Row │ group   diff
     │ String  Int64?
─────┼─────────────────
   1 │ A       missing
   2 │ A            -1
   3 │ A             3
   4 │ A            -1
   5 │ B       missing
   6 │ B             2
   7 │ B            -3
   8 │ B            -1

通常情况下，Julia中的diff与R中的类似，会产生一个较少的行数（而且语法更简单：

julia> combine(groupby(df, :group), :value => diff => :diff)
6×2 DataFrame
 Row │ group   diff
     │ String  Int64
─────┼───────────────
   1 │ A          -1
   2 │ A           3
   3 │ A          -1
   4 │ B           2
   5 │ B          -3
   6 │ B          -1

julia> @chain df begin
           groupby(:group)
           @combine :diff = diff(:value)
       end
6×2 DataFrame
 Row │ group   diff
     │ String  Int64
─────┼───────────────
   1 │ A          -1
   2 │ A           3
   3 │ A          -1
   4 │ B           2
   5 │ B          -3
   6 │ B          -1

另一种方法是使用ShiftedArrays.jl中的lag:

julia> using ShiftedArrays: lag

julia> @chain df begin
           groupby(:group)
           @combine :diff = :value - lag(:value)
       end
8×2 DataFrame
 Row │ group   diff
     │ String  Int64?
─────┼─────────────────
   1 │ A       missing
   2 │ A            -1
   3 │ A             3
   4 │ A            -1
   5 │ B       missing
   6 │ B             2
   7 │ B            -3
   8 │ B            -1

- Bogumił Kamiński