如何将所有子列表元素组合到一个列表中

Question

我有一个列表(长度为3),由子列表组成(每个都有不同的长度 - 2,2,3).我想将所有这些存储为一个大的列表(例如,没有子列表 - 只有一个长度为7的列表).我理解如何手动完成,但有一个我可以使用的功能或命令吗？

我希望能够为任何长度的列表和子列表执行此操作.

这是列表的一个例子:

[[1]]
[[1]][[1]]
      name  n       l_1         t         t_3          t_4          t_5 cluster
12  563035 19  9.263158 0.2017045  0.06379453  0.075876830  0.095852895       1
14  563037 19  8.026316 0.2076503  0.05634675  0.098684211 -0.104566563       1


[[1]][[2]]
      name  n       l_1         t         t_3          t_4          t_5 cluster
13  563036 20  7.200000 0.1838450 -0.06428098  0.085681987 -0.011070830       2
17  563042 20  7.725000 0.2168285  0.15161037  0.117570045 -0.067102568       2


[[2]]
[[2]][[1]]
      name  n       l_1          t          t_3          t_4           t_5 cluster
1   561101 11  6.772727 0.19731544  0.029478458 -0.128117914  6.235828e-02       1
44  563080 11  7.545455 0.18554217  0.103896104  0.285714286 -2.164502e-02       1


[[2]][[2]]
      name  n       l_1         t         t_3           t_4          t_5 cluster
48  566017 33 10.400000 0.2037624  0.16432326  0.1166006937 -0.012830017       2
49  566018 22  9.218182 0.2113271  0.30646667  0.2502280702  0.189838207       2
50  566020 19 11.736842 0.3111609  0.51217445  0.5147883012  0.462723120       2


[[3]]
[[3]][[1]]
      name  n       l_1         t         t_3         t_4         t_5 cluster
158 568004 18  8.722222 0.1787186 -0.05083857  0.06498952  0.06918239       1
161 568046 19 11.794737 0.3646190  0.54582540  0.49747236  0.32255755       1
162 568047 18 12.916667 0.3366224  0.53523112  0.40464111  0.29960541       1
163 568048 20 11.590000 0.3918986  0.50007725  0.43039556  0.34299752       1


[[3]][[2]]
      name  n       l_1         t         t_3        t_4         t_5 cluster
165 568050 20  9.125000 0.2034607  0.29789747 0.31073776  0.09157738       2
167 568054 20  8.850000 0.1332144  0.09895833 0.18636204  0.04641544       2



[[3]][[3]]
      name  n       l_1         t         t_3          t_4          t_5 cluster
168 568058 20  8.675000 0.2012741  0.18161266  0.200319163 -0.009375416       3
170 568061 18 24.861111 0.7394676  0.91836281  0.928317483  0.905563950       3

非常感谢,西尔维娅

Answer 1

对于您的具体问题,答案很简单:

unlist(mylist, recursive = FALSE)

但是,您询问如何能够为具有任意数量的子列表的列表执行此操作.这有点棘手.幸运的是,Akhil S Bhel为我们解决了这个问题并创建了一个名为的函数LinearizeNestedList.他的网站目前正在下降,但我把他的功能作为一个Github Gist.

首先,我们将在嵌套列表中使用嵌套列表创建一些示例数据.

NList <- list(a = "a", # Atom
              b = 1:5, # Vector
              c = data.frame(x = runif(5), y = runif(5)), 
              d = matrix(runif(4), nrow = 2), 
              e = list(l = list("a", "b"), 
                       m = list(1:5, 5:10),
                       n = list(list(1), list(2)))) 

源列表看起来像这样.请注意嵌套列表项"e"发生的嵌套.

NList
# $a
# [1] "a"
# 
# $b
# [1] 1 2 3 4 5
# 
# $c
#           x          y
# 1 0.7893562 0.47761962
# 2 0.0233312 0.86120948
# 3 0.4772301 0.43809711
# 4 0.7323137 0.24479728
# 5 0.6927316 0.07067905
# 
# $d
#            [,1]      [,2]
# [1,] 0.09946616 0.5186343
# [2,] 0.31627171 0.6620051
# 
# $e
# $e$l
# $e$l[[1]]
# [1] "a"
# 
# $e$l[[2]]
# [1] "b"
# 
# 
# $e$m
# $e$m[[1]]
# [1] 1 2 3 4 5
# 
# $e$m[[2]]
# [1]  5  6  7  8  9 10
# 
# 
# $e$n
# $e$n[[1]]
# $e$n[[1]][[1]]
# [1] 1
# 
# 
# $e$n[[2]]
# $e$n[[2]][[1]]
# [1] 2

您可以看到如何LinearizeNestedList"展平"所有子列表,以便最终得到一个列表.

LinearizeNestedList(NList)
# $a
# [1] "a"
# 
# $b
# [1] 1 2 3 4 5
# 
# $c
#           x          y
# 1 0.7893562 0.47761962
# 2 0.0233312 0.86120948
# 3 0.4772301 0.43809711
# 4 0.7323137 0.24479728
# 5 0.6927316 0.07067905
# 
# $d
#            [,1]      [,2]
# [1,] 0.09946616 0.5186343
# [2,] 0.31627171 0.6620051
# 
# $`e/l/1`
# [1] "a"
# 
# $`e/l/2`
# [1] "b"
# 
# $`e/m/1`
# [1] 1 2 3 4 5
# 
# $`e/m/2`
# [1]  5  6  7  8  9 10
# 
# $`e/n/1/1`
# [1] 1
# 
# $`e/n/2/1`
# [1] 2 

顺便说一句,我忘了提到你也可以data.frame在lists中展平s (因为a data.frame是listR中的特殊类型)

如果你真的想把所有东西弄平(好吧,除了数组,因为它们只是带dims的向量),加入LinearizeDataFrames = TRUE你的LinearizeNestedList调用:

LinearizeNestedList(NList, LinearizeDataFrames=TRUE)