为每个 ID 分配唯一值

Question

我需要按升序将每个id替换为唯一值。

数据

df = DataFrame(id=[1,1,1,3,3,3,4,4,4,7,7,7],
               time=[0,1,2,0,1,2,0,1,2,0,1,2],
               conc=[missing,100,70,missing,60,40, missing,90,80, missing,99,70])

Output

df1 = DataFrame(id=[1,1,1,2,2,2,3,3,3,4,4,4],
                time=[0,1,2,0,1,2,0,1,2,0,1,2],
                conc=[missing,100,70,missing,60,40, missing,90,80, missing,99,70])

我尝试使用此循环，但是当我尝试编织文档时，此循环失败。

f = 0
df.id = 0
for b = 1:nrow(df)
    if df.time[b] == 0
       f = f + 1
       df.id[b] = f
    else
       df.id[b] = f
    end
end

Answer 1

您的循环通常是正确的，但是在 Julia 中，当您想要为 dataframe 或矩阵的列分配值时，您正在执行广播，并且广播操作需要在运算符之前或 ZC1C4245274C 之后的附加点。 所以将 df.id 分配给 0 的正确方法是df.id.= 0 。

Answer 2

除了@hhilrun 的上述评论之外，这里有一些紧凑的方法来做你想做的事情（我在每种情况下都创建一个新的数据框，而不是覆盖源数据框）。

选项 1. 使用 StatsBase.jl

julia> using StatsBase

julia> transform(df, :id => denserank => :id)
12×3 DataFrame
 Row │ id     time   conc    
     │ Int64  Int64  Int64?  
─────┼───────────────────────
   1 │     1      0  missing 
   2 │     1      1      100
   3 │     1      2       70
   4 │     2      0  missing 
   5 │     2      1       60
   6 │     2      2       40
   7 │     3      0  missing 
   8 │     3      1       90
   9 │     3      2       80
  10 │     4      0  missing 
  11 │     4      1       99
  12 │     4      2       70

选项 2. 使用 split-apply-combine：

julia> df2 = copy(df);

julia> df2.id = groupindices(groupby(df2, :id));

julia> df2
12×3 DataFrame
 Row │ id      time   conc    
     │ Int64?  Int64  Int64?  
─────┼────────────────────────
   1 │      1      0  missing 
   2 │      1      1      100
   3 │      1      2       70
   4 │      2      0  missing 
   5 │      2      1       60
   6 │      2      2       40
   7 │      3      0  missing 
   8 │      3      1       90
   9 │      3      2       80
  10 │      4      0  missing 
  11 │      4      1       99
  12 │      4      2       70

选项 3. 使用cumsum ：

julia> df3 = copy(df);

julia> df3.id = cumsum(df3.time .== 0);

julia> df3
12×3 DataFrame
 Row │ id     time   conc    
     │ Int64  Int64  Int64?  
─────┼───────────────────────
   1 │     1      0  missing 
   2 │     1      1      100
   3 │     1      2       70
   4 │     2      0  missing 
   5 │     2      1       60
   6 │     2      2       40
   7 │     3      0  missing 
   8 │     3      1       90
   9 │     3      2       80
  10 │     4      0  missing 
  11 │     4      1       99
  12 │     4      2       70

选项 4. 使用accumulate ：

julia> df4 = copy(df);

julia> df4.id = accumulate((x, y) -> x + (y == 0), df4.time, init=0);

julia> df4
12×3 DataFrame
 Row │ id     time   conc    
     │ Int64  Int64  Int64?  
─────┼───────────────────────
   1 │     1      0  missing 
   2 │     1      1      100
   3 │     1      2       70
   4 │     2      0  missing 
   5 │     2      1       60
   6 │     2      2       40
   7 │     3      0  missing 
   8 │     3      1       90
   9 │     3      2       80
  10 │     4      0  missing 
  11 │     4      1       99
  12 │     4      2       70

请注意，选项 3 和选项 4 仅依赖于:time列的特殊结构，而选项 1 和选项 2 仅依赖于存储在:id列中的值。 另请注意，在选项 3 和选项 4 中，您可以使用cumsum! 并accumumulate! 在:id列中进行就地分配。