6  Listes

Les listes constituent l’une des structures les plus flexibles du langage R. Contrairement aux vecteurs ou matrices, elles peuvent contenir des éléments de toute nature : vecteur numériques, chaînes de caractères, matrices, fonctions, voire d’autres listes.

Créer une liste avec list()

Pour créer une liste, il suffit d’utiliser la fonction list() et d’écrire entre les parenthèses les différents éléments.

# 1. Définir les éléments de la liste
x <- c(45, 12, 56, 14, 16)
y <- c("Car", "Bike")
z <- matrix(1:12, ncol = 4)

# 2. Créer 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

Comme pour les vecteurs, il est possible d’attribuer des noms aux éléments d’une liste. Cette pratique améliore la lisibilité de la structure et facilite l’accès aux données.

# Méthode 1 : noms lors de la création
lista <- list(vec_x = x, vec_y = y, mat_z = z)

# Méthode 2 : noms après création
names(lista) <- c("vec_x", "vec_y", "mat_z")

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

La fonction str() permet d’afficher une structure compacte et lisible de l’objet :

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ès aux élements d’une liste

On peut accéder à un élément donné d’une liste de plusieurs façons :

lista[[3]]         # Par position/numéro (3e élément)
lista[["mat_z"]]   # Par nom, avec doubles crochets (si la liste a des noms)
lista$mat_z        # Par nom, avec l’opérateur $ (si la liste a des noms)
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

Une fois un élément extrait, on peut accéder à ses composants internes. Par exemple :

lista[[1]][2]
[1] 12

Cette expression s’interprète en deux étapes :

  1. lista[[1]] extrait le premier élément de la liste, ici un vecteur numérique.
  2. [2] sélectionne le deuxième élément de ce vecteur.

Ainsi, lista[[1]][2] renvoie la deuxième valeur du vecteur stocké en première position dans la liste.

On peut également extraire une sous-liste, on utilise les crochets simples []. Cela permet de conserver la structure de liste, contrairement aux doubles crochets [[ ]] qui extraient le contenu. Exemple :

lista[c(1, 3)]               # Sous-liste par position (éléments 1 et 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)]              # Sous-liste excluant les éléments 1 et 3
$vec_y
[1] "Car"  "Bike"
lista[c("mat_z", "vec_x")]   # Sous-liste par nom (si la liste est nommée)
$mat_z
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

$vec_x
[1] 45 12 56 14 16

Modifier une liste

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

lista[1] <- "A"              # Remplace le premier élément par 0
lista[[3]][1, 1] <- 11       # Modifie la cellule [1,1] de la matrice (3ᵉ élément)
lista$vec_w <- 1:10          # Ajoute un nouvel élément nommé 'vec_w'
lista$vec_y <- NULL          # Supprime l’élément nommé 'vec_y' en le remplaçant par NULL

lista
$vec_x
[1] "A"

$mat_z
     [,1] [,2] [,3] [,4]
[1,]   11    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

Il est aussi possible de créer une liste vide et de l’alimenter progressivement :

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] "A"

$mat_z
     [,1] [,2] [,3] [,4]
[1,]   11    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

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

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

$listA
$listA$vec_x
[1] "A"

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

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


$listB
$listB[[1]]
[1]  TRUE FALSE FALSE

$listB[[2]]
NULL

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

$listB$test
[1] TRUE

L’accès aux éléments imbriqués se fait comme suit :

# Accède à l’élément nommé 'listA' de 'listAB'
listAB$listA
# Accède à l’élément 'mat_z' de la sous-liste 'listA'
listAB$listA$mat_z
# Accède au premier élément de la sous-liste située en troisième position de 'listAB'
listAB[[3]][[1]]
# Accède à l’élément nommé 'test' dans la sous-liste située en troisième position de 'listAB'
listAB[[3]]$test
Output
$vec_x
[1] "A"

$mat_z
     [,1] [,2] [,3] [,4]
[1,]   11    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

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