6 Les listes

La liste sont les structures les moins rigides et les plus polyvalentes du langage R. Il s’agit d’un objet spécial dont les éléments peuvent être de toute nature (y compris d’autres listes). Pour créer une liste, il suffit d’utiliser la fonction list() et d’écrire entre les parenthèses les différents éléments.

# Les objets à mettre dans une liste
x <- c(45, 12, 56, 14, 16)
y <- c("Car", "Bike")
z <- matrix(1:12, ncol = 4)
# Création de la liste
lista <- list(x, y, z)
lista
[[1]]
[1] 45 12 56 14 16

[[2]]
[1] "Car"  "Bike"

[[3]]
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

Nous pouvons nommer les éléments d’une liste, de la même façon que l’on nomme les éléments d’un vecteur, ce qui permet une meilleure lecture et un accès aux données parfois plus pratique.

lista <- list(vec_x = x, vec_y = y, mat_z = z)  # méthode 1
names(lista) <- c("vec_x", "vec_y", "mat_z")    # méthode 2
lista
$vec_x
[1] 45 12 56 14 16

$vec_y
[1] "Car"  "Bike"

$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

Voici un aperçu de la structure de notre liste.

str(lista)
List of 3
 $ vec_x: num [1:5] 45 12 56 14 16
 $ vec_y: chr [1:2] "Car" "Bike"
 $ mat_z: int [1:3, 1:4] 1 2 3 4 5 6 7 8 9 10 ...

Accéder aux éléments d’une liste

Nous pouvons accéder à un élément d’une liste de plusieurs façons différentes.

# par numéro (position), en utilisant les doubles crochets
lista[[3]]
# par nom, en utilisant les doubles crochets
lista[["mat_z"]]
# par nom, en utilisant l'opérateur $ (Méthode la plus fréquente)
lista$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

On peut aussi construire une sous-liste à partir d’une liste, on utilise pour cela les crochets simples.

lista[c(1, 3)]
$vec_x
[1] 45 12 56 14 16

$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
lista[-c(1, 3)]
$vec_y
[1] "Car"  "Bike"

Modifier une liste

Comme pour les vecteurs, on peut modifier les éléments d’une liste existante ou en ajouter/supprimer des éléments.

lista[[1]] <- 0      # modifier 1e élément
lista$vec_w <- 1:10  # ajouter un nouveau élément à la liste
lista$vec_y <- NULL  # supprimer vec_y de la liste
lista
$vec_x
[1] 0

$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

$vec_w
 [1]  1  2  3  4  5  6  7  8  9 10

On peut aussi créer une liste vide et la remplir au fur et à mesure.

listb <- list()
listb[[1]] <- c(TRUE, FALSE, FALSE)
listb[[3]] <- 1:10
listb$test <- TRUE
listb
[[1]]
[1]  TRUE FALSE FALSE

[[2]]
NULL

[[3]]
 [1]  1  2  3  4  5  6  7  8  9 10

$test
[1] TRUE

On peut concaténer deux ou plusieurs listes en utilisant la fonction c(). De cette façon, les éléments des différentes listes s’enchaîneront les unes après les autres pour ne construire qu’une seule grande liste.

listab <- c(lista, listb)
listab
$vec_x
[1] 0

$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

$vec_w
 [1]  1  2  3  4  5  6  7  8  9 10

[[4]]
[1]  TRUE FALSE FALSE

[[5]]
NULL

[[6]]
 [1]  1  2  3  4  5  6  7  8  9 10

$test
[1] TRUE
str(listab)
List of 7
 $ vec_x: num 0
 $ mat_z: int [1:3, 1:4] 1 2 3 4 5 6 7 8 9 10 ...
 $ vec_w: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $      : logi [1:3] TRUE FALSE FALSE
 $      : NULL
 $      : int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ test : logi TRUE

Et pour finir, sachez qu’une liste peut aussi contenir d’autres listes.

listAB <- list(vet = 1:5, list1 = lista, list2 = listb)
listAB
$vet
[1] 1 2 3 4 5

$list1
$list1$vec_x
[1] 0

$list1$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

$list1$vec_w
 [1]  1  2  3  4  5  6  7  8  9 10


$list2
$list2[[1]]
[1]  TRUE FALSE FALSE

$list2[[2]]
NULL

$list2[[3]]
 [1]  1  2  3  4  5  6  7  8  9 10

$list2$test
[1] TRUE
str(listAB)
List of 3
 $ vet  : int [1:5] 1 2 3 4 5
 $ list1:List of 3
  ..$ vec_x: num 0
  ..$ mat_z: int [1:3, 1:4] 1 2 3 4 5 6 7 8 9 10 ...
  ..$ vec_w: int [1:10] 1 2 3 4 5 6 7 8 9 10
 $ list2:List of 4
  ..$     : logi [1:3] TRUE FALSE FALSE
  ..$     : NULL
  ..$     : int [1:10] 1 2 3 4 5 6 7 8 9 10
  ..$ test: logi TRUE

L’accès aux différents éléments d’une telle liste se fait de la même manière, comme indiqué ci-dessus. Voici quelques exemples.

listAB$list1
$vec_x
[1] 0

$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

$vec_w
 [1]  1  2  3  4  5  6  7  8  9 10
listAB$list1$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12
listAB[[3]][[1]]
[1]  TRUE FALSE FALSE
listAB[[3]]$test
[1] TRUE
require(tibble)
Loading required package: tibble