R：在深度嵌套列表中按名称查找对象 [英] R: Find object by name in deeply nested list

问题描述

问题

我想这应该是一个常见的问题，但我找不到解决它的方法：

让我们假设一个深度嵌套的列表，例如：

my_list <- list(
  "first_node" = list(
    "group_a" = list(
      "E001" = 1:5,
      "E002" = list(
        "F001" = 6:10,
        "F002" = 11:15
      )
    ),
    "group_b" = list(
      "XY01" = list(
        "Z1" = LETTERS[1:5],
        "Z2" = LETTERS[6:10],
        "Z3" = list(
          "ZZ1" = LETTERS[1],
          "ZZ2" = LETTERS[2],
          "ZZ3" = LETTERS[3]
        )
      ),
      "YZ" = LETTERS[11:15]
    ),
    "group_c" = list(
      "QQQQ" = list(
        "RRRR" = 200:300
      )
    )
  ),
  "second_node" = list(
    "group_d" = list(
      "L1" = 99:101,
      "L2" = 12
    )
  )
)

所需输出

我想按元素的名称检索元素，这些元素可能位于该列表中的未知深度级别。重要的是，我只想要那个特定的元素，它是孩子，而不是父母。

例如，搜索my_list应显示"XY01"：

XY01 = list(
  "Z1" = LETTERS[1:5],
  "Z2" = LETTERS[6:10],
  "Z3" = list(
    "ZZ1" = LETTERS[1],
    "ZZ2" = LETTERS[2],
    "ZZ3" = LETTERS[3]
  )
)

> str(XY01)
List of 3
 $ Z1: chr [1:5] "A" "B" "C" "D" ...
 $ Z2: chr [1:5] "F" "G" "H" "I" ...
 $ Z3:List of 3
  ..$ ZZ1: chr "A"
  ..$ ZZ2: chr "B"
  ..$ ZZ3: chr "C"

以前的尝试

最初我想使用rapply()来完成该工作，但似乎无法访问当前迭代的names()。我的第二个尝试是编写一个自定义递归函数：

recursive_extract <- function(haystack, needle){

    lapply(names(haystack), function(x){
      if (needle %in% names(haystack[[x]])) {
        return(haystack[[needle]])
      } else {
        recursive_extract(haystack[[x]], needle)
      }
    }) %>% setNames(names(haystack))
}

...这似乎也有问题，因为lapply()将始终返回相同的对象，即使返回NULL，因此父级结构也是如此。

我一直在研究purrr和rlist-包，以寻找一个方便的函数，但似乎大多数包都不支持递归(？)。

奖金挑战

提取所需元素后，理想情况下，我希望选择要返回多少个子级别。例如： desired_func(haystack, needle, get_depth = 1)对于上一个示例，将导致：

XY01 = list(
  "Z1" = LETTERS[1:5],
  "Z2" = LETTERS[6:10]
)

> str(XY01)
List of 2
 $ Z1: chr [1:5] "A" "B" "C" "D" ...
 $ Z2: chr [1:5] "F" "G" "H" "I" ...

非常感谢您的帮助！：)

推荐答案

这里有一个函数，如果找到，将返回第一个匹配项

find_name <- function(haystack, needle) {
 if (hasName(haystack, needle)) {
   haystack[[needle]]
 } else if (is.list(haystack)) {
   for (obj in haystack) {
     ret <- Recall(obj, needle)
     if (!is.null(ret)) return(ret)
   }
 } else {
   NULL
 }
}

find_name(my_list, "XY01")

我们避免lapply，因此如果发现循环，则可以提早中断。

列表修剪实际上是一个单独的问题。最好用不同的功能来解决这个问题。这应该会起作用

list_prune <- function(list, depth=1) {
  if (!is.list(list)) return(list)
  if (depth>1) {
    lapply(list, list_prune, depth = depth-1)
  } else  {
    Filter(function(x) !is.list(x), list)
  }
}

然后您可以

list_prune(find_name(my_list, "XY01"), 1)

或使用管道

find_name(my_list, "XY01") %>% list_prune(1)

这篇关于R：在深度嵌套列表中按名称查找对象的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！