Quelle est la différence entre lapply et à faire.appel en R?

Question

Je suis d'apprentissage R récemment et confus par deux fonction: lapplyet do.call. Il semble qu'ils sont juste similaire à l' map fonction Lisp. Mais pourquoi il y a deux fonctions avec un nom différent? Pourquoi ne pas la R suffit d'utiliser une fonction appelée map?

Answer 1

Il y a une fonction appelée Map qui peut être semblable à la carte dans les autres langues:

• lapply renvoie une liste de la même longueur que X, dont chaque élément est le résultat de l'application du PLAISIR à l'élément correspondant de X.

• do.call construit et exécute un appel de fonction à partir d'un nom ou d'une fonction et une liste d'arguments pour être transmis.

• Map s'applique une fonction aux éléments correspondants de vecteurs... Map est un simple wrapper mapply qui ne cherche pas à simplifier le résultat, semblable à la Common Lisp est mapcar (avec des arguments qui sont recyclées, cependant). Les futures versions peuvent permettre un certain contrôle sur le type de résultat.

---

1. Map est un wrapper autour de mapply
2. lapply est un cas spécial de l' mapply
3. Par conséquent, Map et lapply sera similaire dans de nombreux cas.

Par exemple, ici, est - lapply:

lapply(iris, class)
$Sepal.Length
[1] "numeric"

$Sepal.Width
[1] "numeric"

$Petal.Length
[1] "numeric"

$Petal.Width
[1] "numeric"

$Species
[1] "factor"

Et même à l'aide de Map:

Map(class, iris)
$Sepal.Length
[1] "numeric"

$Sepal.Width
[1] "numeric"

$Petal.Length
[1] "numeric"

$Petal.Width
[1] "numeric"

$Species
[1] "factor"

---

do.call prend une fonction en entrée et les éclaboussures de ses autres arguments de la fonction. Il est largement utilisé, par exemple, pour assembler des listes dans des structures plus simples (souvent avec de l' rbind ou cbind).

Par exemple:

x <- lapply(iris, class)
do.call(c, x)
Sepal.Length  Sepal.Width Petal.Length  Petal.Width      Species 
   "numeric"    "numeric"    "numeric"    "numeric"     "factor" 

Answer 2

lapply s'applique une fonction sur une liste, do.call appelle une fonction avec une liste d'arguments. Qui ressemble tout à fait une différence pour moi...

Pour donner un exemple avec une liste :

X <- list(1:3,4:6,7:9)

Avec lapply vous obtenez la moyenne de chaque élément dans la liste comme ceci :

> lapply(X,mean)
[[1]]
[1] 2

[[2]]
[1] 5

[[3]]
[1] 8

do.call donne une erreur, que signifie s'attend à ce que l'argument "trim" pour être 1.

D'autre part, rbind lie tous les arguments rowwise. Donc, pour lier X rowwise, vous ne :

> do.call(rbind,X)
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

Si vous utilisez lapply, R s'appliquerait rbind pour chaque élément de la liste, vous donnant ce non-sens :

> lapply(X,rbind)
[[1]]
     [,1] [,2] [,3]
[1,]    1    2    3

[[2]]
     [,1] [,2] [,3]
[1,]    4    5    6

[[3]]
     [,1] [,2] [,3]
[1,]    7    8    9

Pour avoir quelque chose comme la Carte, vous avez besoin d' ?mapply, ce qui est quelque chose de différent en tout. POUR obtenir par exemple la moyenne de chaque élément de X, mais avec un autre parage, vous pouvez utiliser :

> mapply(mean,X,trim=c(0,0.5,0.1))
[1] 2 5 8

Answer 3

lapply est similaire à l' map, do.call ne l'est pas. lapply s'applique une fonction à tous les éléments d'une liste, do.call appelle une fonction où tous les arguments de la fonction sont dans une liste. Donc, pour l' n élément de la liste, lapply a n des appels de fonction, et do.call a juste un appel de fonction. Donc, do.call est tout à fait différent de lapply. Espérons que cela clarifie votre problème.

Un exemple de code:

do.call(sum, list(c(1,2,4,1,2), na.rm = TRUE))

et:

lapply(c(1,2,4,1,2), function(x) x + 1)

Answer 4

Dans la plupart des mots simples:

1. lapply() applique une fonction à chaque élément d'une liste,il y aura plusieurs appels de fonction.

2. n'.call() applique une fonction donnée de la liste dans son ensemble,il est donc uniquement un seul appel de fonction.

La meilleure façon d'apprendre est de jouer avec les exemples de fonction dans le R de la documentation.

Answer 5

lapply() est une carte de type fonction. do.call() est différent. Il est utilisé pour passer des arguments à une fonction sous forme de liste au lieu de les avoir énumérés. Par exemple,

> do.call("+",list(4,5))
[1] 9