Функции группировки (tapply, by, aggregate) и семейство * apply

С другой стороны, вот как различные функции plyr соответствуют базовым функциям *apply (от ввода к документу plyr с веб-страницы plyr http://had.co.nz/plyr/)

Base function   Input   Output   plyr function 
---------------------------------------
aggregate        d       d       ddply + colwise 
apply            a       a/l     aaply / alply 
by               d       l       dlply 
lapply           l       l       llply  
mapply           a       a/l     maply / mlply 
replicate        r       a/l     raply / rlply 
sapply           l       a       laply 

Одной из целей plyr является предоставление согласованных соглашений об именах для каждой из функций, кодирующих типы входных и выходных данных в имени функции. Он также обеспечивает согласованность вывода, поскольку вывод из dlply() легко проходит к ldply() для получения полезного вывода и т.д.

Концептуально, обучение plyr не более сложно, чем понимание базовых функций *apply.

Функции

plyr и reshape заменили почти все эти функции в моем ежедневном использовании. Но, также из документа Intro to Plyr:

Связанные функции tapply и sweep не имеют соответствующей функции в plyr и остаются полезными. merge полезен для комбинирования сумм с исходными данными.

Из слайда 21 http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy:

(Надеюсь, ясно, что apply соответствует @Hadley aaply и aggregate соответствует @Hadley ddply и т.д. Слайд 20 из того же слайд-шоу прояснит, не получите ли вы его от этого изображения. )

(слева находится вход, сверху отображается)

Сначала начните с Joran отличный ответ - сомнительно, что что-то может улучшить это.

Тогда следующие мнемоники могут помочь запомнить различия между ними. В то время как некоторые из них очевидны, другие могут быть менее такими - для них вы найдете оправдание в обсуждениях Джорана.

Мнемоник

• lapply - это список, который действует в списке или векторе и возвращает список.
• sapply - это простой lapply (функция по умолчанию возвращает вектор или матрицу, когда это возможно)
• vapply - это проверенное применение (позволяет задавать тип возвращаемого объекта)
• rapply - это рекурсивное применение для вложенных списков, т.е. списков в списках
• tapply применяется с тегами, где теги идентифицируют подмножества
• apply является общим: применяет функцию к матричным строкам или столбцам (или, более общо, к размерам массива)

Создание правильного фона

Если использование семейства apply все еще немного чуждо вам, возможно, вам не хватает ключевой точки зрения.

Эти две статьи могут помочь. Они обеспечивают необходимый фон для мотивации методов функционального программирования, предоставляемых семейством функций apply.

Пользователи Lisp сразу узнают парадигму. Если вы не знакомы с Lisp, как только вы пойдете вокруг FP, вы приобретете мощную точку зрения для использования в R - и apply, что будет иметь больший смысл.

• Advanced R: функциональное программирование, Hadley Wickham
• Простое функциональное программирование в R, Michael Barton

Так как я понял, что (очень превосходные) ответы на этот пост недостаток by и aggregate объяснений. Вот мой вклад.

ПО

Функция by, как указано в документации, может быть, однако, как "обертка" для tapply. Сила by возникает, когда мы хотим вычислить задачу, которую tapply не может обрабатывать. Одним из примеров является этот код:

ct <- tapply(iris$Sepal.Width , iris$Species , summary )
cb <- by(iris$Sepal.Width , iris$Species , summary )

 cb
iris$Species: setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 
-------------------------------------------------------------- 
iris$Species: versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 
-------------------------------------------------------------- 
iris$Species: virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 


ct
$setosa
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.300   3.200   3.400   3.428   3.675   4.400 

$versicolor
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.000   2.525   2.800   2.770   3.000   3.400 

$virginica
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  2.200   2.800   3.000   2.974   3.175   3.800 

Если мы напечатаем эти два объекта ct и cb, мы "по существу" получим те же результаты, и единственные различия в том, как они показаны, и разные атрибуты class, соответственно by для cb и array для ct.

Как я уже сказал, сила by возникает, когда мы не можем использовать tapply; следующим примером является следующий пример:

 tapply(iris, iris$Species, summary )
Error in tapply(iris, iris$Species, summary) : 
  arguments must have same length

R говорит, что аргументы должны иметь одинаковую длину, например "мы хотим рассчитать summary всей переменной в iris по коэффициенту Species": но R просто не может этого сделать, потому что это не знать, как обращаться.

С помощью функции by R отправляет специальный метод для класса data frame, а затем пусть функция summary работает, даже если длина первого аргумента (и тип тоже) различна.

bywork <- by(iris, iris$Species, summary )

bywork
iris$Species: setosa
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.300   Min.   :2.300   Min.   :1.000   Min.   :0.100   setosa    :50  
 1st Qu.:4.800   1st Qu.:3.200   1st Qu.:1.400   1st Qu.:0.200   versicolor: 0  
 Median :5.000   Median :3.400   Median :1.500   Median :0.200   virginica : 0  
 Mean   :5.006   Mean   :3.428   Mean   :1.462   Mean   :0.246                  
 3rd Qu.:5.200   3rd Qu.:3.675   3rd Qu.:1.575   3rd Qu.:0.300                  
 Max.   :5.800   Max.   :4.400   Max.   :1.900   Max.   :0.600                  
-------------------------------------------------------------- 
iris$Species: versicolor
  Sepal.Length    Sepal.Width     Petal.Length   Petal.Width          Species  
 Min.   :4.900   Min.   :2.000   Min.   :3.00   Min.   :1.000   setosa    : 0  
 1st Qu.:5.600   1st Qu.:2.525   1st Qu.:4.00   1st Qu.:1.200   versicolor:50  
 Median :5.900   Median :2.800   Median :4.35   Median :1.300   virginica : 0  
 Mean   :5.936   Mean   :2.770   Mean   :4.26   Mean   :1.326                  
 3rd Qu.:6.300   3rd Qu.:3.000   3rd Qu.:4.60   3rd Qu.:1.500                  
 Max.   :7.000   Max.   :3.400   Max.   :5.10   Max.   :1.800                  
-------------------------------------------------------------- 
iris$Species: virginica
  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width          Species  
 Min.   :4.900   Min.   :2.200   Min.   :4.500   Min.   :1.400   setosa    : 0  
 1st Qu.:6.225   1st Qu.:2.800   1st Qu.:5.100   1st Qu.:1.800   versicolor: 0  
 Median :6.500   Median :3.000   Median :5.550   Median :2.000   virginica :50  
 Mean   :6.588   Mean   :2.974   Mean   :5.552   Mean   :2.026                  
 3rd Qu.:6.900   3rd Qu.:3.175   3rd Qu.:5.875   3rd Qu.:2.300                  
 Max.   :7.900   Max.   :3.800   Max.   :6.900   Max.   :2.500     

он работает действительно, и результат очень удивителен. Это объект класса by, который вдоль Species (скажем, для каждого из них) вычисляет summary каждой переменной.

Обратите внимание, что если первым аргументом является data frame, отправленная функция должна иметь метод для этого класса объектов. Например, мы используем этот код с функцией mean, у нас будет этот код, который вообще не имеет смысла:

 by(iris, iris$Species, mean)
iris$Species: setosa
[1] NA
------------------------------------------- 
iris$Species: versicolor
[1] NA
------------------------------------------- 
iris$Species: virginica
[1] NA
Warning messages:
1: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
2: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA
3: In mean.default(data[x, , drop = FALSE], ...) :
  argument is not numeric or logical: returning NA

ОБЩИЙ

aggregate можно рассматривать как другой способ использования tapply, если мы будем использовать его таким образом.

at <- tapply(iris$Sepal.Length , iris$Species , mean)
ag <- aggregate(iris$Sepal.Length , list(iris$Species), mean)

 at
    setosa versicolor  virginica 
     5.006      5.936      6.588 
 ag
     Group.1     x
1     setosa 5.006
2 versicolor 5.936
3  virginica 6.588

Два непосредственных отличия заключаются в том, что второй аргумент aggregate должен быть списком, тогда как tapply может (не обязательно) быть списком и что вывод of aggregate - это кадр данных, а один из tapply - array.

Сила aggregate заключается в том, что она может обрабатывать легко подмножества данных с аргументом subset и что у нее есть методы для объектов ts и formula.

Эти элементы упрощают работу aggregate с этим tapply в некоторых ситуациях. Вот несколько примеров (доступно в документации):

ag <- aggregate(len ~ ., data = ToothGrowth, mean)

 ag
  supp dose   len
1   OJ  0.5 13.23
2   VC  0.5  7.98
3   OJ  1.0 22.70
4   VC  1.0 16.77
5   OJ  2.0 26.06
6   VC  2.0 26.14

Мы можем достичь того же значения с tapply, но синтаксис немного сложнее, а выход (в некоторых случаях) менее читабельный:

att <- tapply(ToothGrowth$len, list(ToothGrowth$dose, ToothGrowth$supp), mean)

 att
       OJ    VC
0.5 13.23  7.98
1   22.70 16.77
2   26.06 26.14

Есть другие случаи, когда мы не можем использовать by или tapply, и мы должны использовать aggregate.

 ag1 <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, mean)

 ag1
  Month    Ozone     Temp
1     5 23.61538 66.73077
2     6 29.44444 78.22222
3     7 59.11538 83.88462
4     8 59.96154 83.96154
5     9 31.44828 76.89655

Мы не можем получить предыдущий результат с помощью tapply в одном вызове, но мы должны вычислить среднее значение по Month для каждого элемента и затем объединить их (также обратите внимание, что мы должны называть na.rm = TRUE, потому что formula методы функции aggregate по умолчанию имеют значение na.action = na.omit):

ta1 <- tapply(airquality$Ozone, airquality$Month, mean, na.rm = TRUE)
ta2 <- tapply(airquality$Temp, airquality$Month, mean, na.rm = TRUE)

 cbind(ta1, ta2)
       ta1      ta2
5 23.61538 65.54839
6 29.44444 79.10000
7 59.11538 83.90323
8 59.96154 83.96774
9 31.44828 76.90000

в то время как с by мы просто не можем добиться того, что на самом деле следующий вызов функции возвращает ошибку (но, скорее всего, она связана с предоставленной функцией, mean):

by(airquality[c("Ozone", "Temp")], airquality$Month, mean, na.rm = TRUE)

В других случаях результаты одинаковы, а различия находятся только в классе (а затем как он отображается/печатается, а не только - например, как его подмножать):

byagg <- by(airquality[c("Ozone", "Temp")], airquality$Month, summary)
aggagg <- aggregate(cbind(Ozone, Temp) ~ Month, data = airquality, summary)

Предыдущий код достигает той же цели и результатов, в некоторых случаях какой инструмент использовать - это только вопрос личных вкусов и потребностей; предыдущие два объекта имеют очень разные потребности в терминах подмножества.

Есть много замечательных ответов, в которых обсуждаются различия в вариантах использования для каждой функции. Ни один из ответов не говорит о различиях в производительности. Это разумная причина, по которой различные функции ожидают различного ввода и производят различную продукцию, но большинство из них имеют общую общую цель для оценки по группам/группам. Мой ответ будет сосредоточен на производительности. Из-за выше входное создание из векторов включено в синхронизацию, также функция apply не измеряется.

Я проверил сразу две разные функции sum и length. Тестируемый объем составляет 50 М на входе и 50 КВ на выходе. Я также включил два популярных в настоящее время пакета, которые не были широко использованы в момент запроса вопроса, data.table и dplyr. Оба, безусловно, стоит посмотреть, если вы нацелены на хорошую работу.

library(dplyr)
library(data.table)
set.seed(123)
n = 5e7
k = 5e5
x = runif(n)
grp = sample(k, n, TRUE)

timing = list()

# sapply
timing[["sapply"]] = system.time({
    lt = split(x, grp)
    r.sapply = sapply(lt, function(x) list(sum(x), length(x)), simplify = FALSE)
})

# lapply
timing[["lapply"]] = system.time({
    lt = split(x, grp)
    r.lapply = lapply(lt, function(x) list(sum(x), length(x)))
})

# tapply
timing[["tapply"]] = system.time(
    r.tapply <- tapply(x, list(grp), function(x) list(sum(x), length(x)))
)

# by
timing[["by"]] = system.time(
    r.by <- by(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# aggregate
timing[["aggregate"]] = system.time(
    r.aggregate <- aggregate(x, list(grp), function(x) list(sum(x), length(x)), simplify = FALSE)
)

# dplyr
timing[["dplyr"]] = system.time({
    df = data_frame(x, grp)
    r.dplyr = summarise(group_by(df, grp), sum(x), n())
})

# data.table
timing[["data.table"]] = system.time({
    dt = setnames(setDT(list(x, grp)), c("x","grp"))
    r.data.table = dt[, .(sum(x), .N), grp]
})

# all output size match to group count
sapply(list(sapply=r.sapply, lapply=r.lapply, tapply=r.tapply, by=r.by, aggregate=r.aggregate, dplyr=r.dplyr, data.table=r.data.table), 
       function(x) (if(is.data.frame(x)) nrow else length)(x)==k)
#    sapply     lapply     tapply         by  aggregate      dplyr data.table 
#      TRUE       TRUE       TRUE       TRUE       TRUE       TRUE       TRUE 

# print timings
as.data.table(sapply(timing, `[[`, "elapsed"), keep.rownames = TRUE
              )[,.(fun = V1, elapsed = V2)
                ][order(-elapsed)]
#          fun elapsed
#1:  aggregate 109.139
#2:         by  25.738
#3:      dplyr  18.978
#4:     tapply  17.006
#5:     lapply  11.524
#6:     sapply  11.326
#7: data.table   2.686

Несмотря на все замечательные ответы здесь, есть еще две базовые функции, которые заслуживают упоминания, полезная функция outer и неявная eapply функция

внешняя

outer - очень полезная функция, скрытая как более обыденная. Если вы прочитали справку для outer, в ее описании говорится:

The outer product of the arrays X and Y is the array A with dimension  
c(dim(X), dim(Y)) where element A[c(arrayindex.x, arrayindex.y)] =   
FUN(X[arrayindex.x], Y[arrayindex.y], ...).

из-за чего кажется, что это полезно только для вещей типа линейной алгебры. Однако его можно использовать так же, как mapply, чтобы применить функцию к двум векторам входных данных. Разница в том, что mapply применит эту функцию к первым двум элементам, а затем ко второй и т.д., Тогда как outer применит эту функцию к каждой комбинации одного элемента из первого вектора, а вторая - к второй. Например:

 A<-c(1,3,5,7,9)
 B<-c(0,3,6,9,12)

mapply(FUN=pmax, A, B)

> mapply(FUN=pmax, A, B)
[1]  1  3  6  9 12

outer(A,B, pmax)

 > outer(A,B, pmax)
      [,1] [,2] [,3] [,4] [,5]
 [1,]    1    3    6    9   12
 [2,]    3    3    6    9   12
 [3,]    5    5    6    9   12
 [4,]    7    7    7    9   12
 [5,]    9    9    9    9   12

Я лично использовал это, когда у меня есть вектор значений и вектор условий и хочу видеть, какие значения соответствуют тем условиям.

eapply

eapply похож на lapply, за исключением того, что вместо применения функции к каждому элементу в списке он применяет функцию к каждому элементу в среде. Например, если вы хотите найти список пользовательских функций в глобальной среде:

A<-c(1,3,5,7,9)
B<-c(0,3,6,9,12)
C<-list(x=1, y=2)
D<-function(x){x+1}

> eapply(.GlobalEnv, is.function)
$A
[1] FALSE

$B
[1] FALSE

$C
[1] FALSE

$D
[1] TRUE 

Откровенно говоря, я не использую это очень много, но если вы создаете много пакетов или создаете множество сред, это может пригодиться.

Возможно, стоит упомянуть ave. ave tapply дружелюбный кузен. Он возвращает результаты в форме, которую вы можете подключить прямо к вашему кадру данных.

dfr <- data.frame(a=1:20, f=rep(LETTERS[1:5], each=4))
means <- tapply(dfr$a, dfr$f, mean)
##  A    B    C    D    E 
## 2.5  6.5 10.5 14.5 18.5 

## great, but putting it back in the data frame is another line:

dfr$m <- means[dfr$f]

dfr$m2 <- ave(dfr$a, dfr$f, FUN=mean) # NB argument name FUN is needed!
dfr
##   a f    m   m2
##   1 A  2.5  2.5
##   2 A  2.5  2.5
##   3 A  2.5  2.5
##   4 A  2.5  2.5
##   5 B  6.5  6.5
##   6 B  6.5  6.5
##   7 B  6.5  6.5
##   ...

В базовом пакете ничего не работает, как ave для целых фреймов данных (как by как tapply для фреймов данных). Но вы можете выдумать это:

dfr$foo <- ave(1:nrow(dfr), dfr$f, FUN=function(x) {
    x <- dfr[x,]
    sum(x$m*x$m2)
})
dfr
##     a f    m   m2    foo
## 1   1 A  2.5  2.5    25
## 2   2 A  2.5  2.5    25
## 3   3 A  2.5  2.5    25
## ...

Недавно я обнаружил довольно полезную функцию sweep и добавил ее здесь для полноты:

подметать

Основная идея состоит в том, чтобы прокручивать массив row- или по столбцам и возвращать модифицированный массив. Пример сделает это ясно (source: datacamp):

Скажем, у вас есть матрица и вы хотите стандартизировать ее по столбцам:

dataPoints <- matrix(4:15, nrow = 4)

# Find means per column with 'apply()'
dataPoints_means <- apply(dataPoints, 2, mean)

# Find standard deviation with 'apply()'
dataPoints_sdev <- apply(dataPoints, 2, sd)

# Center the points 
dataPoints_Trans1 <- sweep(dataPoints, 2, dataPoints_means,"-")
print(dataPoints_Trans1)
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Return the result
dataPoints_Trans1
##      [,1] [,2] [,3]
## [1,] -1.5 -1.5 -1.5
## [2,] -0.5 -0.5 -0.5
## [3,]  0.5  0.5  0.5
## [4,]  1.5  1.5  1.5
# Normalize
dataPoints_Trans2 <- sweep(dataPoints_Trans1, 2, dataPoints_sdev, "/")

# Return the result
dataPoints_Trans2
##            [,1]       [,2]       [,3]
## [1,] -1.1618950 -1.1618950 -1.1618950
## [2,] -0.3872983 -0.3872983 -0.3872983
## [3,]  0.3872983  0.3872983  0.3872983
## [4,]  1.1618950  1.1618950  1.1618950

NB: для этого простого примера можно, конечно, добиться того же результата
apply(dataPoints, 2, scale)