如何访问不同深度嵌套列表中的第一个对象？
我需要访问列表的第一个元素。问题是列表的嵌套深度不同。下面是一个例子：
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），但在这里不起作用。
共有3个答案
另一种可能的解决方案，使用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]一起使