Gruppierungsfunktionen (tapply, by, aggregate) und die * apply-Familie

Immer, wenn ich etwas tun möchte "Karte"py in R, ich in der Regel versuchen, eine Funktion in der apply Familie.

Allerdings habe ich nie ganz verstanden, die Unterschiede zwischen Ihnen -- wie { sapply , lapply etc.} die Funktion anwenden, um die input - /grouped input, was der output Aussehen wird, oder auch, was die Eingabe kann -- so oft ich nur durch Sie gehen, bis ich das bekomme, was ich will.

Kann mir jemand erklären, wie man die ein???

Meine aktuelle (wohl falschen/unvollständigen) Verständnis...

  1. sapply(vec, f): Eingabe ist ein Vektor. Ausgabe ist ein Vektor/matrix ist, wo das element i ist f(vec[i]) ist, geben Sie eine matrix an, wenn f hat eine multi-element-Ausgabe
  2. lapply(vec, f): wie sapplyaber die Ausgabe ist eine Liste?
  3. apply(matrix, 1/2, f): Eingabe einer matrix. Ausgabe ist ein Vektor, wo element i ist f(row/col i der matrix)
  4. tapply(vector, grouping, f): output ist eine matrix/array, wo ein element in der matrix/array ist der Wert von f bei einer Gruppierung g des Vektors, und g wird geschoben, um die row/col Namen
  5. by(dataframe, grouping, f): lassen Sie g eine Gruppierung. gelten f auf jede Säule in der Gruppe/dataframe. pretty-print die Gruppierung, und der Wert von f bei jeder Spalte.
  6. aggregate(matrix, grouping, f): ähnlich bysondern von ziemlich drucken Sie die Ausgabe -, Aggregat-sticks alles zu einem dataframe.

Zwischenfrage: ich habe noch nicht gelernt plyr oder umgestalten-würde plyr oder reshape ersetzen alle diese ganz?

InformationsquelleAutor der Frage grautur | 2010-08-17

  1. R hat viele *anwenden von Funktionen, die gekonnt beschrieben in den Hilfe-Dateien (z.B. ?apply). Es gibt genug von Ihnen, obwohl, dass Anfang Benutzer können Schwierigkeiten haben, zu entscheiden, welche für Ihre situation oder sogar die Erinnerung an Sie alle. Sie können ein Allgemeines Gefühl, dass "ich sollte mit ein *wenden Sie die Funktion hier", aber es kann hart sein, zu halten alle gerade auf den ersten.

    Trotz der Tatsache (erwähnt in anderen Antworten), dass viel von der Funktionalität des *wenden Sie Familie ist abgedeckt durch die äußerst beliebt plyr - Paket, Basis-Funktionen bleiben nützlich und wissenswert.

    Diese Antwort ist bestimmt zu handeln, als eine Art Wegweiser für neue Benutzer zu helfen, leiten Sie an die richtige *anwenden-Funktion für Ihre besonderen problem. Beachten Sie, dies ist nicht soll einfach wiederkäuen, oder ersetzen Sie die R-Dokumentation! Die Hoffnung ist, dass diese Antwort hilft Ihnen zu entscheiden, welche *anwenden der Funktion die zu Ihrer situation passen und dann ist es bis zu Ihnen, um die Forschung weiter. Mit einer Ausnahme, die performance-Unterschiede werden nicht angesprochen.

    • gelten - Wenn Sie sich bewerben möchten eine Funktion auf die Zeilen oder Spalten
      einer matrix (und höher-dimensionale Analoga); nicht im Allgemeinen ratsam, dass die Daten-frames, wie es zu zwingen zu einer matrix-ersten.

      # Two dimensional matrix
M <- matrix(seq(1,16), 4, 4)

# apply min to rows
apply(M, 1, min)
[1] 1 2 3 4

# apply max to columns
apply(M, 2, max)
[1]  4  8 12 16

# 3 dimensional array
M <- array( seq(32), dim = c(4,4,2))

# Apply sum across each M[*, , ] - i.e Sum across 2nd and 3rd dimension
apply(M, 1, sum)
# Result is one-dimensional
[1] 120 128 136 144

# Apply sum across each M[*, *, ] - i.e Sum across 3rd dimension
apply(M, c(1,2), sum)
# Result is two-dimensional
     [,1] [,2] [,3] [,4]
[1,]   18   26   34   42
[2,]   20   28   36   44
[3,]   22   30   38   46
[4,]   24   32   40   48

      Wenn Sie möchten, die Zeile/Spalte bedeutet, oder die Beträge für eine 2D-matrix, sicher sein, zu
      untersuchen Sie die hoch-optimierten Blitz-schnell -colMeans,
      rowMeanscolSumsrowSums.

    • lapply - Wenn Sie möchten, anwenden einer Funktion auf jedes element einer
      Liste der Reihe nach und bekommen eine Liste zurück.

      Dies ist das Arbeitspferd von vielen anderen *anwenden von Funktionen. Peel
      wieder Ihren code, und Sie werden oft finden lapply darunter.

      x <- list(a = 1, b = 1:3, c = 10:100) 
lapply(x, FUN = length) 
$a 
[1] 1
$b 
[1] 3
$c 
[1] 91
lapply(x, FUN = sum) 
$a 
[1] 1
$b 
[1] 6
$c 
[1] 5005

    • sapply - Wenn Sie möchten, anwenden einer Funktion auf jedes element einer
      Liste ihrerseits, aber Sie wollen eine Vektor zurück, eher als eine Liste.

      Wenn Sie finden, sich selbst eingeben unlist(lapply(...))zu stoppen und überlegen,
      sapply.

      x <- list(a = 1, b = 1:3, c = 10:100)
# Compare with above; a named vector, not a list 
sapply(x, FUN = length)  
a  b  c   
1  3 91

sapply(x, FUN = sum)   
a    b    c    
1    6 5005

      In mehr fortgeschrittene Verwendung von sapply es wird versuchen, Sie zu zwingen, die
      Ergebnis in ein mehrdimensionales array, falls zutreffend. Zum Beispiel, wenn unsere Funktion liefert die Vektoren die gleiche Länge, sapply diese als Spalten einer matrix:

      sapply(1:5,function(x) rnorm(3,x))

      Wenn unsere Funktion gibt eine 2-dimensionale matrix, sapply tun im wesentlichen die gleiche Sache, die Behandlung jedes zurückgegebene matrix als einen langen Vektor:

      sapply(1:5,function(x) matrix(x,2,2))

      Es sei denn, wir geben Sie simplify = "array"in dem Fall werden die einzelnen Matrizen zu bauen, die ein multi-dimensionales array:

      sapply(1:5,function(x) matrix(x,2,2), simplify = "array")

      Jede dieser Verhaltensweisen ist natürlich abhängig von unserer Funktion zurückgeben-Vektoren oder Matrizen, die die gleiche Länge oder dimension.

    • vapply - Wenn Sie verwenden möchten sapply aber vielleicht müssen
      drücken Sie etwas mehr Geschwindigkeit aus Ihrem code.

      Für vapply Sie im Grunde geben R ein Beispiel von dem, was Art der Sache
      Ihre Funktion zurück, welche können sparen Sie einige Zeit die Nötigung zurückgegeben
      die Werte passen in einer einzigen atomaren Vektor.

      x <- list(a = 1, b = 1:3, c = 10:100)
#Note that since the advantage here is mainly speed, this
# example is only for illustration. We're telling R that
# everything returned by length() should be an integer of 
# length 1. 
vapply(x, FUN = length, FUN.VALUE = 0L) 
a  b  c  
1  3 91

    • mapply - wenn Sie Für mehrere Datenstrukturen (z.B.
      Vektoren, Listen), und wollen Sie anwenden einer Funktion auf die Elemente 1.
      der einzelnen, und dann die 2. Elemente der einzelnen, etc., die Nötigung das Ergebnis
      ein Vektor/array, wie in sapply.

      Dies ist multivariaten in dem Sinne, dass Sie Ihre Funktion akzeptieren muss
      mehrere Argumente.

      #Sums the 1st elements, the 2nd elements, etc. 
mapply(sum, 1:5, 1:5, 1:5) 
[1]  3  6  9 12 15
#To do rep(1,4), rep(2,3), etc.
mapply(rep, 1:4, 4:1)   
[[1]]
[1] 1 1 1 1

[[2]]
[1] 2 2 2

[[3]]
[1] 3 3

[[4]]
[1] 4

    • Karte - Einen wrapper um mapply mit SIMPLIFY = FALSEso ist es garantiert, um eine Liste.

      Map(sum, 1:5, 1:5, 1:5)
[[1]]
[1] 3

[[2]]
[1] 6

[[3]]
[1] 9

[[4]]
[1] 12

[[5]]
[1] 15

    • rapply - wenn Sie wollen, anwenden einer Funktion auf jedes element einer verschachtelte Liste Struktur rekursiv.

      Geben Ihnen eine Vorstellung davon, wie ungewöhnlich rapply ist, ich vergaß es beim ersten posting diese Antwort! Natürlich, ich bin sicher, dass viele Leute es verwenden, aber YMMV. rapply ist am besten mit einer benutzerdefinierten Funktion zu übernehmen:

      # Append ! to string, otherwise increment
myFun <- function(x){
    if(is.character(x)){
      return(paste(x,"!",sep=""))
    }
    else{
      return(x + 1)
    }
}

#A nested list structure
l <- list(a = list(a1 = "Boo", b1 = 2, c1 = "Eeek"), 
          b = 3, c = "Yikes", 
          d = list(a2 = 1, b2 = list(a3 = "Hey", b3 = 5)))


# Result is named vector, coerced to character          
rapply(l, myFun)

# Result is a nested list like l, with values altered
rapply(l, myFun, how="replace")

    • tapply - Für wenn Sie anwenden möchten, um eine Funktion zu Teilmengen einer
      Vektor und die Teilmengen sind definiert durch einen anderen Vektor, der Regel ein
      Faktor.

      Den schwarzen Schafen der *anwenden von der Familie, von möglichen. Die Hilfe-Datei zu verwenden
      der Satz "ragged array" kann ein bisschen verwirrend, aber es ist tatsächlich
      ganz einfach.

      Eines Vektors:

      x <- 1:20

      Einen Faktor (der die gleiche Länge haben!) die Definition von Gruppen:

      y <- factor(rep(letters[1:5], each = 4))

      Addieren Sie die Werte in x innerhalb jeder Untergruppe definiert durch y:

      tapply(x, y, sum)  
 a  b  c  d  e  
10 26 42 58 74

      Komplexere Beispiele können behandelt werden, wobei die Untergruppen definiert sind
      durch die einzigartigen Kombinationen aus einer Liste von mehreren Faktoren ab. tapply ist
      ähnlich wie im Geist der split-anwenden-Funktionen kombinieren, sind
      Häufig in R ( aggregate , by, ave, ddply usw.) Folglich ist seine
      schwarze Schafe status.

    InformationsquelleAutor der Antwort joran

  2. 170

    Auf der Seite beachten, ist hier, wie die verschiedenen plyr Funktionen entsprechen der Basis *apply Funktionen (aus dem intro zu plyr Dokument aus dem plyr Webseite 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

    Eines der Ziele von plyr ist, um konsistente Namenskonventionen für jede der Funktionen, die Codierung der Eingabe-und Ausgabe-Daten-Typen in den Namen der Funktion. Es stellt auch Konsistenz in der Ausgabe, in der Ausgabe von dlply() ist leicht begehbar zu ldply() zu nützlichen Ausgang, etc.

    Konzeptionell, lernen plyr ist nicht schwieriger als das Verständnis der Basis *apply Funktionen.

    plyr und reshape Funktionen ersetzt haben fast alle diese Funktionen in meinem jeden Tag verwenden. Aber auch aus dem Intro zu Plyr Dokument:

    Verwandte Funktionen tapply und sweep haben keine entsprechende Funktion in plyr und nützlich bleiben. merge ist nützlich bei der Kombination von Zusammenfassungen mit den ursprünglichen Daten.

    InformationsquelleAutor der Antwort JoFrhwld

  3. 118

    Ab Folie 21 von http://www.slideshare.net/hadley/plyr-one-data-analytic-strategy:

    Gruppierungsfunktionen (tapply, by, aggregate) und die * apply-Familie

    (Ich hoffe, es ist klar, dass apply entspricht @Hadley 's aaply und aggregate entspricht @Hadley' s ddply etc. Folie 20 von der gleichen slideshare klären, wenn Sie nicht bekommen es von diesem Bild.)

    (auf der linken Seite ist der Eingang, oben Ausgang)

    InformationsquelleAutor der Antwort isomorphismes

  4. 88

    Ersten start mit Joran ausgezeichnete Antwort -- zweifelhaft, kann alles besser.

    Dann die folgenden eselsbrücken können helfen, sich zu erinnern, die Unterschiede zwischen den einzelnen. Während einige sind offensichtlich, andere vielleicht weniger --- für diese, die Sie finden Rechtfertigung in der Joran-Diskussionen.

    Mnemonics

    • lapply ist ein Liste gelten, die Handlungen auf einer Liste oder einem vector und gibt eine Liste.
    • sapply ist ein einfach lapply (Funktion standardmäßig Rückkehr einen Vektor oder matrix, wenn möglich)
    • vapply ist ein verifiziert gelten (ermöglicht die Rückkehr-Objekt geben zu vorgegebenen)
    • rapply ist ein rekursive gelten für verschachtelte Listen, d.h. Listen innerhalb von Listen
    • tapply ist ein tagged gelten, wo die tags identifizieren die Teilmengen
    • apply ist generic: wendet eine Funktion einer matrix die Zeilen oder Spalten (oder, allgemeiner, um die Dimensionen eines Arrays)

    Gebäude Rechts im Hintergrund

    Wenn Sie mit der apply Familie fühlt sich immer noch ein wenig Fremd für Sie, dann könnte es sein, dass Sie fehlt ein entscheidender Punkt der Ansicht.

    Diese beiden Artikel helfen können. Sie liefern den notwendigen hintergrund zu motivieren, die funktionale Programmierung Technikendie von der apply Familie von Funktionen.

    Benutzer von Lisp wird erkennen das Paradigma sofort. Wenn Sie nicht vertraut sind mit Lisp, sobald Sie Ihren Kopf um FP, haben Sie gewonnen eine leistungsstarke point-of-view für den Einsatz in R-und apply machen viel mehr Sinn.

    InformationsquelleAutor der Antwort Assad Ebrahim

  5. 38

    Da erkannte ich, dass (sehr gute) Antworten zu diesem Beitrag fehlen by und aggregate Erklärungen. Hier ist mein Beitrag.

    Den by Funktion, wie in der Dokumentation erwähnt werden können, obwohl, wie ein "wrapper" für tapply. Die macht der by entsteht, wenn wir wollen, um zu berechnen, eine Aufgabe, die tapply nicht umgehen kann. Ein Beispiel ist dieser code:

    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

    Wenn wir drucken diese zwei Objekte ct und cb wir "im wesentlichen" die gleichen Ergebnisse und die einzigen Unterschiede sind, wie Sie dargestellt werden, und die verschiedenen class Attribute, bzw. by für cb und array für ct.

    Wie ich schon sagte, die macht der by entsteht, wenn wir nicht verwenden können tapply; der folgende code ist ein Beispiel:

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

    R sagt, dass Argumente müssen die gleichen Längen, sagen: "wir wollen die Berechnung der summary aller Variablen in iris entlang der Faktor Species": aber R kann das einfach nicht, weil Sie nicht wissen, wie Sie zu behandeln.

    Mit der by Funktion R Versand eine spezifische Methode für die data frame Klasse und dann lassen die summary - Funktion funktioniert auch dann, wenn die Länge des ersten Arguments (und der Typ auch) sind unterschiedlich.

    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

    es funktioniert tatsächlich und das Ergebnis ist sehr überraschend. Es ist ein Objekt der Klasse by dass entlang Species (sagen wir, für jeden von Ihnen) berechnet die summary für jede variable.

    Beachten Sie, dass, wenn das erste argument ein data framedie Funktion wird ausgelöst, muss eine Methode für die Klasse von Objekten. Zum Beispiel verwenden wir diesen code mit der mean Funktion wir haben in diesem code, dass hat überhaupt keinen Sinn:

     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

    aggregate gesehen werden kann als ein anderes eine andere Art und Weise der Verwendung tapply wenn wir es so.

    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

    Den beiden unmittelbaren Unterschiede sind, dass das zweite argument von aggregate muss eine Liste, während tapply kann (nicht obligatorisch) eine Liste und, dass die Ausgabe von aggregate ist ein Daten-frame, während die von tapply ist ein array.

    Die macht der aggregate ist, dass es gut umgehen können Teilmengen der Daten mit subset argument und, hat es Methoden für das ts Objekte und formula als gut.

    Diese Elemente machen aggregate einfacher, mit zu arbeiten, dass tapply in einigen Situationen.
    Hier sind einige Beispiele (in der Dokumentation):

    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

    Können wir erreichen das gleiche mit tapply aber die syntax ist etwas härter und die Ausgabe (in manchen Fällen) weniger lesbar:

    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

    Gibt es andere Zeiten, wir können nicht by oder tapply und wir haben die Verwendung von 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

    Wir können nicht erhalten Sie das Vorherige Ergebnis mit tapply in einem Aufruf, aber wir berechnen den Mittelwert entlang Month für die einzelnen Elemente und kombinieren Sie Sie dann (beachten Sie auch, dass wir rufen Sie die na.rm = TRUEweil die formula Methoden der aggregate Funktion hat standardmäßig die 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

    während mit by wir können nicht erreichen, dass in der Tat die folgende Funktion Aufruf gibt einen Fehler (aber wahrscheinlich ist es im Zusammenhang mit der mitgelieferten Funktion mean):

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

    Anderen Zeiten die Ergebnisse sind die gleichen und die Unterschiede sind nur in der Klasse (und dann, wie es dargestellt/gedruckt werden und nicht nur-Beispiel, wie Teilmenge) Objekt:

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

    Den vorherigen code das gleiche Ziel erreichen, und Ergebnisse, auf einige Punkte, welche Tools zu verwenden, ist nur eine Frage der persönlichen Vorlieben und Bedürfnisse; die vorigen zwei Objekte haben sehr unterschiedliche Bedürfnisse in Bezug auf die Untergruppen.

    InformationsquelleAutor der Antwort SabDeM

  6. 30

    Gibt es viele tolle Antworten diskutieren die Unterschiede in der use-cases für jede Funktion. Keines der Antwort diskutieren die Unterschiede in der Leistung. Das ist vernünftig verursachen Sie verschiedene Funktionen, die erwartet, dass verschiedene Eingaben und erzeugt verschiedene Ausgabeformate, doch die meisten von Ihnen haben eine Allgemeine gemeinsame Ziel zu bewerten, die von Serien/Gruppen. Meine Antwort geht auf die performance. Aufgrund der über die Eingabe-Erstellung von Vektoren ist im timing, auch die apply Funktion wird nicht gemessen.

    Ich getestet habe, haben zwei unterschiedliche Funktionen sum und length auf einmal. Lautstärke getestet, ist 50M auf input und 50K ausgegeben. Ich habe auch zwei derzeit beliebtesten Pakete, die nicht weit verbreitet zu der Zeit, wenn die Frage gestellt wurde, data.table und dplyr. Beide sind auf jeden Fall Wert zu schauen, wenn Sie wollen für gute Leistung. 

    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

    InformationsquelleAutor der Antwort jangorecki

  7. 20

    Es ist vielleicht erwähnenswert ave. ave ist tapply's freundlich cousin. Es liefert Ergebnisse in einer form, in der Sie stecken gerade wieder in Ihrem data frame.

    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
##   ...

    Gibt es nichts in der Basis-Paket, das funktioniert wie ave für die gesamte Daten-frames (als by ist wie tapply für Daten-frames). Aber Sie können fudge:

    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
## ...

    InformationsquelleAutor der Antwort

  8. 20

    Trotz all der tollen Antworten hier, gibt es 2 weitere Basis-Funktionen, die es verdienen, erwähnt zu werden, die nützlich outer Funktion und den obskuren eapply Funktion

    äußeren

    outer ist eine sehr nützliche Funktion versteckt, als ein langweiliger. Wenn Sie Lesen Sie die Hilfe für outer seiner Beschreibung sagt:

    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], ...).

    macht es scheinen, wie diese ist nur nützlich für die lineare algebra Art Dinge. Es kann jedoch verwendet werden, ähnlich wie mapply anwenden einer Funktion auf zwei Vektoren der Eingänge. Der Unterschied ist, dass mapply wird die Funktion anwenden, um die ersten zwei Elemente und dann die zweiten zwei usw., in der Erwägung, dass outer wird die Funktion anwenden, um jede Kombination eines Elementes aus der ersten Vektor-und einer aus der zweiten. Zum Beispiel:

     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

    Ich habe persönlich verwendet diese, wenn ich einen Vektor von Werten und einem Vektor, der die Bedingungen und wünschen, um zu sehen, welche Werte erfüllen die Bedingungen.

    eapply

    eapply ist wie lapply Ausnahme, dass, anstatt die Anwendung einer Funktion auf jedes element einer Liste, so wendet eine Funktion auf jedes element in einer Umgebung. Zum Beispiel, wenn Sie möchten, finden eine Liste von Benutzer-definierten Funktionen in der globalen Umwelt:

    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

    Ehrlich gesagt, ich benutze dies nicht sehr viel, aber wenn Sie eine Menge von Paketen oder erstellen Sie eine Menge von Umgebungen, es kann in handliches kommen.

    InformationsquelleAutor der Antwort John Paul

  9. 5

    Ich vor kurzem entdeckt, die Recht nützlich sweep - Funktion, und fügen Sie es hier, der Vollständigkeit halber:

    sweep

    Die grundlegende Idee ist sweep durch ein array Zeilen - oder spaltenweise und eine modifizierte array. Ein Beispiel soll dies deutlich machen (Quelle: datacamp):

    Lassen Sie uns sagen, Sie haben eine matrix und möchten standardisieren es spaltenweise:

    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: für dieses einfache Beispiel dasselbe Ergebnis kann natürlich leichter erzielt werden durch
    apply(dataPoints, 2, scale)

    InformationsquelleAutor der Antwort vonjd

Schreibe einen Kommentar