Mémo des fonctions lapply, sapply, tapply, apply

Image par Gerd Altmann de Pixabay

Ces fonctions lapply, sapply, tapply et lapply permettent d’appliquer une fonction (mean, par exemple, pour calculer une moyenne) sur des données, de façon itérative. Autrement dit, elles font la même chose qu’une boucle for(), tout en ayant une syntaxe concise, puisque ça se passe en une ligne de commande, et en étant plus rapide.

Néanmoins, de mon côté, j’ai toujours eu des difficultés à les employer parce que je ne me souviens jamais laquelle utiliser selon :

la structure de mes données d’entrées (data frame, vecteur, liste),
ce que je veux faire (appliquer une fonction par sous-groupe de données, appliquer une fonction sur les marges (sur chaque ligne ou chaque colonne) d’un data frame),
ce que je souhaite obtenir en sortie (un vecteur, une liste).

Savoir utiliser ces fonctions peut cependant s’avérer très utile. Alors, j’ai fini par me faire un petit mémo, que je vous partage ici.

La fonction lapply

Elle réalise une boucle sur une structure de type liste, en appliquant une fonction sur chaque élément de cette liste. La lettre l devant le apply correspond à `list`

Par défaut, les résultats sont également fournis sous forme d’une liste :

maliste <- list(E1=rnorm(10),E2=1:10, E3=runif(10))
maliste
## $E1
##  [1] -1.7984349  0.6276849  0.7310556  1.1642278 -1.0313113  0.1958217
##  [7] -1.9018991 -1.8122020 -0.3482781 -1.2713203
## 
## $E2
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $E3
##  [1] 0.723830546 0.838541188 0.845484439 0.039995958 0.615807877 0.917093245
##  [7] 0.867372951 0.224336368 0.001643635 0.081938347


lapply(maliste, mean)
## $E1
## [1] -0.5444656
## 
## $E2
## [1] 5.5
## 
## $E3
## [1] 0.5156045

Si on utilise une fonction qui nécessite des arguments, il faut les indiquer après la fonction, comme ici avec la fonction quantile() et l’argument probs.

lapply(maliste, quantile,probs=c(0.25,0.75))
## $E1
##        25%        75% 
## -1.6666563  0.5197191 
## 
## $E2
##  25%  75% 
## 3.25 7.75 
## 
## $E3
##       25%       75% 
## 0.1175379 0.8437486

On peut également obtenir les résultats sous la forme d’un vecteur en employant la fonction unlist() en amont :

unlist(lapply(maliste, mean))
##         E1         E2         E3 
## -0.5444656  5.5000000  0.5156045
unlist(lapply(maliste, quantile,probs=c(0.25,0.75)))
##     E1.25%     E1.75%     E2.25%     E2.75%     E3.25%     E3.75% 
## -1.6666563  0.5197191  3.2500000  7.7500000  0.1175379  0.8437486

Et il est aussi possible d’utiliser un vecteur en entrée, plutôt qu’une liste :

nom <- names(iris)
nom
## [1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"
class(nom)
## [1] "character"
NOM <- unlist(lapply(nom, toupper))
NOM
## [1] "SEPAL.LENGTH" "SEPAL.WIDTH"  "PETAL.LENGTH" "PETAL.WIDTH"  "SPECIES"

Donc, si on résume : lapply permet d’appliquer une fonction sur tous les éléments d’une liste, et fournit les résultats sous forme de liste.

MAIS…, on peut facilement transformer la liste de sortie en vecteur, grâce à la fonction unlist(). Et, on peut aussi donner en entrée un vecteur d’éléments !

Ce n’est donc pas pour rien que j’ai toujours eu du mal à m’y retrouver !

La fonction sapply

Le s est pour simplify ( de la sortie) ! Après ce qu’on vient de voir, on se dit forcément que c’est une bonne idée !

Allez, on regarde de plus près comment ça fonctionne :

maliste <- list(E1=rnorm(10),E2=1:10, E3=runif(10))
res <- sapply(maliste,mean)
res
##         E1         E2         E3 
## -0.6635282  5.5000000  0.4673550
class(res)
## [1] "numeric"

La fonction sapply fait donc la même chose que la fonction lapply, mais en fournissant directement un vecteur en sortie !

Un vecteur….ou une matrice, si la fonction renvoie plusieurs éléments :

res <- sapply(maliste,quantile,probs=c(0.25,0.75))
res
##              E1   E2        E3
## 25% -1.20998298 3.25 0.2139582
## 75%  0.04138477 7.75 0.7128085
class(res)
## [1] "matrix" "array"

Pas super simplifié, quand même !

La fonction tapply

La fonction tapply permet d’appliquer une fonction sur une variable, par sous-groupe de données, que l’on spécifie en argument. Et les résultats sont fournis sous une structure de type array.

Par exemple, on peut obtenir la moyenne des longueurs de sépale pour chaque espèce d’iris :

res <- tapply(iris$Sepal.Length,iris$Species, mean )
res
##     setosa versicolor  virginica 
##      5.006      5.936      6.588
class(res)
## [1] "array"

C’est l’équivalent de la fonction by(), mais sans la mise en forme:

by(iris$Sepal.Length,iris$Species, mean )
## iris$Species: setosa
## [1] 5.006
## ------------------------------------------------------------ 
## iris$Species: versicolor
## [1] 5.936
## ------------------------------------------------------------ 
## iris$Species: virginica
## [1] 6.588

On peut aussi employer cette syntaxe :

with(iris, tapply(Sepal.Length, Species, mean))
##     setosa versicolor  virginica 
##      5.006      5.936      6.588

Et comme précédemment, si la fonction employée nécessite des arguments supplémentaires, on les ajoute après la virgule :

res <- with(iris, tapply(Sepal.Length, Species, quantile, probs=c(0.25,0.75)))
res
## $setosa
## 25% 75% 
## 4.8 5.2 
## 
## $versicolor
## 25% 75% 
## 5.6 6.3 
## 
## $virginica
##   25%   75% 
## 6.225 6.900
class(res)
## [1] "array"

La fonction apply

La fonction apply permet d’appliquer une fonction sur toutes les lignes ou toutes les colonnes d’un data frame (ou une matrice). Si on souhaite appliquer la fonction sur les lignes, on va spécifier l’argument MARGIN=1 (en pratique, on utilise que le 1 en second argument de la fonction).

De la même manière, si on souhaite appliquer la fonction sur les colonnes, on va spécifier l’argument MARGIN=2(là encore, en pratique, on utilise que le 2 en second argument de la fonction)

Par exemple ici, si on souhaite faire la moyenne des 4 premières variables du jeu de données iris , sur les 10 premières lignes :

res <- apply(iris[1:10,1:4],1, mean, na.rm=TRUE)
res
##     1     2     3     4     5     6     7     8     9    10 
## 2.550 2.375 2.350 2.350 2.550 2.850 2.425 2.525 2.225 2.400
class(res)
## [1] "numeric"

C’est l’équivalent de la fonction rowMeans().

res <- rowMeans(iris[1:10,1:4])
res
##     1     2     3     4     5     6     7     8     9    10 
## 2.550 2.375 2.350 2.350 2.550 2.850 2.425 2.525 2.225 2.400
class(res)
## [1] "numeric"

Mais l’intérêt de apply, c’est qu’on peut utiliser n’importe quelle fonction :

res <- apply(iris[1:10,1:4],1, summary)
res
##            1     2     3     4    5     6     7     8     9   10
## Min.    0.20 0.200 0.200 0.200 0.20 0.400 0.300 0.200 0.200 0.10
## 1st Qu. 1.10 1.100 1.025 1.175 1.10 1.375 1.125 1.175 1.100 1.15
## Median  2.45 2.200 2.250 2.300 2.50 2.800 2.400 2.450 2.150 2.30
## Mean    2.55 2.375 2.350 2.350 2.55 2.850 2.425 2.525 2.225 2.40
## 3rd Qu. 3.90 3.475 3.575 3.475 3.95 4.275 3.700 3.800 3.275 3.55
## Max.    5.10 4.900 4.700 4.600 5.00 5.400 4.600 5.000 4.400 4.90
class(res)
## [1] "matrix" "array"

Comme la sortie summary() renvoie plusieurs éléments, la fonction apply renvoie, en sortie, une matrice.

Idem, pour les colonnes, en employant l’argument 2. Par exemple, ici, on calcule la moyenne des colonnes 1 à 4, c’est-à-dire les variables “Sepal.Length”, “Sepal.Width” , “Petal.Length”, “Petal.Width” :

res <- apply(iris[,1:4],2, mean, na.rm=TRUE)
res
## Sepal.Length  Sepal.Width Petal.Length  Petal.Width 
##     5.843333     3.057333     3.758000     1.199333
class(res)
## [1] "numeric"
res <- apply(iris[,1:4],2, quantile,probs=c(0.25,0.75))
res
##     Sepal.Length Sepal.Width Petal.Length Petal.Width
## 25%          5.1         2.8          1.6         0.3
## 75%          6.4         3.3          5.1         1.8
class(res)
## [1] "matrix" "array"

Pour aller plus loin

Si ces fonctions *apply() vous intéressent vous pouvez aussi explorer les fonctions vapply() et mapply(). Vous trouverez des informations ici, et là.

Je vous recommande aussi de regarder du côté du package purrr et ces fonctions map() qui permettent aussi d’appliquer une même fonction (ou une même série de fonctions) à chaque élément d’un ensemble de données.

Vous trouverez une introduction au package purrr et une liste de ressources pour apprendre à l’utiliser, dans mon article : Liste de ressources pour le package purrr

Ce petit mémo m’est très utile, et j’espère qu’il en sera de même pour vous. N’hésitez pas à me partager en commentaire des exemples de vos propres utilisations de ces fonctions apply. Cela aidera certainement ceux qui débutent !

Si cet article vous a plu, ou vous a été utile, et si vous le souhaitez, vous pouvez soutenir ce blog en faisant un don sur sa page Tipeee