10

我有一个嵌套列表，其基本元素是数据帧，我想递归地遍历这个列表来对每个数据帧进行一些计算，最后得到一个与输入结构相同的嵌套结果列表。我知道“rapply”正是针对此类任务，但我遇到了一个问题，rapply 实际上比我想要的更深入，即它分解每个数据帧并改为应用于每一列（因为数据帧本身就是一个列表在 R)。

我可以考虑的一种解决方法是将每个数据帧转换为矩阵，但它会强制统一数据类型，所以我真的不喜欢它。我想知道是否有任何方法可以控制 rapply 的递归深度。任何的想法？谢谢。

4

3 回答 3

8

1. 包装在 proto 中

创建列表结构时，尝试将数据框包装在 proto 对象中：

library(proto)
L <- list(a = proto(DF = BOD), b = proto(DF = BOD))
rapply(L, f = function(.) colSums(.$DF), how = "replace")

给予：

$a
  Time demand 
    22     89 

$b
  Time demand 
    22     89

如果您想进一步使用，也可以将函数的结果包装在 proto 对象中rapply；

f <- function(.) proto(result = colSums(.$DF))
out <- rapply(L, f = f, how = "replace")
str(out)

给予：

List of 2
 $ a:proto object 
 .. $ result: Named num [1:2] 22 89 
 ..  ..- attr(*, "names")= chr [1:2] "Time" "demand" 
 $ b:proto object 
 .. $ result: Named num [1:2] 22 89 
 ..  ..- attr(*, "names")= chr [1:2] "Time" "demand"

2. 编写自己的 rapply 替代方案

recurse <- function (L, f) {
    if (inherits(L, "data.frame")) f(L)
    else lapply(L, recurse, f)
}

L <- list(a = BOD, b = BOD)
recurse(L, colSums)

这给出了：

$a
  Time demand 
    22     89 

$b
  Time demand 
    22     89

添加：第二种方法

于 2013-07-31T13:49:44.757 回答
3

2020 年 6 月更新：

您现在还可以rrapply在rrapply-package 中使用（base 的扩展版本rapply）。Settingclasses = "data.frame"将该f函数作为一个整体应用于 data.frame 对象（而不是递归到各个列中）：

library(rrapply)

L <- list(a = BOD, b = BOD)

## apply f to data.frames 
rrapply(L, f = colSums, classes = "data.frame")
#> $a
#>   Time demand 
#>     22     89 
#> 
#> $b
#>   Time demand 
#>     22     89

## apply f to individual columns of data.frames
rrapply(L, f = function(x, .xname) if(.xname == "demand") scale(x) else x)
#> $a
#>   Time     demand
#> 1    1 -1.4108974
#> 2    2 -0.9789900
#> 3    3  0.8998070
#> 4    4  0.2519460
#> 5    5  0.1655645
#> 6    7  1.0725699
#> 
#> $b
#>   Time     demand
#> 1    1 -1.4108974
#> 2    2 -0.9789900
#> 3    3  0.8998070
#> 4    4  0.2519460
#> 5    5  0.1655645
#> 6    7  1.0725699
于 2020-06-13T07:47:00.987 回答
0

在特定深度处理列表计算：

recursive_lapply <- function (data, fun, depth = 1L) {
  stopifnot(inherits(data, "list"))
  stopifnot(depth >= 1)
  f <- function(data, fun, where = integer()) {
    if (length(where) == depth) {
      fun(data)
    } else {
      res <- lapply(seq_along(data), function(i) {f(data[[i]], fun, where = c(where, i))})
      names(res) <- names(data)
      res
    }
  }
  f(data, fun)
}

示例计算：

d <- list(
  A = list(a = list(
    a1 = data.table::data.table(x = 11:15, y = 10:14),
    a2 = data.table::data.table(x = 1:5, y = 0:4)
  )),
  B = list(b = list(
    b1 = data.table::data.table(x = 7, y = 8),
    b2 = data.table::data.table(x = 9, y = 10)
  ))
)

> recursive_lapply(d, function(data) data[, "z":= x + y], 3)
$A
$A$a
$A$a$a1
    x  y  z
1: 11 10 21
2: 12 11 23
3: 13 12 25
4: 14 13 27
5: 15 14 29

$A$a$a2
   x y z
1: 1 0 1
2: 2 1 3
3: 3 2 5
4: 4 3 7
5: 5 4 9

$B
$B$b
$B$b$b1
   x y  z
1: 7 8 15

$B$b$b2
   x  y  z
1: 9 10 19
于 2020-09-04T22:04:14.340 回答