Sauvegarder le code …

Pas l’environnement !

Utiliser un IDE¹

• RStudio :
  https://www.rstudio.com/products/rstudio/download/#download

• Emacs + ESS :
  https://ess.r-project.org

• vim + Nvim-R :
  https://medium.com/free-code-camp/turning-vim-into-an-r-ide-cd9602e8c217

• Visual Studio Code + vscode-R :
  https://github.com/REditorSupport/vscode-R

Faire table rase à chaque démarrage !

Lorsque vous quittez  :

• Ne pas enregistrer votre espace de travail (workspace¹) !

Lorsque vous démarrez  :

• Ne pas charger l’espace de travail sauvegardé précédemment !

Faire table rase !

Dans Windows

Faire table rase !

Dans RStudio (Tools > Global options)

Faire table rase !

• Dans un Terminal.

  R --no-save --no-restore-data

• .bash_profile / .bashrc / …

  alias R='R --no-save --no-restore-data'

Comment Réinitialiser  ?

Avec rm(list = ls()) ?

If the first line of your R script is

rm(list = ls())

I will come into your office and SET YOUR COMPUTER ON FIRE 🔥.

— Jenny Bryan

Que ne fait pas rm(list = ls()) ?

• Réinitialiser la session en cours

• Réinitialiser les options() → options(stringsAsFactors = FALSE)¹

• Réinitialiser le répertoire de travail getwd() → setwd()

• Réinitialiser les extensions attachées

Alors que fait rm(list = ls()) ?

help(rm)

Réinitialiser

• Dans une console

  • Via le raccourci Ctrl+D.

  • Via la fonction q() dans une console .

Réinitialiser

Désactiver les fichiers de démarrage

• --vanilla,
  pour désactiver le chargement de tous les fichiers de démarrage.

• --no-init-file,
  pour désactiver le chargement du fichier .Rprofile.

• --no-environ,
  pour désactiver le chargement du fichier .Renviron.

setwd(...) en première ligne …

If the first line of your R script is

setwd("C:\Users\jenny\path\that\only\I\have")

I will come into your office and SET YOUR COMPUTER ON FIRE 🔥.

— Jenny Bryan

L’extension here

here::here()
here::i_am("radvanced.qmd")
here::i_am("contents/content-01.qmd")

Utiliser un Mode “Projet” via un IDE

• Démarrer un projet A :

  1. Démarre R.

  2. Défini le répetoire de travail de R comme la racine du projet A.

• Passer d’un projet A à un project B :

  1. Redémarre R.

  2. Défini le répetoire de travail de R comme la racine du projet B.

Utiliser un Mode “Projet”

• “What They Forgot to Teach You About R”
  — Jenny Bryan & Jim Hester

• “Project-oriented Workflow”
  — Jenny Bryan

Lectures Utiles

• “Code Smells and Feels”
  — Jenny Bryan

• “Advanced R”
  — Hadley Wickham

• “Project-oriented Workflow”
  — Jenny Bryan

• “R for Data Science”
  — Garrett Grolemund & Hadley Wickham

• “What They Forgot to Teach You About R”
  — Jenny Bryan & Jim Hester

Affectation

x <- c(1, 2, 3)

“Crée un objet nommé ‘x’, contenant les valeurs 1, 2 et 3” ou plus précisément :

• Crée un objet de type vecteur c(1, 2, 3).

• Associe cet objet à un nom x.

Affectation

x <- c(1, 2, 3)
y <- x

lobstr::obj_addr(x)

[1] "0x55826bdd28a8"

lobstr::obj_addr(y)

[1] "0x55826bdd28a8"

y n’est pas une copie de x. x et y sont des références à l’objet de type vecteur c(1, 2, 3).

Noms Non-syntaxique

dispose d’un ensemble de règles pour les noms utilisables :

• Contient uniquement des lettres (ASCII, mais pas uniquement), des chiffres, . et _.

• Ne peut pas débuter par des chiffres ou _.

• Ne peut pas être un “nom réservé” (?Reserved).

Noms Non-syntaxique

_abc <- 1

Error: <text>:1:2: unexpected symbol
1: _abc
     ^

TRUE <- "false"

Error in TRUE <- "false": invalid (do_set) left-hand side to assignment

(`_abc` <- 1)

[1] 1

(`+` <- 1)

[1] 1

Copie sur Modification¹

x <- c(1, 2, 3)
y <- x

y[3] <- 4
x

[1] 1 2 3

y

[1] 1 2 4

La modification de y n’a pas modifié x.
crée une copie de l’objet référencé par x en modifiant la troisième valeur.
Ce nouvel objet est ensuite référencé par y.

Déréférencement et “Garbage Collection”

x <- 1:3
x <- 2:4

rm(x) # Déréférencement

gc() # Force "Garbage Collection"

          used (Mb) gc trigger (Mb) max used (Mb)
Ncells  583605 31.2    1243322 66.5  1243322 66.5
Vcells 1101790  8.5    8388608 64.0  1816085 13.9

Exercices

1. À quelle ligne, une copie de a est effectuée ?

   a <- c(1, 5, 3, 2)
   b <- a
   b[[1]] <- 10

Les Vecteurs

c() (“combine”) permet de constituer des vecteurs de longueurs supérieurs à 1.

lgl_var <- c(TRUE, FALSE)
int_var <- c(1L, 6L, 10L)
dbl_var <- c(1, 2.5, 4.5)
chr_var <- c("these are", "some strings")

Lorsque les éléments de c() sont dit atomiques, le résultat est alors de même nature.

c(c(1, 2), c(3, 4))

[1] 1 2 3 4

Les Vecteurs

Le type d’un vecteur peut-être déterminé via typeof().

typeof(lgl_var)

[1] "logical"

typeof(int_var)

[1] "integer"

typeof(dbl_var)

[1] "double"

typeof(chr_var)

[1] "character"

Les Vecteurs

Et sa longueur via length().

length(lgl_var)

[1] 2

length(int_var)

[1] 3

length(dbl_var)

[1] 3

length(chr_var)

[1] 2

Valeurs Manquantes

symbolise les valeurs manquantes à l’aide de NA (“not applicable”).
Un calcul impliquant NA résultera en un NA.

NA > 5

[1] NA

10 * NA

[1] NA

!NA

[1] NA

Valeurs Manquantes

À quelques exceptions.

NA ^ 0

[1] 1

NA | TRUE

[1] TRUE

NA & FALSE

[1] FALSE

Valeurs Manquantes

Détermination des valeurs manquantes d’un vecteur de façon “naïve”.

x <- c(NA, 5, NA, 10)
x == NA

[1] NA NA NA NA

La bonne approche pour éviter les erreurs.

is.na(x)

[1]  TRUE FALSE  TRUE FALSE

Valeurs Manquantes

NA est la forme “générique”, mais il existe un NA pour chacun des types :

• Booléen : NA.

• Numérique

  • Flottant (“double”) : NA_real_.

  • Entier (“integer”) : NA_integer_.

• Chaîne de caractères : NA_character_.

Test et Conversion de Type

Un vecteur ne dispose que d’un seul type, c’est-à-dire, tous les éléments doivent avoir le même type.

Lorsque les éléments d’un vecteur sont de plusieurs types, une conversion sera appliquée selon la règle de priorité :
character → double → integer → logical.

x <- c("a", 1)
typeof(x)

[1] "character"

str(x)

 chr [1:2] "a" "1"

Test et Conversion de Type

La plupart des fonctions mathématiques réalise cette conversion de type (p.ex., +, log, etc.).

x <- c(FALSE, FALSE, TRUE)
as.numeric(x)

[1] 0 0 1

# Nombre de "TRUE"
sum(x)

[1] 1

# Proportion de "TRUE"
mean(x)

[1] 0.3333333

Test et Conversion de Type

Il est possible de convertir explicitement un vecteur avec les fonctions as.*() : as.logical(), as.integer(), as.double() et as.character().

avertira via un avertissement d’un problème lors de la conversion.

as.integer(c("1", "1.5", "a"))

Warning: NAs introduced by coercion

[1]  1  1 NA

Exercices

1. Déterminer le type des vecteurs suivants.

   c(1, FALSE)
   c("a", 1)
   c(TRUE, 1L)

2. Déterminer le résultat des comparaisons suivantes.

   1 == "1"
   -1 < FALSE
   "one" < 2

   Pour quelle raison ces résultats ont été obtenu ?

3. Pourquoi le type par défaut de NA est booléen ?

Les Attributs

Les attributs sont des meta-données stockées sont la forme de paire nom/valeur.
Chaque attribut peut être récupéré et défini individuellement via attr(), récupéré en masse via attributes() ou encore défini en masse via structure().

a <- 1:3
attr(a, "x") <- "abcdef"
attr(a, "x")

[1] "abcdef"

attr(a, "y") <- 4:6
str(attributes(a))

List of 2
 $ x: chr "abcdef"
 $ y: int [1:3] 4 5 6

Les Attributs

a <- structure(
  1:3,
  x = "abcdef",
  y = 4:6
)
str(attributes(a))

List of 2
 $ x: chr "abcdef"
 $ y: int [1:3] 4 5 6

Les Attributs : Dimensions

Il est possible de modifier directement les dimensions d’un vecteur pour en modifier la “forme”.

x <- 1:6
dim(x) <- c(3, 2)
x

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

Les Attributs : Dimensions

Les Attributs : Dimensions

str() est le meilleur moyen d’identifier la “nature” d’un objet.

str(1:3)                   # 1d vector

 int [1:3] 1 2 3

str(matrix(1:3, ncol = 1)) # column vector

 int [1:3, 1] 1 2 3

str(matrix(1:3, nrow = 1)) # row vector

 int [1, 1:3] 1 2 3

str(array(1:3, 3))         # "array" vector

 int [1:3(1d)] 1 2 3

Les Vecteurs (Objets) S3

class est un autre attribut important dans , il est le fondement du système objet S3.

Un objet possédant l’attribut class devient un objet S3 qui réagira différemment d’un simple objet au regard d’une fonction dite “générique”.

Les principaux vecteurs S3 :

• factor, permettant de définir des niveaux pour un vecteur.
• Date, la date dans un format défini au jour près.
• POSIXct, la date dans un format défini à la seconde près.

Les Vecteurs (Objets) S3 : Les Facteurs

Un facteur est un vecteur ne pouvant contenir que des valeurs prédéfinies.
Ce type de vecteur est utilisé pour stocker des données catégorielles / discrètes en se basant sur un vecteur d’entier.

x <- factor(c("a", "b", "b", "a"))
x

[1] a b b a
Levels: a b

typeof(x)

[1] "integer"

Les Vecteurs (Objets) S3 : Les Facteurs

Un facteur est un vecteur ne pouvant contenir que des valeurs prédéfinies.
Ce type de vecteur est utilisé pour stocker des données catégorielles / discrètes en se basant sur un vecteur d’entier.

attributes(x)

$levels
[1] "a" "b"

$class
[1] "factor"

str(x)

 Factor w/ 2 levels "a","b": 1 2 2 1

Les Vecteurs (Objets) S3 : Les Facteurs

Les niveaux d’un facteur peuvent être connus, mais pas nécessairement observés dans les données.

sex_char <- c("m", "m", "m")
sex_factor <- factor(sex_char, levels = c("m", "f"))

Ainsi, il est possible de compter les occurrences de l’ensemble des niveaux.

table(sex_char)

sex_char
m 
3 

table(sex_factor)

sex_factor
m f 
3 0 

Les Vecteurs (Objets) S3 : Les Facteurs

Les facteurs peuvent également être ordonnées et se comportent comme des facteurs “classiques”.

ordered(c("b", "b", "a", "c"), levels = c("c", "b", "a"))

[1] b b a c
Levels: c < b < a

factor( c("b", "b", "a", "c"), levels = c("c", "b", "a"), ordered = TRUE)

[1] b b a c
Levels: c < b < a

Exercices

1. Quelle sorte d’objet renvoi table() ?
   Quel est son type ?
   Quels sont ses attributs ?

2. Qu’arrive-t-il à un facteur lorsque les niveaux sont modifiés ?

   f1 <- factor(letters)
   levels(f1) <- rev(levels(f1))

3. Que fait le code suivant ?
   De quelle façon f2 et f3 différent-ils de f1 ?

   f2 <- rev(factor(letters))
   f3 <- factor(letters, levels = rev(letters))

Les Listes

À la différence des vecteurs, les éléments d’une liste peuvent être de n’importe quel type, il n’est plus question de “cohérence de type”.

l1 <- list(
  1:3,
  "a",
  c(TRUE, FALSE, TRUE),
  c(2.3, 5.9)
)
typeof(l1)

[1] "list"

Les Listes

À la différence des vecteurs, les éléments d’une liste peuvent être de n’importe quel type, il n’est plus question de “cohérence de type”.

str(l1)

List of 4
 $ : int [1:3] 1 2 3
 $ : chr "a"
 $ : logi [1:3] TRUE FALSE TRUE
 $ : num [1:2] 2.3 5.9

Les Listes

Chaque élément d’une liste, n’est en réalité qu’une référence à l’objet.

lobstr::obj_size(mtcars)

7.21 kB

l2 <- list(mtcars, mtcars, mtcars, mtcars)
lobstr::obj_size(l2)

7.29 kB

Les Listes

La levée de la contrainte de “cohérence de type” fait des listes un type particulièrement flexible et de ce fait ne permet pas d’avoir une représentation générique efficace systématiquement, comme c’est le cas pour les vecteurs.

l3 <- list(list(list(1)))
str(l3)

List of 1
 $ :List of 1
  ..$ :List of 1
  .. ..$ : num 1

Les Listes

c() permet de combiner des éléments dans le cas des listes.

l4 <- list(list(1, 2), c(3, 4))
str(l4)

List of 2
 $ :List of 2
  ..$ : num 1
  ..$ : num 2
 $ : num [1:2] 3 4

l5 <- c(list(1, 2), c(3, 4))
str(l5)

List of 4
 $ : num 1
 $ : num 2
 $ : num 3
 $ : num 4

Test et Conversion de Type

Le typeof() d’une liste est list. is.list() permet de tester si l’objet est une liste quand as.list() permet la conversion en liste.

list(1:3)

[[1]]
[1] 1 2 3

as.list(1:3)

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

Matrices et Arrays

L’attribut dim permettait de passer d’un vecteur à une matrice ou à un array.
Dans le cas des listes, il permet de passer à des “matrice-liste” et “array-liste”.

l <- list(1:3, "a", TRUE, 1.0)
dim(l) <- c(2, 2)
l

     [,1]      [,2]
[1,] integer,3 TRUE
[2,] "a"       1   

l[[1, 1]]

[1] 1 2 3

Exercices

1. Lister les points de divergences entre un vecteur et une liste.

2. Pourquoi as.vector() ne fonctionne pas pour convertir une liste en vecteur ?
   Pourquoi l’usage de unlist() est nécessaire ?

data.frame

L’une des classes S3 importante dans est la classe data.frame (tibble dans le “tidyverse”), qui repose entièrement sur les listes.

Qu’est-ce qu’un data.frame ?

df1 <- data.frame(x = 1:3, y = letters[1:3])
typeof(df1)

[1] "list"

Un data.frame est une liste nommée, de vecteur de même dimension (longueur) avec des attributs names (noms des colonnes) et row.names.

data.frame

L’une des classes S3 importante dans est la classe data.frame (tibble dans le “tidyverse”), qui repose entièrement sur les listes.

Qu’est-ce qu’un data.frame ?

attributes(df1)

$names
[1] "x" "y"

$class
[1] "data.frame"

$row.names
[1] 1 2 3

Un data.frame est une liste nommée, de vecteur de même longueur avec des attributs names (noms des colonnes) et row.names.

data.frame

Un data.frame a donc une structure rectangulaire et dispose de noms pour les lignes et les colonnes.

• rownames() pour obtenir le noms des lignes.

• colnames() (ou names()) pour obtenir le noms des colonnes.

• nrow() pour obtenir le nombre de lignes.

• ncol() (ou length()) pour obtenir le nombre de colonnes.

data.frame

La création d’un data.frame se fait via data.frame().

df <- data.frame(
  x = 1:3,
  y = c("a", "b", "c")
)
str(df)

'data.frame':   3 obs. of  2 variables:
 $ x: int  1 2 3
 $ y: chr  "a" "b" "c"

data.frame

La création d’un data.frame se fait via data.frame().

df <- data.frame(
  x = 1:3,
  y = c("a", "b", "c"),
  stringsAsFactors = TRUE # Par défaut dans R < 4.0
)
str(df)

'data.frame':   3 obs. of  2 variables:
 $ x: int  1 2 3
 $ y: Factor w/ 3 levels "a","b","c": 1 2 3

data.frame

La création d’un data.frame se fait via data.frame().

df <- data.frame(
  x = 1:3,
  y = c("a", "b", "c"),
  stringsAsFactors = FALSE # Par défaut dans R > 4.0
)
str(df)

'data.frame':   3 obs. of  2 variables:
 $ x: int  1 2 3
 $ y: chr  "a" "b" "c"

data.frame

Par défaut, un data.frame requiert des noms de colonnes syntaxiquement correct.

names(data.frame(`1` = 1))

[1] "X1"

names(data.frame(`1` = 1, check.names = FALSE))

[1] "1"

data.frame

Un data.frame requiert que ces éléments soit de même longueur, quand cela n’est pas respecté et lorsque c’est possible, les valeurs des vecteurs les plus courts sont recyclés.

data.frame(x = 1:4, y = 1:2)

  x y
1 1 1
2 2 2
3 3 1
4 4 2

data.frame(x = 1:4, y = 1:3)

Error in data.frame(x = 1:4, y = 1:3): arguments imply differing number of rows: 4, 3

data.frame

Les data.frame ayant des noms de lignes, il est possible de les définir de plusieurs façons.

df3 <- data.frame(
  age = c(35, 27, 18),
  hair = c("blond", "brown", "black"),
  row.names = c("Bob", "Susan", "Sam")
)
df3

      age  hair
Bob    35 blond
Susan  27 brown
Sam    18 black

data.frame

Les data.frame ayant des noms de lignes, il est possible de les définir de plusieurs façons.

df3 <- data.frame(
  age = c(35, 27, 18),
  hair = c("blond", "brown", "black")
)
rownames(df3) <- c("Bob", "Susan", "Sam")
df3

      age  hair
Bob    35 blond
Susan  27 brown
Sam    18 black

data.frame

L’usage des noms de lignes n’est pas recommandé.

• Le nom des lignes est une donnée, pourquoi la stocker différemment ?

• Le nom des lignes doit obligatoirement être une chaîne de caractères.

• Chaque nom de ligne doit-être unique.
  s’assurera que ce soit le cas !

  df3[c(1, 1, 1), ]

        age  hair
  Bob    35 blond
  Bob.1  35 blond
  Bob.2  35 blond

Test et Conversion de Type

is.data.frame() permet de tester si l’objet est un data.frame() quand as.data.frame() permet la conversion.

is.data.frame(df1)

[1] TRUE

Exercises

1. Est-il possible d’avoir un data.frame avec zéro lignes ?
   Et zéro colonnes ?

2. Que se passe-t-il lorsque des noms lignes avec duplicatas sont définis via rownames() ?

3. Que donne t(df) ou t(t(df)) ?
   Avec, df un objet de classe data.frame.

4. Que fait as.matrix() sur un data.frame dont les colonnes sont de type différents ?

NULL

NULL un objet particulier.

typeof(NULL)

[1] "NULL"

length(NULL)

[1] 0

x <- NULL
attr(x, "y") <- 1

Error in attr(x, "y") <- 1: attempt to set an attribute on NULL

NULL

Il est possible de tester le caractère NULL d’un objet.

is.null(NULL)

[1] TRUE

NULL sert à définir :

• un vecteur vide (p.ex., c()).

• un vecteur absent (p.ex., argument non défini d’une fonction).

Sélection Dans un Vecteur

• Entier positif.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[c(3, 1)]

  [1] 3.3 2.1

  x[c(1, 1)]

  [1] 2.1 2.1

  x[c(2.1, 2.9)] # Troncature

  [1] 4.2 4.2

Sélection Dans un Vecteur

• Entier négatif.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[-c(3, 1)]

  [1] 4.2 5.4

  x[c(-1, 2)] # Pas de mélange

  Error in x[c(-1, 2)]: only 0's may be mixed with negative subscripts

Sélection Dans un Vecteur

• Booléen.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[c(TRUE, TRUE, FALSE, FALSE)]

  [1] 2.1 4.2

  x[x > 3]

  [1] 4.2 3.3 5.4

Sélection Dans un Vecteur

• Recyclage des valeurs.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[c(TRUE, FALSE)] # Recyclage

  [1] 2.1 3.3

  x[c(TRUE, FALSE, TRUE, FALSE)]

  [1] 2.1 3.3

Sélection Dans un Vecteur

• Valeur manquante.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[c(TRUE, TRUE, NA, FALSE)]

  [1] 2.1 4.2  NA

Sélection Dans un Vecteur

• “Rien”.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[]

  [1] 2.1 4.2 3.3 5.4

Sélection Dans un Vecteur

• Zéro.

  x <- c(2.1, 4.2, 3.3, 5.4)

  x[0]

  numeric(0)

Sélection Dans un Vecteur

• Avec des “noms”.

  x <- c(2.1, 4.2, 3.3, 5.4)
  names(x) <- letters[1:4]

  x[c("d", "c", "a")]

    d   c   a 
  5.4 3.3 2.1 

  x[c("a", "a", "a")]

    a   a   a 
  2.1 2.1 2.1 

Sélection Dans un Vecteur

• Avec des “noms”, une correspondance parfaite est requise.

  z <- c(abc = 1, def = 2)

  z[c("a", "d")] # Correspondance parfaite

  <NA> <NA> 
    NA   NA 

  z[c("abc", "def")]

  abc def 
    1   2 

Sélection Dans une Liste

La sélection s’opère de la même façon que sur un vecteur.

• [, renvoi une liste.
• [[ et $, renvoient un élément d’une liste.

Sélection Dans une Liste

La sélection s’opère de la même façon que sur un vecteur.

• [, renvoi une liste.

  x <- list(2.1, 4.2, 3.3, 5.4)
  x[c(1, 3)]

  [[1]]
  [1] 2.1
  
  [[2]]
  [1] 3.3

  x[[2]]

  [1] 4.2

Sélection Dans une Liste

La sélection s’opère de la même façon que sur un vecteur.

• [[ et $, renvoient un élément d’une liste.

  x <- list(2.1, 4.2, 3.3, 5.4)
  names(x) <- letters[1:4]
  x$a

  [1] 2.1

  x[["b"]]

  [1] 4.2

Sélection Dans une Matrice ou Array

La sélection peut s’effectuer avec un vecteur, plusieurs vecteurs ou une matrice.

a <- matrix(1:9, nrow = 3)
colnames(a) <- c("A", "B", "C")
a[1:2, ]

     A B C
[1,] 1 4 7
[2,] 2 5 8

a[c(TRUE, FALSE, TRUE), c("B", "A")]

     B A
[1,] 4 1
[2,] 6 3

Sélection Dans une Matrice ou Array

Comme les matrices ou arrays ne sont que des vecteurs avec un attribut dim, la sélection peut se faire directement avec un seul vecteur de position.

vals <- outer(1:5, 1:5, FUN = "paste", sep = ",")
vals

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

vals[c(4, 15)]

[1] "4,1" "5,3"

Sélection Dans une Matrice ou Array

Il est également possible d’effectuer la sélection à partir d’une matrice donnant la position des dans chacune des dimensions de la matrice ou array que l’on souhaite manipuler.

vals <- outer(1:5, 1:5, FUN = "paste", sep = ",")
select <- matrix(ncol = 2, byrow = TRUE, c(
  1, 1,
  3, 1,
  2, 4
))
vals[select]

[1] "1,1" "3,1" "2,4"

Sélection Dans un data.frame

Les data.frame se comportent comme des listes et comme des matrices.

df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3])
df[df$x == 2, ]

  x y z
2 2 2 b

df[c(1, 3), ]

  x y z
1 1 3 a
3 3 1 c

Sélection Dans un data.frame

Deux approches pour sélectionner les colonnes d’un data.frame.

df <- data.frame(x = 1:3, y = 3:1, z = letters[1:3])
df[c("x", "z")] # approche liste

  x z
1 1 a
2 2 b
3 3 c

df[, c("x", "z")] # approche matrice

  x z
1 1 a
2 2 b
3 3 c

Sélection Dans un data.frame

Attention, ces deux approches ne sont pas tout à fait équivalentes.

str(df["x"])

'data.frame':   3 obs. of  1 variable:
 $ x: int  1 2 3

str(df[, "x"])

 int [1:3] 1 2 3

str(df[, "x", drop = FALSE])

'data.frame':   3 obs. of  1 variable:
 $ x: int  1 2 3

Les Opérateurs [[ et $

[[ renvoi toujours un élément plus petit.

x <- list(1:3, "a", 4:6)
x[1]

[[1]]
[1] 1 2 3

x[[1]]

[1] 1 2 3

Les Opérateurs [[ et $

$ fonctionne d’une façon proche de celle de [[.

mitcars$cyl
mitcars[["cyl"]]

Les Opérateurs [[ et $

Le $ n’est pas utilisable lorsque le nom de la colonne ou de l’élément est stockée dans une variable.

var <- "cyl"
mtcars$var

NULL

mtcars[[var]]

 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4 4 8 8 8 8 4 4 4 8 6 8 4

Les Opérateurs [[ et $

L’opérateur $ permet également une correspondance partiel des noms, contrairement à [[ (ou [).

x <- list(abc = 1)
x$a

[1] 1

x[["a"]]

NULL

Les Opérateurs slot() et @

Les opérateurs slot() et @ sont des opérateurs spécifiques des objets de classe S4, ou :

• slot() correspond à [[.

• @ correspond à $.

Exercices

1. Extraire la troisième valeur de la variable cyl du jeu de données mtcars.

2. À partir de la régression linéaire mod <- lm(mpg ~ wt, data = mtcars), extraire le nombre de degré de liberté.
   Puis extraire, le R carré du modèle (summary(mod)).

Sélection et Affectation

Les opérateurs [, [[ et $ permettent également les affectations ou modifications.

x <- 1:5
x[c(1, 2)] <- c(101, 102)
x

[1] 101 102   3   4   5

Attention au recyclage des valeurs !

Sélection et Affectation

Approche identique pour les listes.

x <- list(a = 1, b = 2)
x[["b"]] <- NULL
x

$a
[1] 1

y <- list(a = 1, b = 2)
y["b"] <- list(NULL)
y

$a
[1] 1

$b
NULL

str(y)

List of 2
 $ a: num 1
 $ b: NULL

Sélection et Affectation

Le cas de la sélection par “rien”, c’est-à-dire, df[], permet dans le cas d’une affectation de préservé la structure d’origine.

mtcars2 <- mtcars
mtcars2[] <- lapply(mtcars2, as.integer)
is.data.frame(mtcars2)

[1] TRUE

mtcars2 <- lapply(mtcars2, as.integer)
is.data.frame(mtcars2)

[1] FALSE

Les Fonctions

Une fonction se décompose en trois éléments :

• Les arguments (arguments).

• Le corps (body).

• L’environnement (environment).

Les Fonctions

f <- function(x, y) {
  # Commentaire
  return(x + y)
}

f <- function(x, y) {
  # Commentaire
  x + y
}

Les Fonctions

formals(f)

$x


$y

body(f)

{
    x + y
}

environment(f)

<environment: R_GlobalEnv>

Les Fonctions

Les fonctions sont des objets au même titre que les vecteurs.

attributes(f)

$srcref
function(x, y) {
  # Commentaire
  x + y
}

Les Fonctions

• Fonction “classique”, affectée d’un nom.

  f <- function(x, y) {
    # Commentaire
    x + y
  }
  f(1, 2)

  [1] 3

• Fonction anonyme.

  (function(x, y) x + y)(1, 2)

  [1] 3

Les Fonctions Composées

square <- function(x) x^2
deviation <- function(x) x - mean(x)
x <- runif(100)

Exercices

1. match.fun() permet de trouver une fonction avec son nom.
   À partir d’une fonction, est-il possible de trouver son nom ?

2. Quelles fonctions permettraient d’identifier si un objet est une fonction et s’il s’agit d’une primitive ?
   Par exemple, +, sum, lm et t.test.

3. Quelles sont les composantes d’une fonction ?
   str, attributes, typeof, class, etc.

4. Est-il possible de donner des attributs (c.-à-d., avec attr) à une fonction ?

if … else …`

La structure de contrôle “si sinon” s’écrit sous les formessuivantes :

• if (condition) si_vraie,
  lorsque l’on ne souhaite rien faire si la condition est fausse.

• if (condition) si_vraie else si_fausse,
  lorsque l’on souhaite définir une action que la condition soit vraie ou fausse.

if ... else ...

Les structures if ... else ... peuvent être imbriquées :

if (x > 75) {
  "]75, Inf["
} else if (x > 50) {
  "]50, 75]"
} else if (x > 25) {
  "]25, 50]"
} else {
  "]-Inf, 25]"
}

if ... else ...

if ... else ... renvoie un résultat comme n’importe quelle fonction.
Ce résultat peut donc être affecté à une variable via l’opérateur <- (ou =)¹.

resultat1 <- if (TRUE) "vrai" else "faux"
resultat1

[1] "vrai"

(resultat2 <- if (FALSE) "vrai" else "faux")

[1] "faux"

resultat2

[1] "faux"

if ... else ...

Avec ou sans else, un résultat est renvoyé :

if ... else ...

Une condition doit être un booléen (c’est-à-dire, TRUE ou FALSE) de longueur 1.

if ("FALSE") "vrai"
if (NA) "vrai"

Error in if (NA) "vrai": missing value where TRUE/FALSE needed

if (logical()) "vrai"

Error in if (logical()) "vrai": argument is of length zero

if (1:5) "vrai"

Error in if (1:5) "vrai": the condition has length > 1

if ... else ...

autorise cependant l’usage d’un vecteur de booléen d’une longueur supérieure à 1¹.

if (c(FALSE, TRUE)) "vrai"

Error in if (c(FALSE, TRUE)) "vrai": the condition has length > 1

if (c(TRUE, FALSE)) "vrai"

Error in if (c(TRUE, FALSE)) "vrai": the condition has length > 1

if ... else ...

est un langage vectorielle, ainsi il existe ifelse.

ifelse(c(FALSE, TRUE), "vrai", "faux")

[1] "faux" "vrai"

ifelse(c(TRUE, FALSE), "vrai", "faux")

[1] "vrai" "faux"

ifelse(1:10 %% 2 == 0, "pair", "impair")

 [1] "impair" "pair"   "impair" "pair"   "impair" "pair"   "impair" "pair"  
 [9] "impair" "pair"  

ifelse(1:10 %% 2 == 0, "pair", NA_character_)

 [1] NA     "pair" NA     "pair" NA     "pair" NA     "pair" NA     "pair"

if ... else ...

propage les NA dans la sortie du ifelse.

x <- c(NA, 1:10, NA)
ifelse(x %% 2 == 0, "pair", "impair")

 [1] NA       "impair" "pair"   "impair" "pair"   "impair" "pair"   "impair"
 [9] "pair"   "impair" "pair"   NA      

Exercices

1. Quel type de vecteurs produisent les instructions suivantes ?
   Quelle est la règle (?ifelse) ?

   ifelse(TRUE, 1, "no")
   ifelse(FALSE, 1, "no")
   ifelse(NA, 1, "no")

2. Pour quelle raison les instructions suivantes fonctionnent ?

   x <- 1:10
   if (length(x)) "Non vide" else "Vide"
   x <- numeric()
   if (length(x)) "Non vide" else "Vide"

for (...) ...

• Les itérations à partir d’un vecteur de valeurs peut se faire via une boucle for.

  for (element in vecteur) action

• L’action action est réalisée une fois par élément et donc autant de fois que la longeur de vecteur.

  for (i in 1:3) {
    print(i)
  }

• La valeur de l’indice i est stockée dans l’environnement courant.

  i <- "mon indice"
  for (i in 1:3) {}
  i

for (...) ...

Pour sortir prématurément d’une boucle for :

• next, passe directement à l’élément suivant de la boucle et continu jusqu’à la fin.

• break, provoque une sortie immédiate de la boucle.

for (i in 1:10) {
  if (i < 3) next
  if (i > 5) break
  print(i)
}

[1] 3
[1] 4
[1] 5

Exercices

1. Pourquoi le code suivant fonctionne sans erreurs ou avertissement ?

   x <- numeric()
   out <- vector("list", length(x))
   for (i in 1:length(x)) {
     out[i] <- x[i] ^ 2
   }
   out

2. Que se passe-t-il à chaque étape de la boucle for ?

   xs <- c(1, 2, 3)
   for (x in xs) {
     xs <- c(xs, x * 2)
   }
   xs