Formation R perfectionnement Martin Chevalier (Insee)

---

Formation R Perfectionnement

Cette page comporte l’ensemble des cas pratiques de la formation R perfectionnement donnée à la Drees les 16 et 17 avril 2018 accompagnés de leur correction.

• Support de présentation
• Données utilisées dans les cas pratiques

Les supports de cette formation ont été conçus sous RStudio avec R Markdown et compilés le 10/04/2018. Certains éléments de mise en forme du site compagnon sont repris de l’ouvrage R packages de Hadley Wickham.

Ces supports seront durablement disponibles à l’adresse http:// t.slmc.fr/perf et leur code source sur github. L’ensemble est librement réutilisable sous © 2016-2018 Martin Chevalier CC BY-NC-SA 3.0.

Savoir utiliser les fonctions *apply(), do.call() et Reduce()

Le package microbenchmark est souvent utilisé dans cette partie et les suivantes pour mesurer la performance des des solutions testées :

install.packages("microbenchmark")
library(microbenchmark)

 

Cas pratique 1 Fonctions et environnements

Tout ce qui se passe dans R correspond à un appel de fonction. Comprendre le fonctionnement des fonctions et savoir en créer soi-même est donc crucial.

1. Utilisez les guillemets simples inversés (AltGr + 7 sur le clavier azerty) pour afficher le code associé au signe +. Utilisez-le comme une fonction classique avec la syntaxe nomFonction(parametre1, parametre2).

   Afficher/masquer la solution

   ---

   # Pour afficher le code d'une fonction, il suffit
   # de saisir son nom. Dans le cas des signes 
   # arithmétiques, il convient d'entourer le nom
   # de guillemets inversés
   `+`
   ## function (e1, e2)  .Primitive("+")
   
   # En utilisant les guillemets inversés, on peut
   # utiliser la fonction `+`() comme n'importe
   # quelle fonction (en appelant ses arguments dans
   # la parenthèse).
   `+`(2, 2)
   ## [1] 4

   ---

    

2. Définissez la fonction monCalcul(x, puissance) qui pour un vecteur numérique x quelconque :

   1. calcule sa somme ;

   2. met la somme à la puissance puissance.

   Dans un second temps, donnez à puissance la valeur 2 par défaut et faites en sorte que la fonction prenne en charge les vecteurs x présentant des valeurs manquantes NA.

   Afficher/masquer la solution

   ---

   # Associée à `<-`, la fonction function()
   # permet de définir une nouvelle fonction
   monCalcul <- function(x, puissance){
     resultat <- sum(x)^puissance
     return(resultat)
   }
   monCalcul(1:3, puissance = 2)
   ## [1] 36
   
   # La syntaxe suivante est équivalente : 
   monCalcul <- function(x, puissance) sum(x)^puissance
   monCalcul(1:3, puissance = 2)
   ## [1] 36
   
   # Pour ajouter un argument par défaut, il suffit 
   # de le spécifier dans la parenthèse de function()
   monCalcul <- function(x, puissance = 2) sum(x)^puissance
   monCalcul(1:3)
   ## [1] 36
   
   # L'argument na.rm = TRUE de la fonction sum()
   # permet d'exclure automatiquement les valeurs manquantes.
   monCalcul <- function(x, puissance = 2) sum(x, na.rm = TRUE)^puissance
   monCalcul(c(1:3, NA))
   ## [1] 36

   ---

    

3. Modifier la fonction pour ajouter une étape de vérification du type de x : prévoyez un message d’erreur si x est de type character ou factor.

   Afficher/masquer la solution

   ---

   # Les fonctions is.character() et is.factor() permettent
   # de tester le type de x. 
   monCalcul <- function(x, puissance = 2){
     if(is.character(x) || is.factor(x)) stop("x est de type caractère ou factor.")
     sum(x, na.rm = TRUE)^puissance
   }
   monCalcul(c("a", "c"))
   ## Error in monCalcul(c("a", "c")): x est de type caractère ou factor.

   ---

    

4. Quelle est la valeur de l’objet T ? Comment expliquez-vous que cet objet soit défini alors que vous ne l’avez pas vous-même créé (vous pouvez utiliser la fonction getAnywhere() pour répondre) ?

   Afficher/masquer la solution

   ---

   # L'objet T a par défaut la valeur TRUE
   T
   ## [1] TRUE
   
   # T est défini dans le package base de R comme un alias de TRUE
   getAnywhere(T)
   ## A single object matching 'T' was found
   ## It was found in the following places
   ##   package:base
   ##   namespace:base
   ## with value
   ## 
   ## [1] TRUE
   base::T
   ## [1] TRUE

   ---

    

5. Soumettez le code T <- 3. Que vaut désormais l’objet T ? Pourquoi R n’accède-t-il plus à la valeur stockée par défaut (vous pouvez utiliser la fonction search() pour répondre) ? Comment accéder désormais à la valeur par défaut ? Que retenez-vous quant à l’utilisation de T et de F en lieu et place de TRUE et FALSE dans un code ?

   Afficher/masquer la solution

   ---

   T <- 3
   T 
   ## [1] 3
   # R accède en premier lieu à l'environnement global, puis
   # aux packages dans l'ordre de search()
   search()
   ##  [1] ".GlobalEnv"             "package:foreign"       
   ##  [3] "package:bindrcpp"       "package:scales"        
   ##  [5] "package:Rcpp"           "package:Matrix"        
   ##  [7] "package:sqldf"          "package:RSQLite"       
   ##  [9] "package:gsubfn"         "package:proto"         
   ## [11] "package:microbenchmark" "package:ggplot2"       
   ## [13] "package:pryr"           "package:data.table"    
   ## [15] "package:nycflights13"   "package:dplyr"         
   ## [17] "package:MASS"           "package:ctv"           
   ## [19] "package:formatR"        "package:stats"         
   ## [21] "package:graphics"       "package:grDevices"     
   ## [23] "package:utils"          "package:datasets"      
   ## [25] "package:methods"        "Autoloads"             
   ## [27] "package:base"
   # Le package base est situé en dernière position.
   
   # Pour accéder explicitement à l'élément du package base,
   # on utilise ::
   base::T
   ## [1] TRUE
   
   # Le fait que T et F ne soit que des alias pour TRUE et FALSE
   # et donc que leur valeur soit modifiable invite à la plus
   # grande prudence dans leur utilisation. Elle est en fait
   # à proscrire dans la réalisation de projets importants 
   # (par exemple l'écriture d'un package).

   ---

    

 

Cas pratique 2 apply() : Appliquer une fonction selon les dimensions d’une matrice

1. Créez une matrice e1 de 3 lignes et de 5 colonnes en utilisant la fonction runif(). Ses valeurs sont-elles identiques si vous la générez une seconde fois ? Comment faire pour que cela soit le cas ?

   Afficher/masquer la solution

   ---

   # Par défaut,  l'utilisation sucessive de la fonction
   # runif() ne conduit pas aux mêmes résultats
   e1 <- matrix(runif(15), ncol = 5)
   e1
   ##           [,1]       [,2]      [,3]      [,4]      [,5]
   ## [1,] 0.9517595 0.09967682 0.1995403 0.6697140 0.6814065
   ## [2,] 0.5471749 0.97088164 0.2908252 0.4237895 0.6609128
   ## [3,] 0.9269703 0.60405585 0.7520751 0.9651914 0.7546232
   e1b <- matrix(runif(15), ncol = 5)
   e1b
   ##           [,1]         [,2]      [,3]       [,4]       [,5]
   ## [1,] 0.8563281 0.0129960224 0.6935136 0.87513154 0.24786063
   ## [2,] 0.7438388 0.2310905347 0.8141819 0.55749948 0.06994223
   ## [3,] 0.5767685 0.0006464222 0.1505970 0.07619284 0.53948312
   identical(e1, e1b)
   ## [1] FALSE
   
   # La fonction set.seed() permet en revanche d'initialiser
   # le générateur de nombres pseudo-aléatoires de R. 
   # Utilisé après la fonction set.seed(), deux fonctions
   # runif() donneront toujours le même résultat.
   set.seed(2016)
   e1 <- matrix(runif(15), ncol = 5)
   e1
   ##           [,1]      [,2]        [,3]       [,4]      [,5]
   ## [1,] 0.1801636 0.1335746 0.616631283 0.05345881 0.2225800
   ## [2,] 0.1429437 0.4775025 0.890547575 0.38868792 0.8765744
   ## [3,] 0.8416465 0.1212584 0.002623455 0.27295359 0.2466688
   set.seed(2016)
   e1b <- matrix(runif(15), ncol = 5)
   e1b
   ##           [,1]      [,2]        [,3]       [,4]      [,5]
   ## [1,] 0.1801636 0.1335746 0.616631283 0.05345881 0.2225800
   ## [2,] 0.1429437 0.4775025 0.890547575 0.38868792 0.8765744
   ## [3,] 0.8416465 0.1212584 0.002623455 0.27295359 0.2466688
   identical(e1, e1b)
   ## [1] TRUE

   ---

    

2. Utilisez la fonction apply() pour calculer la somme des termes de chaque ligne de e1. Comment auriez-vous pu faire autrement ? Utilisez la fonction microbenchmark() pour comparer ces deux solutions.

   Afficher/masquer la solution

   ---

   # La fonction apply() permet d'appliquer
   # une même fonction aux lignes ou aux colonnes
   # d'une matrice. 
   apply(e1, 1, sum)
   ## [1] 1.206408 2.776256 1.485151
   # Le second argument indique la dimension selon
   # laquelle appliquer la fonction (1 pour les lignes, 
   # 2 pour les colonnes). 
   
   # Cette opération est en fait nativement implémentée
   # via la fonction rowSums()
   rowSums(e1)
   ## [1] 1.206408 2.776256 1.485151
   
   # La fonction microbenchmark() permet de comparer
   # systématiquement ces deux stratégies (apply() ou
   # rowSums())
   microbenchmark(times = 1e4
     , apply = apply(e1, 1, sum)
     , rowSums = rowSums(e1)
   )
   ## Unit: microseconds
   ##     expr    min     lq    mean  median      uq      max neval
   ##    apply 21.308 24.342 28.2082 25.3315 26.6960 2252.306 10000
   ##  rowSums 16.411 19.057 21.6968 20.0705 21.3445  169.443 10000

   ---

    

3. Utilisez la fonction apply() pour centrer-réduire toutes les colonnes de e1 (i.e. leur soustraire leur moyenne puis les diviser par leur écart-type).

   Afficher/masquer la solution

   ---

   # Etape 1 : fonction pour centrer-réduire une variable
   x <- runif(10)
   mean(x) # Moyenne de x
   ## [1] 0.3157225
   sd(x) # Ecart-type de x
   ## [1] 0.2328214
   centrer_reduire <- function(x) ( x - mean(x) ) / sd(x)
   z <- centrer_reduire(x)
   mean(z)
   ## [1] 5.551115e-17
   sd(z)
   ## [1] 1
   
   # Etape 2 : utilisation dans un apply()
   e2 <- apply(e1, 2, centrer_reduire)
   colMeans(e2)
   ## [1]  0.000000e+00  3.700743e-17  1.110223e-16 -1.850372e-17  7.401487e-17
   apply(e2, 2, sd)
   ## [1] 1 1 1 1 1
   
   # Tout en une seule étape :
   e3 <- apply(e1, 2, function(x) ( x - mean(x) ) / sd(x))
   identical(e2, e3)
   ## [1] TRUE

   ---

    

 

Cas pratique 3 lapply() et sapply() : Appliquer une fonction aux éléments d’un vecteur, d’une liste ou aux colonnes d’un data.frame

1. On définit le vecteur f1 par f1 <- 5:15. Utilisez la fonction sapply() pour calculer la somme cumulée des éléments de f1. Quelle(s) alternative(s) envisageriez-vous ? Utilisez la fonction microbenchmark() pour comparer ces solutions.

   Afficher/masquer la solution

   ---

   # INDICATION : commencer par définir la fonction 
   # sumfirst(x, i) qui calcule la somme des i premiers 
   # éléments de x, puis utilisez-la dans un sapply(). 
   
   f1 <- 5:15
   
   # Méthode 1 : sapply()
   # L'objectif est d'obtenir un vecteur de longueur length(f1)
   # qui pour chaque élément i renvoie la somme des éléments 1 à i
   # de f1
   
   # Pour calculer la somme des 4 premiers termes, il suffit d'appliquer
   # la fonction sum() au vecteur f1 restreint à ses 4 premiers termes
   sum(f1[1:4])
   ## [1] 26
   
   # On généralise cette idée dans un sapply() en définissant
   # la fonction à la volée (x remplace ici le 4 de l'exemple)
   sapply(1:length(f1), function(i) sum(x[1:i]))
   ##  [1] 0.5808441 1.2996963 1.7508546 1.9072832 1.9705809 1.9829998 2.4652852
   ##  [8] 2.7432785 2.9876747 3.1572245        NA
   # Note : dans cette méthode pour chaque élément du vecteur
   # on recalcule la somme, sans réutiliser celle calculée
   # pour les éléments précédents.
   
   # Remarque : on peut aussi utiliser la fonction
   # seq_along() pour créer le vecteur d'indices
   sapply(seq_along(f1), function(i) sum(x[1:i]))
   ##  [1] 0.5808441 1.2996963 1.7508546 1.9072832 1.9705809 1.9829998 2.4652852
   ##  [8] 2.7432785 2.9876747 3.1572245        NA
   
   
   
   # Méthode 2 : cumsum()
   # La fonction cumsum() effectue nativement cette opération
   cumsum(f1)
   ##  [1]   5  11  18  26  35  45  56  68  81  95 110
   
   # Comparaison avec microbenchmark()
   microbenchmark(times = 1e4
     , sapply = sapply(seq_along(f1), function(i) sum(f1[1:i]))
     , cumsum = cumsum(f1)
   )
   ## Unit: nanoseconds
   ##    expr   min    lq       mean  median    uq     max neval
   ##  sapply 27908 29722 34932.9104 31192.5 33480 5585155 10000
   ##  cumsum   260   367   549.6245   545.0   629   15181 10000

   ---

    

2. On définit la liste f2 par

   f2 <- list(
     sample.int(26, 10, replace = TRUE)
     , sample.int(26, 100, replace = TRUE)
     , sample.int(26, 1000, replace = TRUE)
   )

Utilisez les fonctions lapply() ou sapply() pour :

• retrouver la longueur de chacun des éléments de f2 ;
• extraire les 5 premiers éléments de chacun des éléments de f2 ;

• remplacer chaque élément de f2 par le vecteur de lettres (en minuscules) dont il représente les positions dans l’alphabet.

  Afficher/masquer la solution

  ---

  # Les fonctions sapply() et lapply() permettent 
  # d'appliquer systématiquement une fonction aux éléments
  # d'une liste. 
  
  # Pour connaître la longueur de chaque élément de f2, 
  # il suffit ainsi d'appliquer à chacun la fonction length()
  lapply(f2, length)
  ## [[1]]
  ## [1] 10
  ## 
  ## [[2]]
  ## [1] 100
  ## 
  ## [[3]]
  ## [1] 1000
  
  # sapply() effectue exactement le même traitement que
  # lapply() mais essaie en plus de simplifier le résultat
  # si c'est possible
  sapply(f2, length)
  ## [1]   10  100 1000
  # Ici c'est le cas : on passe d'une liste avec lapply()
  # à un vecteur avec sapply()
  
  # Pour extraire les éléments 1 à 10 de chacun des éléments
  # de f2, on utilise l'opérateur [
  lapply(f2, function(x) x[1:10])
  ## [[1]]
  ##  [1]  2 17 13 12 25 25 17 16  4 20
  ## 
  ## [[2]]
  ##  [1]  4  3  4  9 11  8  7  9 10 17
  ## 
  ## [[3]]
  ##  [1] 18  5 15  8 14  6  7 13 26  2
  # On aurait aussi pu soumettre de façon équivalente 
  lapply(f2, `[`, 1:10)
  ## [[1]]
  ##  [1]  2 17 13 12 25 25 17 16  4 20
  ## 
  ## [[2]]
  ##  [1]  4  3  4  9 11  8  7  9 10 17
  ## 
  ## [[3]]
  ##  [1] 18  5 15  8 14  6  7 13 26  2
  # car x[1:10] est équivalent à `[`(x, 1:10)
  
  # Remplacer les éléments d'un des éléments de f2
  # par les lettres dont il représente la position
  # est relativement simple : 
  letters[f2[[1]]]
  ##  [1] "b" "q" "m" "l" "y" "y" "q" "p" "d" "t"
  # On reprend donc le principe de la sous-question
  # précédente dans un lapply()
  # lapply(f2, function(x) letters[x])
  # (commenté ici pour ne pas saturer la sortie).

  ---

   

3. On définit le data.frame f3 par

   set.seed(1)
   f3 <- data.frame(
     id = letters[1:20]
     , by = rep(letters[1:5], times = 4)
     , matrix(runif(100), ncol = 5)
     , stringsAsFactors = FALSE
   )

   Utilisez les fonctions lapply() ou sapply() pour :

• déterminer le type de chacune des variables de f3;
• calculer la moyenne de toutes les variables numériques de f3;
• convertir toutes les variables de type character en facteurs.
  Afficher/masquer la solution

  ---

  # Un data.frame étant un cas particulier de liste, 
  # on peut lui appliquer les fonctions lapply() et
  # sapply() exactement comme on le ferait pour une liste.
  
  # Pour connaître le type de chacun de ses éléments, 
  # on leur applique donc systématiquement la fonction
  # typeof()
  sapply(f3, typeof)
  ##          id          by          X1          X2          X3          X4 
  ## "character" "character"    "double"    "double"    "double"    "double" 
  ##          X5 
  ##    "double"
  
  # Pour appliquer une même fonction à toutes ses variables 
  # de type numériques, on commence par les identifier
  # avec un is.numeric() dans un sapply()
  num <- sapply(f3, is.numeric)
  num
  ##    id    by    X1    X2    X3    X4    X5 
  ## FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE
  # Puis on leur applique la fonction désirée
  sapply(f3[num], mean)
  ##        X1        X2        X3        X4        X5 
  ## 0.5551671 0.4738822 0.5072134 0.5665520 0.4864206
  
  # De même pour les variables de type caractère
  char <- sapply(f3, is.character)
  char
  ##    id    by    X1    X2    X3    X4    X5 
  ##  TRUE  TRUE FALSE FALSE FALSE FALSE FALSE
  f3[char] <- lapply(f3[char], as.factor)
  str(f3)
  ## 'data.frame':    20 obs. of  7 variables:
  ##  $ id: Factor w/ 20 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ...
  ##  $ by: Factor w/ 5 levels "a","b","c","d",..: 1 2 3 4 5 1 2 3 4 5 ...
  ##  $ X1: num  0.266 0.372 0.573 0.908 0.202 ...
  ##  $ X2: num  0.935 0.212 0.652 0.126 0.267 ...
  ##  $ X3: num  0.821 0.647 0.783 0.553 0.53 ...
  ##  $ X4: num  0.913 0.294 0.459 0.332 0.651 ...
  ##  $ X5: num  0.435 0.713 0.4 0.325 0.757 ...

  ---

   

 

Cas pratique 4 tapply() : Appliquer une fonction selon les modalités d’un vecteur

1. On définit le vecteur g1 <- sample(20) et le vecteur g2 <- rep(c("H", "F"), times = 10). Utilisez tapply() pour calculer la moyenne de g1 selon les groupes définis par g2.
   Afficher/masquer la solution

   ---

   set.seed(2)
   g1 <- sample(20)
   g2 <- rep(c("H", "F"), times = 10)
   
   # La fonction tapply() permet d'appliquer une fonction
   # à un vecteur selon les modalités d'un autre vecteur
   tapply(g1, g2, mean)
   ##    F    H 
   ## 10.7 10.3

   ---

    

2. On repart du data.frame f3 du cas pratique précédent. Utilisez tapply() pour calculer le total de la variable X1 selon les modalités de la variable by.
   Afficher/masquer la solution

   ---

   # Il suffit d'utiliser tapply() sur les variables de f3
   tapply(f3$X1, f3$by, sum)
   ##        a        b        c        d        e 
   ## 1.867572 2.210974 2.912580 2.301461 1.810755

   ---

    

3. Combinez la fonction split() avec sapply() pour obtenir le même résultat. Comment calculeriez-vous le total de toutes les variables numériques de f3 selon les modalités de la variable by ?

   Afficher/masquer la solution

   ---

   # La fonction split() éclate en une liste un vecteur 
   # ou un data.frame selon les modalités d'une ou plusieurs
   # variables.
   f3[,c("by", "X1")]
   ##    by         X1
   ## 1   a 0.26550866
   ## 2   b 0.37212390
   ## 3   c 0.57285336
   ## 4   d 0.90820779
   ## 5   e 0.20168193
   ## 6   a 0.89838968
   ## 7   b 0.94467527
   ## 8   c 0.66079779
   ## 9   d 0.62911404
   ## 10  e 0.06178627
   ## 11  a 0.20597457
   ## 12  b 0.17655675
   ## 13  c 0.68702285
   ## 14  d 0.38410372
   ## 15  e 0.76984142
   ## 16  a 0.49769924
   ## 17  b 0.71761851
   ## 18  c 0.99190609
   ## 19  d 0.38003518
   ## 20  e 0.77744522
   split(f3$X1, f3$by)
   ## $a
   ## [1] 0.2655087 0.8983897 0.2059746 0.4976992
   ## 
   ## $b
   ## [1] 0.3721239 0.9446753 0.1765568 0.7176185
   ## 
   ## $c
   ## [1] 0.5728534 0.6607978 0.6870228 0.9919061
   ## 
   ## $d
   ## [1] 0.9082078 0.6291140 0.3841037 0.3800352
   ## 
   ## $e
   ## [1] 0.20168193 0.06178627 0.76984142 0.77744522
   
   # Ce faisant, on peut avec une fonction lapply()
   # ou sapply() reproduire le comportent de la fonction
   # tapply()
   sapply(split(f3$X1, f3$by), sum)
   ##        a        b        c        d        e 
   ## 1.867572 2.210974 2.912580 2.301461 1.810755
   
   # L'avantage de cette technique est qu'elle
   # permet d'appliquer le même type de traitement
   # non à une seule variable mais à plusieurs
   # d'un seul coup
   sapply(split(f3[num], f3$by), function(x){
     sapply(x, sum)
   })
   ##           a        b        c        d        e
   ## X1 1.867572 2.210974 2.912580 2.301461 1.810755
   ## X2 2.471366 1.619339 1.635547 1.905174 1.846217
   ## X3 2.187388 1.847873 2.216894 2.192152 1.699960
   ## X4 2.402164 2.475928 1.962049 1.527737 2.963161
   ## X5 1.674290 1.937845 1.574059 2.257980 2.284239
   # ... ou de façon équivalente (mais un peu difficile
   # à relire !)
   sapply(split(f3[num], f3$by), sapply, sum)
   ##           a        b        c        d        e
   ## X1 1.867572 2.210974 2.912580 2.301461 1.810755
   ## X2 2.471366 1.619339 1.635547 1.905174 1.846217
   ## X3 2.187388 1.847873 2.216894 2.192152 1.699960
   ## X4 2.402164 2.475928 1.962049 1.527737 2.963161
   ## X5 1.674290 1.937845 1.574059 2.257980 2.284239
   # ... ou plus efficacement avec colSums()
   sapply(split(f3[num], f3$by), colSums)
   ##           a        b        c        d        e
   ## X1 1.867572 2.210974 2.912580 2.301461 1.810755
   ## X2 2.471366 1.619339 1.635547 1.905174 1.846217
   ## X3 2.187388 1.847873 2.216894 2.192152 1.699960
   ## X4 2.402164 2.475928 1.962049 1.527737 2.963161
   ## X5 1.674290 1.937845 1.574059 2.257980 2.284239

   ---

    

 

Cas pratique 5 do.call() : Appliquer une fonction simultanément à l’ensemble des éléments d’une liste

De nombreuses fonctions peuvent porter sur un nombre indéterminé d’éléments : c(), sum(), rbind(), etc. Pour les appliquer à l’ensemble des éléments d’une liste sans avoir à tous les écrire un à un, il suffit d’utiliser do.call().

1. On définit la liste h1 <- list(1:5, 6:10, 11:15). Que se passe-t-il si vous soumettez sum(h1) ? Utilisez do.call() pour sommer l’ensemble des éléments de h1. Comparez avec le résultat de sapply(h1, sum).

   Afficher/masquer la solution

   ---

   h1 <- list(1:5, 6:10, 11:15)
   
   # La fonction sum() ne peut pas porter sur une liste
   sum(h1)
   ## Error in sum(h1): 'type' (list) de l'argument incorrect
   
   # En revanche, il est possible d'appliquer la fonction
   # sum() à l'ensemble des éléments de h1
   sum(h1[[1]], h1[[2]], h1[[3]])
   ## [1] 120
   
   # Pour automatiser cette expression, on peut utiliser
   # do.call()
   do.call(sum, h1)
   ## [1] 120
   
   # A l'inverse, sapply(h1, sum) applique la fonction
   # sum() à chaque élément de h1 : 
   sapply(h1, sum)
   ## [1] 15 40 65

   ---

    

2. Réunissez les éléments de h1 en un seul vecteur avec la fonction base::c(). Comparez avec le résultat de lapply(h1, base::c)

   Afficher/masquer la solution

   ---

   # La fonction base::c() permet de concaténer
   # les vecteurs qui constituent h1 
   c(h1[[1]], h1[[2]], h1[[3]])
   ##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
   
   # Pour automatiser cette expression, on peut utiliser
   # do.call()
   do.call(base::c, h1)
   ##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
   # Note : on utilise ici base::c pour bien indiquer que
   # c'est la fonction c() du package base que l'on 
   # souhaite utiliser. En effet, si l'on avait défini
   # on objet c dans l'environnement global il y aurait
   # eu un conflit de noms.
   
   # lapply(h1, base::c) applique la fonction base::c()
   # à chaque élément de h1, ce qui ne change rien
   lapply(h1, base::c)
   ## [[1]]
   ## [1] 1 2 3 4 5
   ## 
   ## [[2]]
   ## [1]  6  7  8  9 10
   ## 
   ## [[3]]
   ## [1] 11 12 13 14 15

   ---

    

3. On définit la liste de matrices h2

   h2 <- list(
     matrix(1:6, nrow = 2)
     , matrix(7:12, nrow = 2)
     , matrix(13:18, nrow = 2)
   )

   Utilisez do.call() avec les fonctions rbind() et cbind() pour concaténer l’ensemble des éléments de h2 en ligne ou en colonne respectivement.
   Afficher/masquer la solution

   ---

   # Pour concaténer les éléments de h2 en ligne, 
   # on utilise rbind()
   rbind(h2[[1]], h2[[2]], h2[[3]])
   ##      [,1] [,2] [,3]
   ## [1,]    1    3    5
   ## [2,]    2    4    6
   ## [3,]    7    9   11
   ## [4,]    8   10   12
   ## [5,]   13   15   17
   ## [6,]   14   16   18
   
   # Pour automatiser cette expression, on peut utiliser
   # do.call()
   do.call(rbind, h2)
   ##      [,1] [,2] [,3]
   ## [1,]    1    3    5
   ## [2,]    2    4    6
   ## [3,]    7    9   11
   ## [4,]    8   10   12
   ## [5,]   13   15   17
   ## [6,]   14   16   18
   
   # De même en colonne avec cbind()
   do.call(cbind, h2)
   ##      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
   ## [1,]    1    3    5    7    9   11   13   15   17
   ## [2,]    2    4    6    8   10   12   14   16   18

   ---

    

 

Cas pratique 6 Reduce() : Appliquer une fonction successivement à l’ensemble des éléments d’une liste

De nombreuses fonctions portent sur deux éléments précisément : opérations arithmétiques, merge(), etc. Pour les appliquer successivement à l’ensemble des éléments d’une liste, il suffit d’utiliser Reduce().

1. On repart de la liste h1 du cas pratique précédent. Observez le résultat de Reduce(`+`, h1) : comment le comprenez-vous ? Comparez avec sapply(h1, sum).

   Afficher/masquer la solution

   ---

   # Reduce(f, x) applique la fonction f() aux éléments de x
   # 2 à 2 et successivement. 
   Reduce(`+`, h1)
   ## [1] 18 21 24 27 30
   # Ici, cette expression est équivalente à 
   ( h1[[1]] + h1[[2]] ) + h1[[3]]
   ## [1] 18 21 24 27 30
   # Le vecteur obtenu est la somme terme à terme de 
   # tous les éléments qui composent h1
   
   # A l'inverse, sapply(h1, sum) applique la fonction
   # sum() à chaque élément de h1 : 
   sapply(h1, sum)
   ## [1] 15 40 65

   ---

    

2. On définit la liste de data.frame i1

   i1 <- list(
     data.frame(id = letters[1:4], var1 = 1:4, stringsAsFactors = FALSE)
     , data.frame(id = letters[2:5], var2 = 5:8, stringsAsFactors = FALSE)
     , data.frame(id = letters[3:6], var3 = 9:12, stringsAsFactors = FALSE)
   )

   Utilisez Reduce() pour fusionner l’ensemble des éléments de i1 selon la variable id. Comment ajusteriez-vous ce code pour pouvoir utiliser l’option all = TRUE de la fonction merge() ?
   Afficher/masquer la solution

   ---

   # La fonction Reduce() est particulièrement utile 
   # pour fusionner de nombreux data.frame selon la
   # même variable. Par défaut, la fonction merge()
   # fusionne les data.frame sur les variables qu'ils
   # ont en commun.
   Reduce(merge, i1)
   ##   id var1 var2 var3
   ## 1  c    3    6    9
   ## 2  d    4    7   10
   # Ce code fournit le résultat désiré. 
   
   # Pour spécifier explicitement la variable de fusion, 
   # il faut redéfinir à la volée la fonction à appliquer 
   # dans le Reduce() (comme dans un *apply) : 
   Reduce(function(x, y) merge(x, y, by = "id"), i1)
   ##   id var1 var2 var3
   ## 1  c    3    6    9
   ## 2  d    4    7   10
   
   # De même pour ajouter d'autres options à la fonction 
   # merge()
   Reduce(function(x, y) merge(x, y, by = "id", all = TRUE), i1)
   ##   id var1 var2 var3
   ## 1  a    1   NA   NA
   ## 2  b    2    5   NA
   ## 3  c    3    6    9
   ## 4  d    4    7   10
   ## 5  e   NA    8   11
   ## 6  f   NA   NA   12

   ---

    

Travailler efficacement sur des données avec base R

L’ensemble des cas pratiques qui suivent portent sur les données de l’enquête Emploi en continu stockées dans le fichier eect4.rds. La fonction readRDS() permet de le charger en mémoire :

setwd("Y:/Documentation/R/R_perfectionnement/donnees")
eec <- readRDS("eect4.rds")
str(eec)

## 'data.frame':    34913 obs. of  19 variables:
##  $ IDENT    : chr  "G0A56JP6" "G0A56JP6" "G0A56JR6" "G0A56JS6" ...
##  $ TRIM     : chr  "4" "4" "4" "4" ...
##  $ NOI      : chr  "01" "02" "01" "01" ...
##  $ REG      : chr  "11" "11" "11" "11" ...
##  $ AGE      : chr  "66" "29" "27" "29" ...
##  $ SEXE     : chr  "2" "1" "2" "2" ...
##  $ CSE      : chr  "56" "81" "38" "37" ...
##  $ DIP11    : chr  "71" "42" "10" "11" ...
##  $ ACTEU    : chr  "1" "2" "1" "1" ...
##  $ SALRED   : int  596 NA 2700 2666 11967 NA 2000 2800 2333 3500 ...
##  $ STC      : chr  "2" NA "2" "2" ...
##  $ TAM1D    : chr  NA NA NA NA ...
##  $ AIDREF   : chr  NA "5" NA NA ...
##  $ TPP      : chr  "1" NA "1" "1" ...
##  $ NBAGENF  : chr  "0" "0" "0" "0" ...
##  $ DUHAB    : chr  "7" NA "7" "7" ...
##  $ PUB3FP   : chr  "4" NA "4" "4" ...
##  $ NAIA     : chr  "1946" "1983" "1985" "1983" ...
##  $ EXTRI1613: num  1777 1777 2045 1898 1754 ...

 

Cas pratique 7 Sélection d’observations

1. Utilisez l’opérateur [ pour sélectionner l’individu appartenant au ménage dont l’IDENT est "GFO5NVUE" et dont le numéro d’ordre NOI est "02".

   Afficher/masquer la solution

   ---

   # Il suffit de créer le vecteur logique correspondant
   # et de l'utiliser das `[`
   eec[eec$IDENT == "GFO5NVUE" & eec$NOI == "02", ]  
   ##           IDENT TRIM NOI REG AGE SEXE CSE DIP11 ACTEU SALRED STC TAM1D
   ## 360720 GFO5NVUE    4  02  42  56    1  63    50     1   2004   2  <NA>
   ##        AIDREF TPP NBAGENF DUHAB PUB3FP NAIA EXTRI1613
   ## 360720   <NA>   1       0     6      4 1956  990.2715

   ---

    

2. Cherchez de la documentation sur la fonction subset(). Comparez ses performances avec celles de l’opérateur [ à l’aide de la fonction microbenchmark().

   Afficher/masquer la solution

   ---

   # subset() permet d'évaluer une clause logique
   # sans avoir à répéter le nom du data.frame
   # d'origine
   subset(eec, IDENT == "GFO5NVUE" & NOI == "02")
   ##           IDENT TRIM NOI REG AGE SEXE CSE DIP11 ACTEU SALRED STC TAM1D
   ## 360720 GFO5NVUE    4  02  42  56    1  63    50     1   2004   2  <NA>
   ##        AIDREF TPP NBAGENF DUHAB PUB3FP NAIA EXTRI1613
   ## 360720   <NA>   1       0     6      4 1956  990.2715
   
   # Comparaison des performances
   microbenchmark(times = 1e2
     , "[" = eec[eec$IDENT == "GFO5NVUE" & eec$NOI == "02", ]  
     , subset = subset(eec, IDENT == "GFO5NVUE" & NOI == "02")
   )
   ## Unit: milliseconds
   ##    expr      min       lq     mean   median       uq      max neval
   ##       [ 1.323394 1.386014 1.640976 1.426236 1.501453 7.292565   100
   ##  subset 1.497029 1.555517 1.919099 1.613505 1.712313 7.904183   100

   ---

    

3. Concaténez les valeurs des variables IDENT et NOI et utilisez le résultat comme noms de ligne. Retrouvez alors l’individu de la question a à l’aide de son nom de ligne. Comparez les performances de cette méthode avec celles de l’opérateur [.

   Afficher/masquer la solution

   ---

   # La foncton paste0() permet de concaténer des chaînes
   # de caractères sans utiliser de délimiteur
   row.names(eec) <- paste0(eec$IDENT, eec$NOI)
   
   # Sélection de l'individu par son nom de ligne
   eec["GFO5NVUE02", ]
   ##               IDENT TRIM NOI REG AGE SEXE CSE DIP11 ACTEU SALRED STC TAM1D
   ## GFO5NVUE02 GFO5NVUE    4  02  42  56    1  63    50     1   2004   2  <NA>
   ##            AIDREF TPP NBAGENF DUHAB PUB3FP NAIA EXTRI1613
   ## GFO5NVUE02   <NA>   1       0     6      4 1956  990.2715
   
   # Comparaison des performances
   microbenchmark(times = 1e2
     , "[" = eec[eec$IDENT == "GFO5NVUE" & eec$NOI == "02", ]  
     , names = eec["GFO5NVUE02", ]
   )
   ## Unit: microseconds
   ##   expr      min       lq     mean   median       uq      max neval
   ##      [ 1320.147 1428.255 1642.419 1500.146 1553.541 9371.659   100
   ##  names  896.914 1028.111 1217.348 1146.683 1232.324 8138.571   100

   ---

    

 

Cas pratique 8 Création de variables

On souhaite recoder la variable AGE en trois modalités : 15-30 ans, 31-60 ans et plus de 60 ans. On part du code suivant :

for(i in 1:nrow(eec)) eec$trage1[i] <- if(as.numeric(eec$AGE[i]) < 31) "15-30" else if(as.numeric(eec$AGE[i]) < 61) "31-60" else "61 et +"

1. Mesurez le temps d’exécution du code proposé. Que pensez-vous de cette syntaxe ?

   Afficher/masquer la solution

   ---

   # Mesure du temps d'exécution de cette première version
   microbenchmark(times = 1
     , v1 = {
   for(i in 1:nrow(eec)) eec$trage1[i] <- if(as.numeric(eec$AGE[i]) < 31) "15-30" else if(as.numeric(eec$AGE[i]) < 61) "31-60" else "61 et +"
     }
   )
   ## Unit: seconds
   ##  expr      min       lq     mean   median       uq      max neval
   ##    v1 7.826031 7.826031 7.826031 7.826031 7.826031 7.826031     1
   # Remarques : 
   # - on ne fait qu'une seule itération car le temps d'exécution 
   # est très long (plusieurs secondes !).
   # - le as.numeric() n'est pas indispensable mais accélère sensiblement
   # le traitement en faisant en sorte que la comparaison par < s'effectue 
   # entre vecteurs de type numérique et pas entre vecteurs de type caractère.
   
   # Cette syntaxe présente un énorme problème : elle utilise
   # une boucle là où des opérations vectorisées beaucoup 
   # plus rapides sont disponibles.

   ---

    

2. On propose une seconde version du code :

   eec$trage2 <- ifelse(as.numeric(eec$AGE) < 31, "15-30", ifelse(
     as.numeric(eec$AGE) < 61, "31-60", "61 et +"
   ))

   Vérifiez que le résultat est identique à la proposition initiale (par exemple avec identical()ou all.equal()) et mesurez le temps temps d’exécution de cette deuxième version. Êtes-vous surpris du gain de performances ?

   Afficher/masquer la solution

   ---

   eec$trage2 <- ifelse(as.numeric(eec$AGE) < 31, "15-30", ifelse(
     as.numeric(eec$AGE) < 61, "31-60", "61 et +"
   ))
   
   # Vérification de la correspondance 
   # avec la première version
   all.equal(eec$trage1, eec$trage2)
   ## [1] TRUE
   
   # Comparaison des performances
   microbenchmark(times = 1e1
     , v2 = {
   eec$trage2 <- ifelse(as.numeric(eec$AGE) < 31, "15-30", ifelse(
     as.numeric(eec$AGE) < 61, "31-60", "61 et +"
   ))
     }
   )
   ## Unit: milliseconds
   ##  expr      min       lq     mean   median       uq      max neval
   ##    v2 22.00497 22.06697 22.09491 22.10118 22.12497 22.20733    10
   
   # On n'est pas surpris du gain de performance : en R, 
   # les boucles sont beaucoup moins efficaces que les 
   # opérations vectorisées (qui reposent sur des 
   # boucles dans des langages de plus bas niveau).

   ---