r - 用tapply按组求和多列

我想按组对各个列求和，而我的第一个想法是使用tapply。
但是，我无法使tapply工作。可以使用tapply对多列求和吗？
如果没有，为什么不呢？

我已经在互联网上进行了广泛搜索，发现张贴了许多类似的问题
最早可以追溯到2008年。但是，这些问题都没有直接得到解答。
相反，响应总是建议使用其他函数。

以下是我希望按州对苹果，按州对樱桃求和的示例数据集
和李子按州。在此之下，我为tapply编写了许多替代方案，
做工作。

在底部，我显示了对tapply源代码的简单修改，该修改允许
tapply执行所需的操作。

不过，也许我忽略了执行所需操作的简单方法
与tapply。我不希望使用替代功能，但可以使用其他替代功能。

鉴于对tapply源代码进行修改的简便性，我不知道为什么这么做，或者
类似的东西，尚未实施。

感谢您的任何建议。如果我的问题重复，我将很乐意张贴我的问题
问题作为对另一个问题的答案。

这是示例数据集：

df.1 <- read.table(text = '

    state   county   apples   cherries   plums
       AA        1        1          2       3
       AA        2       10         20      30
       AA        3      100        200     300
       BB        7       -1         -2      -3
       BB        8      -10        -20     -30
       BB        9     -100       -200    -300

', header = TRUE, stringsAsFactors = FALSE)

这不起作用：

tapply(df.1, df.1$state, function(x) {colSums(x[,3:5])})

帮助页面显示：

tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)

X       an atomic object, typically a vector.

我对短语typically a vector感到困惑，这使我想知道是否
可以使用一个数据帧。我一直不清楚atomic object是什么意思。

这是有效的tapply替代方法。第一种选择是将tapply与apply结合使用的解决方法。

apply(df.1[,c(3:5)], 2, function(x) tapply(x, df.1$state, sum))

#    apples cherries plums
# AA    111      222   333
# BB   -111     -222  -333

with(df.1, aggregate(df.1[,3:5], data.frame(state), sum))

#   state apples cherries plums
# 1    AA    111      222   333
# 2    BB   -111     -222  -333

t(sapply(split(df.1[,3:5], df.1$state), colSums))

#    apples cherries plums
# AA    111      222   333
# BB   -111     -222  -333

t(sapply(split(df.1[,3:5], df.1$state), function(x) apply(x, 2, sum)))

#    apples cherries plums
# AA    111      222   333
# BB   -111     -222  -333

aggregate(df.1[,3:5], by=list(df.1$state), sum)

#   Group.1 apples cherries plums
# 1      AA    111      222   333
# 2      BB   -111     -222  -333

by(df.1[,3:5], df.1$state, colSums)

# df.1$state: AA
#   apples cherries    plums
#      111      222      333
# ------------------------------------------------------------
# df.1$state: BB
#   apples cherries    plums
#     -111     -222     -333

with(df.1,
     aggregate(x = list(apples   = apples,
                        cherries = cherries,
                        plums    = plums),
               by = list(state   = state),
               FUN = function(x) sum(x)))

#   state apples cherries plums
# 1    AA    111      222   333
# 2    BB   -111     -222  -333

lapply(split(df.1, df.1$state), function(x) {colSums(x[,3:5])} )

# $AA
#   apples cherries    plums
#      111      222      333
#
# $BB
#   apples cherries    plums
#     -111     -222     -333

这是tapply的源代码，除了我更改了该行：

nx <- length(X)

至：

nx <- ifelse(is.vector(X), length(X), dim(X)[1])

此tapply的修改版本执行所需的操作：

my.tapply <- function (X, INDEX, FUN = NULL, ..., simplify = TRUE)
{
    FUN <- if (!is.null(FUN)) match.fun(FUN)
    if (!is.list(INDEX)) INDEX <- list(INDEX)
    nI <- length(INDEX)
    if (!nI) stop("'INDEX' is of length zero")
    namelist <- vector("list", nI)
    names(namelist) <- names(INDEX)
    extent <- integer(nI)
    nx     <- ifelse(is.vector(X), length(X), dim(X)[1])  # replaces nx <- length(X)
    one <- 1L
    group <- rep.int(one, nx) #- to contain the splitting vector
    ngroup <- one
    for (i in seq_along(INDEX)) {
    index <- as.factor(INDEX[[i]])
    if (length(index) != nx)
        stop("arguments must have same length")
    namelist[[i]] <- levels(index)#- all of them, yes !
    extent[i] <- nlevels(index)
    group <- group + ngroup * (as.integer(index) - one)
    ngroup <- ngroup * nlevels(index)
    }
    if (is.null(FUN)) return(group)
    ans <- lapply(X = split(X, group), FUN = FUN, ...)
    index <- as.integer(names(ans))
    if (simplify && all(unlist(lapply(ans, length)) == 1L)) {
    ansmat <- array(dim = extent, dimnames = namelist)
    ans <- unlist(ans, recursive = FALSE)
    } else {
    ansmat <- array(vector("list", prod(extent)),
            dim = extent, dimnames = namelist)
    }
    if(length(index)) {
        names(ans) <- NULL
        ansmat[index] <- ans
    }
    ansmat
}

my.tapply(df.1$apples, df.1$state, function(x) {sum(x)})

#  AA   BB
# 111 -111

my.tapply(df.1[,3:4] , df.1$state, function(x) {colSums(x)})

# $AA
#   apples cherries
#      111      222
#
# $BB
#   apples cherries
#     -111     -222

最佳答案

tapply用于矢量，对于data.frame，可以使用by（它是tapply的包装，请看一下代码）：

> by(df.1[,c(3:5)], df.1$state, FUN=colSums)
df.1$state: AA
  apples cherries    plums
     111      222      333
-------------------------------------------------------------------------------------
df.1$state: BB
  apples cherries    plums
    -111     -222     -333

关于r - 用tapply按组求和多列，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/17903205/