Tutoriel sur la famille Apply en R

La famille apply()

La famille apply() fait partie de R base et réunit des fonctions permettant de manipuler de façon répétitive des tranches de données de matrices, tableaux, listes et data frames. Elles permettent de parcourir les données de plusieurs manières et d’éviter l’usage explicite de boucles. Elles agissent sur une liste, une matrice ou un tableau en entrée et y appliquent une fonction donnée, avec un ou plusieurs arguments optionnels.

La fonction appelée peut être :

• une fonction d’agrégation, par exemple la moyenne ou la somme (qui renvoient un nombre ou un scalaire) ;
• d’autres fonctions de transformation ou de création de sous-ensembles ; et
• d’autres fonctions vectorisées, qui produisent des structures plus complexes comme des listes, vecteurs, matrices et tableaux.

Les fonctions apply() servent de base à des combinaisons plus complexes et permettent d’effectuer des opérations en très peu de lignes. Plus précisément, la famille comprend les fonctions apply(), lapply(), sapply(), vapply(), mapply(), rapply() et tapply().

Mais comment et quand les utiliser ?

Tout dépend de la structure des données à traiter et du format de sortie souhaité.

# Construct a 5 x 6 matrix
my_matrix <- matrix(1:30, nrow = 5, ncol = 6)

# Calculate the sum of each column
col_sums <- apply(my_matrix, 2, sum)

# Print the result
print(col_sums)

La fonction lapply()

Vous souhaitez appliquer une fonction à chaque élément d’une liste et obtenir une liste en sortie. Quand vous exécutez ?lapply, vous verrez que la syntaxe ressemble à celle de apply().

La différence :

1. Elle s’applique aussi à d’autres objets comme les data frames, les listes ou les vecteurs ; et
2. La sortie est une liste (d’où le « l » de son nom), qui comporte autant d’éléments que l’objet passé en entrée.

Pour voir cela, créons quelques matrices et extrayons, pour chacune, une colonne donnée.

C’est une opération courante sur des données réelles pour comparer ou agréger des informations provenant de différents data frames.

Notre exemple jouet, illustré en figure 2, peut s’écrire ainsi :

L’opération est montrée dans la partie gauche de la figure 2.

Vous commencez par préciser l’objet d’intérêt, la liste Mylist. Vous utilisez l’opérateur de sélection R standard [ et omettez le premier paramètre (ce qui revient à « tout », d’où les deux virgules).

Ensuite, vous indiquez le second paramètre, 2 : notre marge est la colonne. Vous extrayez donc la deuxième colonne de toutes les matrices de la liste.

Quelques remarques :

• La notation [ est l’opérateur de sélection. Par exemple, pour extraire tous les éléments de la troisième ligne de B : B[3,] ;
• La notation [[ ]] traduit que l’on manipule des listes : [[2]] signifie le deuxième élément de la liste. C’est visible dans la sortie de R ;
• La sortie est une liste avec autant d’éléments que l’entrée ; et
• Vous auriez aussi pu extraire un seul élément par matrice, ainsi : lapply(MyList,"[", 1, 2)

Dans la partie droite de la figure 2, vous voyez une extraction alternative : cette fois, vous omettez le premier paramètre et récupérez la première ligne de chaque matrice.

À vous de jouer ! Sélectionnez la deuxième colonne de chaque matrice dans la liste :

La fonction sapply()

La fonction sapply() fonctionne comme lapply(), mais tente de simplifier la sortie vers la structure de données la plus élémentaire possible. En effet, sapply() est un « wrapper » autour de lapply().

Un exemple aide à comprendre : répétons l’extraction d’un élément unique comme précédemment, mais en prenant cette fois, pour chaque matrice, le premier élément de la deuxième ligne (index 2 et 1).

Avec lapply(), on obtiendrait une liste, sauf si vous passez simplify=FALSE à sapply(). Dans ce cas, une liste sera renvoyée. Voyez le fonctionnement ci-dessous :

Inversement, une fonction comme unlist() peut demander à lapply() de vous renvoyer un vecteur !

Pour éviter toute confusion, il est préférable d’utiliser ces fonctions dans leur « format natif » et d’éviter les conversions, sauf nécessité.

La fonction rep()

Une fonction souvent utilisée avec apply() est rep(). Appliquée à un vecteur ou un facteur x, elle réplique ses valeurs un nombre de fois donné.

Reprenons l’un des vecteurs générés ci-dessus avec lapply() dans MyList.

Cette fois, vous sélectionnez uniquement les éléments de la première ligne et de la première colonne de chaque élément de la liste MyList (et vous utilisez sapply() pour obtenir un vecteur) :

Vous voyez que le code ci-dessus réplique les valeurs de Z un nombre de fois défini par c(3,1,2) : trois fois la première, une fois la deuxième et deux fois la troisième.

Pratique, non ?

La fonction mapply()

La fonction mapply() signifie « multivariée ». Elle permet de vectoriser les arguments d’une fonction qui, à l’origine, n’accepte pas des vecteurs en arguments.

En bref, mapply() applique une fonction à plusieurs listes ou plusieurs vecteurs d’arguments.

Voyons un exemple avec mapply() où vous créez une matrice 4 x 4 en appelant rep() de manière répétée :

Vous voyez qu’il existe une manière plus efficace d’assembler les résultats de rep() qu’avec c() : en appelant mapply(), vous vectorisez l’action de la fonction rep().

Fonctions apparentées à apply()

Des fonctions structurées de manière similaire sont parfois utilisées avec les éléments de la famille apply() : ce tutoriel en présente un bref aperçu.

La fonction aggregate()

Cette fonction appartient au package stats et s’utilise ainsi : aggregate(x, by, FUN, ..., simplify = TRUE).

En d’autres termes, elle fonctionne de manière similaire à apply() : vous indiquez l’objet, la fonction et si vous souhaitez simplifier, comme avec sapply(). La différence clé est l’usage de l’argument by, qui définit la variable (ou la colonne d’un data frame) selon laquelle effectuer l’agrégation.

La section suivante illustre son fonctionnement.

Exemple avec aggregate()

Considérons un petit jeu de données appelé Mydf, qui contient des ventes d’un produit, et où certaines valeurs de la colonne DepPC (département) se répètent.

Cette variable classe les données par zone géographique, comme une partie d’un code postal (ici, les numéros correspondent aux départements de l’Île-de-France).

Vous souhaitez réaliser quelques statistiques sur les colonnes de ventes. Ce sont DProgr, un numéro progressif dans l’ordre chronologique, et les ventes du produit (Qty), plus une variable logique, Delivered, indiquant si le produit a été livré (T) ou non (F).

Commencez par quelques opérations simples pour vous familiariser avec le jeu de données, au-delà de l’afficher en entier en tapant simplement son nom (ici 120 enregistrements, mais imaginez un vrai fichier avec des milliers de lignes !).

Explorons les données :

Remarque : pour connaître le nombre de lignes et de colonnes du data frame, vous pouvez aussi appeler nrow(Mydf) et ncol(Mydf).

De nombreuses autres explorations sont possibles.

Ici, vous voulez savoir dans quel département le produit se vend le mieux. Regroupez donc les données par département et sommez les ventes Qty pour chaque département DepPC à l’aide de aggregate() :

Ainsi, aggregate() indique à R de sommer toutes les Qty appartenant au même département.

Notez que R assigne la somme à une variable « x » puisque vous n’avez pas indiqué autre chose.

La sortie est lisible telle quelle, mais avec un plus grand nombre de départements, cela peut devenir moins clair. Dans ce cas, vous pouvez recourir à une visualisation : tracez les résultats avec l’un des systèmes graphiques de R, conjointement à aggregate() :

Vous obtenez ainsi les ventes par département.

Vous pouvez poser la même question, mais uniquement pour les produits livrés. Pour cela, commencez par créer un sous-ensemble des données où Delivered vaut vrai (T) en utilisant l’opérateur de sous-ensemble "[".

Remarque : ici, vous assignez le résultat à une nouvelle variable Y, un nouveau data frame qui hérite des mêmes noms de colonnes que le parent Mydf. Cela évite de répéter l’instruction d’agrégation dans l’appel au tracé, pour plus de lisibilité :

Vous pouvez ainsi poser différentes questions aux données de manière vectorisée avec aggregate(), souvent en l’associant à un système de visualisation pratique comme ggplot2. Vous avez l’idée.

Notez qu’il ne faut que quelques lignes de code pour obtenir cela.

La vectorisation comme alternative aux boucles et aux fonctions Apply ?

Vous avez vu plusieurs variantes autour du même thème : « agir de manière répétée sur un jeu de données structuré ». En ce sens, ces fonctions constituent non seulement une alternative aux boucles, mais aussi une manière « vectorisée » de procéder.

« Vectorisée » au sens large ici : nous n’entrerons pas dans le débat pour savoir si – et lesquelles des – fonctions apply() sont réellement vectorisées (voir par exemple la discussion ici).

En pratique, pour choisir quelle fonction apply() utiliser, tenez compte des éléments suivants :

• Le type de données en entrée : l’objet à traiter (vecteur, matrice, tableau, liste, data frame, ou une combinaison) ;
• Ce que vous souhaitez faire : la fonction FUN à passer ;
• Le sous-ensemble de données : lignes, colonnes, ou l’ensemble ?
• Le type de sortie souhaité : vous devrez peut-être enchaîner d’autres opérations (souhaitez-vous un nouvel objet, ou transformer l’objet d’entrée directement ?)

Ce sont des questions générales que vous pouvez également poser pour les fonctions associées, comme aggregate(), by(), sweep(), etc.

Mais il y en a bien d’autres ! Continuez d’explorer. Consultez le tutoriel DataCamp Arrays in R.

Pour aller plus loin, suivez les cours Introduction to R ou Intermediate R de DataCamp.