【问题标题】:Julia - separate() tidyr equivalentJulia - 独立() tidyr 等价物
【发布时间】:2021-10-11 12:24:09
【问题描述】:

julia 中是否有与 R 中的 separate() 等价的函数? 我有一列带有“:”作为分隔符的长字符串,我想通过这些分隔符将字符串拆分为 8 列。

【问题讨论】:

    标签: julia


    【解决方案1】:

    假设您使用 DataFrames.jl,您可以使用以下内容。

    首先生成一些测试数据:

    julia> using DataFrames
    
    julia> df = DataFrame(in = join.(eachrow(rand(1:9, 10, 8)), ":"))
    10×1 DataFrame
     Row │ in
         │ String
    ─────┼─────────────────
       1 │ 8:2:9:4:1:9:3:1
       2 │ 9:6:9:9:8:1:9:5
       3 │ 2:4:9:8:5:4:8:7
       4 │ 8:2:2:9:5:3:7:7
       5 │ 1:4:6:1:3:9:2:1
       6 │ 8:6:1:5:1:4:8:8
       7 │ 4:6:4:4:4:4:8:8
       8 │ 4:3:3:5:1:4:3:4
       9 │ 9:5:5:7:5:3:4:3
      10 │ 4:5:8:5:2:5:7:4
    

    可以通过多种方式进行拆分(我们可以完全灵活地拆分列)。这里我只使用split函数。

    如果您想要自动生成的列名,请使用:

    julia> transform(df, :in => ByRow(x -> split(x, ":")) => AsTable)
    10×9 DataFrame
     Row │ in               x1         x2         x3         x4         x5         x6         x7         x8        
         │ String           SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin… 
    ─────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────
       1 │ 8:2:9:4:1:9:3:1  8          2          9          4          1          9          3          1
       2 │ 9:6:9:9:8:1:9:5  9          6          9          9          8          1          9          5
       3 │ 2:4:9:8:5:4:8:7  2          4          9          8          5          4          8          7
       4 │ 8:2:2:9:5:3:7:7  8          2          2          9          5          3          7          7
       5 │ 1:4:6:1:3:9:2:1  1          4          6          1          3          9          2          1
       6 │ 8:6:1:5:1:4:8:8  8          6          1          5          1          4          8          8
       7 │ 4:6:4:4:4:4:8:8  4          6          4          4          4          4          8          8
       8 │ 4:3:3:5:1:4:3:4  4          3          3          5          1          4          3          4
       9 │ 9:5:5:7:5:3:4:3  9          5          5          7          5          3          4          3
      10 │ 4:5:8:5:2:5:7:4  4          5          8          5          2          5          7          4
    

    或者传递您自己的列名:

    julia> transform(df, :in => ByRow(x -> split(x, ":")) => "out" .* string.(1:8))
    10×9 DataFrame
     Row │ in               out1       out2       out3       out4       out5       out6       out7       out8      
         │ String           SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin…  SubStrin… 
    ─────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────
       1 │ 8:2:9:4:1:9:3:1  8          2          9          4          1          9          3          1
       2 │ 9:6:9:9:8:1:9:5  9          6          9          9          8          1          9          5
       3 │ 2:4:9:8:5:4:8:7  2          4          9          8          5          4          8          7
       4 │ 8:2:2:9:5:3:7:7  8          2          2          9          5          3          7          7
       5 │ 1:4:6:1:3:9:2:1  1          4          6          1          3          9          2          1
       6 │ 8:6:1:5:1:4:8:8  8          6          1          5          1          4          8          8
       7 │ 4:6:4:4:4:4:8:8  4          6          4          4          4          4          8          8
       8 │ 4:3:3:5:1:4:3:4  4          3          3          5          1          4          3          4
       9 │ 9:5:5:7:5:3:4:3  9          5          5          7          5          3          4          3
      10 │ 4:5:8:5:2:5:7:4  4          5          8          5          2          5          7          4
    

    请注意,允许自定义解析器的好处是您可以一次性将原始字符串的部分转换为其数值,如下所示:

    julia> transform(df, :in => ByRow(x -> parse.(Int, split(x, ":"))) => AsTable)
    10×9 DataFrame
     Row │ in               x1     x2     x3     x4     x5     x6     x7     x8    
         │ String           Int64  Int64  Int64  Int64  Int64  Int64  Int64  Int64 
    ─────┼─────────────────────────────────────────────────────────────────────────
       1 │ 8:2:9:4:1:9:3:1      8      2      9      4      1      9      3      1 
       2 │ 9:6:9:9:8:1:9:5      9      6      9      9      8      1      9      5 
       3 │ 2:4:9:8:5:4:8:7      2      4      9      8      5      4      8      7 
       4 │ 8:2:2:9:5:3:7:7      8      2      2      9      5      3      7      7 
       5 │ 1:4:6:1:3:9:2:1      1      4      6      1      3      9      2      1 
       6 │ 8:6:1:5:1:4:8:8      8      6      1      5      1      4      8      8 
       7 │ 4:6:4:4:4:4:8:8      4      6      4      4      4      4      8      8 
       8 │ 4:3:3:5:1:4:3:4      4      3      3      5      1      4      3      4 
       9 │ 9:5:5:7:5:3:4:3      9      5      5      7      5      3      4      3 
      10 │ 4:5:8:5:2:5:7:4      4      5      8      5      2      5      7      4 
    

    这是另一种方法。不像上面那样可组合,但向您展示了生态系统的灵活性:

    julia> using CSV
    
    julia> CSV.read(IOBuffer(join(df.in, "\n")), DataFrame, header=false, delim=":")
    10×8 DataFrame
     Row │ Column1  Column2  Column3  Column4  Column5  Column6  Column7  Column8 
         │ Int64    Int64    Int64    Int64    Int64    Int64    Int64    Int64   
    ─────┼────────────────────────────────────────────────────────────────────────
       1 │       8        2        9        4        1        9        3        1
       2 │       9        6        9        9        8        1        9        5
       3 │       2        4        9        8        5        4        8        7
       4 │       8        2        2        9        5        3        7        7
       5 │       1        4        6        1        3        9        2        1
       6 │       8        6        1        5        1        4        8        8
       7 │       4        6        4        4        4        4        8        8
       8 │       4        3        3        5        1        4        3        4
       9 │       9        5        5        7        5        3        4        3
      10 │       4        5        8        5        2        5        7        4
    
    julia> CSV.read(IOBuffer(join(df.in, "\n")), DataFrame, header="out" .* string.(1:8), delim=":")
    10×8 DataFrame
     Row │ out1   out2   out3   out4   out5   out6   out7   out8  
         │ Int64  Int64  Int64  Int64  Int64  Int64  Int64  Int64 
    ─────┼────────────────────────────────────────────────────────
       1 │     8      2      9      4      1      9      3      1 
       2 │     9      6      9      9      8      1      9      5 
       3 │     2      4      9      8      5      4      8      7 
       4 │     8      2      2      9      5      3      7      7 
       5 │     1      4      6      1      3      9      2      1 
       6 │     8      6      1      5      1      4      8      8 
       7 │     4      6      4      4      4      4      8      8 
       8 │     4      3      3      5      1      4      3      4 
       9 │     9      5      5      7      5      3      4      3 
      10 │     4      5      8      5      2      5      7      4 
    

    【讨论】:

    • 如果您想使用 DataFramesMeta.jl DSL,您可以编写例如@rtransform df $("out" .* string.(1:8)) = split(:in, ":")
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2017-10-26
    • 2019-03-16
    • 2021-02-17
    • 2019-07-14
    • 1970-01-01
    相关资源
    最近更新 更多