我需要访问列表的第一个元素
。问题是列表的嵌套深度不同。下面是一个例子:
list1 <- list(ts(1:100),
list(1:19,
factor(letters)))
list2 <- list(list(list(ts(1:100), data.frame(a= rnorm(100))),
matrix(rnorm(10))),
NA)
我的预期输出是获得两个列表的时间序列ts(1:100)
,即list1[[1]]
和list2[[1]][[1]][[1]]
。我尝试过不同的东西,其中包括Lappy(列表2,`[`,1),但在这里不起作用。
另一种可能的解决方案,使用purrr::pluck
和purrr::vec_depth
:
library(tidyverse)
pluck(list1, !!!(rep(1, vec_depth(list1)-2) %>% as.list()))
#> Time Series:
#> Start = 1
#> End = 100
#> Frequency = 1
#> [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
#> [19] 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
#> [37] 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
#> [55] 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#> [73] 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
#> [91] 91 92 93 94 95 96 97 98 99 100
pluck(list2, !!!(rep(1, vec_depth(list2)-2) %>% as.list()))
#> Time Series:
#> Start = 1
#> End = 100
#> Frequency = 1
#> [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
#> [19] 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
#> [37] 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
#> [55] 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
#> [73] 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
#> [91] 91 92 93 94 95 96 97 98 99 100
您可以使用rrapply::rrapply
:
library(rrapply)
firstList1 <- rrapply(list1, how = "flatten")[[1]]
firstList2 <- rrapply(list2, how = "flatten")[[1]]
all.equal(firstList1, firstList2)
# [1] TRUE
输出
> rrapply(list1, how = "flatten")[[1]]
Time Series:
Start = 1
End = 100
Frequency = 1
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
[27] 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
[53] 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
[79] 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
另一个base R解决方案——您可以使用递归函数来实现这一点:
list1 <- list(ts(1:100),
list(1:19,
factor(letters)))
list2 <- list(list(list(ts(1:100), data.frame(a= rnorm(100))),
matrix(rnorm(10))),
NA)
recursive_fun <- function(my_list) {
if (inherits(my_list, 'list')) {
Recall(my_list[[1]])
} else {
my_list
}
}
输出:
> recursive_fun(list1)
Time Series:
Start = 1
End = 100
Frequency = 1
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
[31] 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
[61] 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
[91] 91 92 93 94 95 96 97 98 99 100
> recursive_fun(list2)
Time Series:
Start = 1
End = 100
Frequency = 1
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
[31] 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
[61] 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
[91] 91 92 93 94 95 96 97 98 99 100
问题内容: 我的应用程序中有一个非常复杂的数据结构,需要对其进行操作。我试图跟踪玩家在他们的花园中有多少种错误。有十种错误,每种错误都有十种模式,每种模式都有十种颜色。所以可能有1000个独特的错误,我想追踪玩家每种类型的错误数量。嵌套的字典如下所示: 我没有使用此语法的任何错误或投诉。 当我想增加播放器的错误收集时,请执行以下操作: 我收到此错误: 字符串不能转换为’DictionaryInde
问题内容: 我正在用Go编写一个websocket客户端。我正在从服务器接收以下JSON: 我正在尝试访问该参数,但无法掌握如何深入了解接口类型: 显然是错误的,因为这种表示法是不正确的: 我只是找不到一种方法来挖掘地图以获取深层嵌套的键和值。 一旦可以克服动态值,我便想声明这些消息。我将如何编写类型结构来表示这种复杂的数据结构? 问题答案: 您解码成的部分将与该字段的类型匹配。因此,在这种情况下
问题内容: 有一个简单的POJO- 内部带有子类别。嵌套可能会很深,因为每个子类别都可能包含子子类别,依此类推。我想通过jersey 返回为REST资源,序列化为json(由jackson提出)。问题是,我不能真正限制序列化的深度,因此所有类别树都可以序列化。 有没有办法在完成第一级(即具有其第一级子类别)后立即停止对杰克逊进行序列化的对象? 问题答案: 如果可以从POJO中获取当前深度,则可以使
有一个简单的POJO-和
问题内容: 我正在尝试复制嵌套列表,但是 不 使用该函数不知道该如何做。 我用了: 和 但事实证明,它们全都是浅表。 有什么提示吗? 问题答案: 我的模拟输入: 策略:遍历传入对象的每个元素,递归地下降到也可迭代的元素中,并创建相同类型的新对象。 无论它是全面的还是没有错误的,我都不会提出任何主张[1](不要传递引用自己的对象!),但是应该让您入门。 [1]真的!这里的重点是演示,而不是涵盖所有可
问题内容: 一个作业有一个真正的问题(和头痛)… 我在入门编程班上,我必须写一个函数,给定一个列表,该函数将返回其达到的“最大”深度。例如:[1,2,3]将返回1,[ 1,[2,3]]将返回2 … 我已经编写了这段代码(这是我能得到的最好的T_T) 但是,它显然不像应有的那样工作,因为如果存在不计入最大深度的列表,它仍然会增加计数器… 例如:当我将函数与[1,2,[3,4],5,[6],7]一起使