3 Matrices et listes

Ce chapitre s’appuie sur les sections 2.2.1.4 Matrices et 2.2.1.5 Listes du chapitre 2 des notes de cours, ainsi que sur la Section 2.4 Manipulation des données.

3.1 Matrice

En R, les matrices sont des vecteurs auxquels un attridut dim de dimension est ajouté (cet attribut est de longueur 2). La fonction matrix() permet de créer une matrice. Son premier argument, data reçoit un vecteur de valeurs. Les arguments ncol et nrow reçoivent quant à eux le nombre de colonnes et de lignes, respectivement. Il est possible de ne préciser qu’un seul de ces deux derniers arguments (en fonction de la longueur du vecteur donné à l’argument data, R devine).

Créons la matrice suivante en R:

\[A = \begin{bmatrix}1 & 4 & 7 & 10\\2 & 5 & 8 & 11\\ 3 & 6 & 9 & 12\end{bmatrix}\]

A <- matrix(data = c(1,2,3,4,5,6, 7, 8, 9, 10, 11, 12), ncol = 4)
A
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

Notes

  • Le remplissage de la matrice s’est effectué colonne par colonne, de sorte à avoir 4 colonnes dans le résultat final (ncol=4{.R}).
  • Les données fourniées à l’argument data doivent être de même type (puisqu’elles sont contenues dans un vecteur).
  • Nous pouvons ne pas écrire data= et simplement écrire matrix(c(1,2,3,4,5,6,7,8,9,10,11,12), ncol = 4).
  • Au lieu d’écrire c(1,2,3,4,5,6,7,8,9,10,11,12), il est possible de générer la même séquence de nombres à l’aide d’une syntaxe plus courte : seq(1,12) ou encore plus court : 1:12.

Pour remplir la matrice en procédant ligne par ligne plutôt que colonne par colonne, on peut ajouter byrow = TRUE en argument à la fonction matrix()

matrix(1:12, ncol = 4, byrow = TRUE)
##      [,1] [,2] [,3] [,4]
## [1,]    1    2    3    4
## [2,]    5    6    7    8
## [3,]    9   10   11   12

3.1.1 Accès aux éléments d’une matrice

3.1.1.1 Indexation par position

Avec les vecteurs, nous avons extrait des sous-ensembles à l’aide de la fonction crochet, en utilisant l’indexation. Les vecteurs étant des objets en dimension 1, nous n’avons donné à la fonction crochet qu’un seul argument : x[c(2,3)] permet d’extraire les éléments aux positions 2 et 3 de x. Les matrices étant des objets à deux dimensions, il convient de fournir deux arguments à la fonction crochet, en les séparant par une virgule : x[i,j]. Le premier argument, i correspond aux indices de la première dimension (les lignes) et j aux indices de la deuxième dimension (les colonnes).

Revenons à notre matrice A. Extrayons les observations des lignes 1 et 3 aux colonnes 2 et 4 :

A[c(1,3), c(2,4)]
##      [,1] [,2]
## [1,]    4   10
## [2,]    6   12

En ommettant l’argument i ou l’argument j, l’ensemble des lignes ou des colonnes respectivement est retourné.

Les éléments de l’ensemble des lignes aux colonnes 2 et 4 :

A[, c(2,4)]
##      [,1] [,2]
## [1,]    4   10
## [2,]    5   11
## [3,]    6   12

Les éléments des lignes 1 et 3 pour l’ensemble des colonnes :

A[c(1,3), ]
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    3    6    9   12

Pour exclure des éléments, comme pour les vecteurs, on utilise le symbole moins (-). Par exemple, pour extraire les éléments pour toutes les lignes, pour toutes les colonnes sauf la 2e et la 4e :

A[, -c(2,4)]
##      [,1] [,2]
## [1,]    1    7
## [2,]    2    8
## [3,]    3    9

Note

Rappelez-vous que les matrices sont stockés sous forme de vecteurs. Il est donc possible d’utiliser la fonction crochet en lui fournissant uniquement l’argument i. L’instruction suivante retourne, sous la forme d’un vecteur, les éléments aux positions 1, 4, et 3 :

A[c(1,4,3)]
## [1] 1 4 3

Exercice

  1. Créez la matrice suivante : \[B = \begin{bmatrix}-2 & 2 & -3 \\ -1 & 1 & 3\\4 & 0 & -1\end{bmatrix}.\]
  2. Extrayez la 2e colonne de la matrice B.
  3. Extrayez la sous-matrice dans le coin inférieur de B : \[C=\begin{bmatrix}1 & 3 \\ 0 & -1\end{bmatrix}.\]
  4. Extrayez toutes les colonnes de B sauf la 2e.
  5. Extrayez le terme en dernière ligne et en dernière colonne de B.

3.1.1.2 Indexation par condition

Comme pour les vecteur, nous pouvons utiliser une matrice de logique indiquant si les éléments doivent être retournés (TRUE) ou non(FALSE).

masque <- matrix(c(TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, 
                   TRUE, TRUE, FALSE, FALSE, FALSE, FALSE), ncol = 4)
masque
##       [,1]  [,2]  [,3]  [,4]
## [1,]  TRUE FALSE  TRUE FALSE
## [2,] FALSE  TRUE  TRUE FALSE
## [3,] FALSE FALSE FALSE FALSE

En appliquant ce masque de valeurs logiques à la matrice A, on récpuère dans un vecteur les valeurs pour lesquelles la valeur dans le masque à la même position vaut TRUE :

A[masque]
## [1] 1 5 7 8

Evidemment, écrire de tels masques à la main n’est pas très utile. En revanche, ils peuvent être obtenus suite à l’évaluation d’une condition logique. Par exemple, si on souhaite obtenir les éléments de la matrice A dont la valeur est inférieure à 5, on peut créer le masque suivant :

A<5
##      [,1]  [,2]  [,3]  [,4]
## [1,] TRUE  TRUE FALSE FALSE
## [2,] TRUE FALSE FALSE FALSE
## [3,] TRUE FALSE FALSE FALSE

Et ensuite appliquer ce masque avec la fonction crochet :

A[A<5]
## [1] 1 2 3 4

Exercice

  1. Récupérez les valeurs de la matrice A qui sont inférieures à 3 ou supérieures à 7.
  2. Récupérez les valeurs paires de la matrice A (utilisez le modulo).

3.1.2 Remplacement et ajout de valeurs

Comme pour les vecteurs, le remplacement de valeurs peut s’effectuer avec la flèche d’affectation <-. On écrit à gauche de cette flèche l’extraction réalisée par indexation et à droite les valeurs de remplacement.

Reprenons notre matrice A :

\[A = \begin{bmatrix}1 & 4 & 7 & 10\\2 & 5 & 8 & 11\\ 3 & 6 & 9 & 12\end{bmatrix}\]

A <- matrix(1:12, ncol = 4)
A
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12

Remplaçons les valeurs 10 et 11 par -10 et -11

A[c(1,2),4] <- c(-10, -11)
A
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7  -10
## [2,]    2    5    8  -11
## [3,]    3    6    9   12

Cela fonctionne aussi avec un indexation par condition. Créons un masque indiquant si les valeurs sont négatives :

A<0
##       [,1]  [,2]  [,3]  [,4]
## [1,] FALSE FALSE FALSE  TRUE
## [2,] FALSE FALSE FALSE  TRUE
## [3,] FALSE FALSE FALSE FALSE

Puis affectons la valeur NA à la place des valeurs négatives de la matrice A :

A[A<0] <- NA
A
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   NA
## [2,]    2    5    8   NA
## [3,]    3    6    9   12

Exercice

  1. Créez la matrice suivante : \[X = \begin{bmatrix}-2 & 2 & -3 \\ -1 & 1 & 3\\4 & 0 & -1\end{bmatrix}.\]
  2. Remplacez les valeurs positives de X par 1000.
  3. Remplacez les éléments aux positions (1,1) et (2,3) par NA.

3.1.3 Calculs matriciels

En économie, et particulièrement en économétrie, nous manipulons beaucoup de matrices. Il est important de savoir effectuer avec R les différents calculs matriciels les plus courants dans notre discipline.

Considérons quelques matrices :

\[A = \begin{bmatrix}1 & 2 & 0\\ 4 & 3 & -1\end{bmatrix}\]

\[B = \begin{bmatrix}5 & 1\\ 2 & 3\\ 3 & 4\end{bmatrix}\]

\[C = \begin{bmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}\]

\[D = \begin{bmatrix}-2 & 2 & -3 \\ -1 & 1 & 3\\4 & 0 & -1\end{bmatrix}\]

A <- matrix(c(1,4,2,3,0,-1), nrow = 2)
B <- matrix(c(5,2,3, 1,3,4), ncol = 2)
C <- matrix(c(1,0,0,0,1,0,0,0,1), ncol = 3)
D <- matrix(c(-2,-1,4,2,1,0,-3,3,-1), ncol = 3)

Considérons par ailleurs le scalaire \(a = 3\).

a <- 3

3.1.3.1 Addition, soustraction

Pour additionner ou soustraire un scalaire ou une matrice à une matrice, on utilise simplement les opérateurs d’addition (+) ou de soustraction (-), respectivement :

A+a
##      [,1] [,2] [,3]
## [1,]    4    5    3
## [2,]    7    6    2
A-a
##      [,1] [,2] [,3]
## [1,]   -2   -1   -3
## [2,]    1    0   -4
C+D
##      [,1] [,2] [,3]
## [1,]   -1    2   -3
## [2,]   -1    2    3
## [3,]    4    0    0
C-D
##      [,1] [,2] [,3]
## [1,]    3   -2    3
## [2,]    1    0   -3
## [3,]   -4    0    2

Lorsqu’on essaie d’additionner ou de soustraire deux matrices non compatibles, R retourne une erreur :

A+C
## Error in A + C: non-conformable arrays

3.1.3.2 Multiplication

La multiplication par un scalaire s’effectue avec l’étoile *:

A*a
##      [,1] [,2] [,3]
## [1,]    3    6    0
## [2,]   12    9   -3

Pour multiplier deux matrices (compatibles) entre-elles, on utilise l’opérateur de produit matriciel %*% :

A %*% B
##      [,1] [,2]
## [1,]    9    7
## [2,]   23    9

En cas d’incompatibilité, R nous prévient :

C %*% A
## Error in C %*% A: non-conformable arguments

Attention, si on utilise l’étoile au lieu de l’opérateur de produit matriciel, si les deux matrices ont la même dimension, alors R effectue une multiplication terme à terme :

C * D
##      [,1] [,2] [,3]
## [1,]   -2    0    0
## [2,]    0    1    0
## [3,]    0    0   -1

3.1.3.3 Transposée

La transposée d’une matrice s’obtient en R avec la fonction t():

t(A)
##      [,1] [,2]
## [1,]    1    4
## [2,]    2    3
## [3,]    0   -1

3.1.3.4 Inversion

L’inversion d’une matrice est calculée à l’aide de la fonction solve():

solve(D)
##             [,1]       [,2] [,3]
## [1,] -0.02777778 0.05555556 0.25
## [2,]  0.30555556 0.38888889 0.25
## [3,] -0.11111111 0.22222222 0.00

En économétrie, l’estimateur des moindres carrés ordinaires est donné par \((X^{\top}X)^{-1}(X^{\top}y)\), où \(X\) est la matrice des variables explicatives et \(y\) le vecteur de la variable endogène.

solve(t(X) %*% X) %*% (t(X) %*% y)

Qui peut aussi se calculer de manière équivalente (nous le ferons dans un prochain exercice) :

crossprod(X,X) %*% crossprod(X,y)

3.1.3.5 Déterminant

Le déterminant s’obtient avec la fonction det() :

det(D)
## [1] 36

3.1.3.6 Diagonale

La diagonale d’une matrice peut être obtenue avec la fonction det(){.R :

diag(C)
## [1] 1 1 1

Note

La fonction diag() permet par ailleurs de créer une matrice identité :

diag(3)
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1

Pour obtenir la trace d’une matrice carrée, on peut simplement sommer les éléments de la diagonale :

sum(diag(D))
## [1] -2

3.1.4 Combiner des matrices

Pour ajouter des colonnes à une matrice, la fonction cbind() peut être utilisée. Il s’agit de combiner (bind) les colonnes (columns) de deux matrices ou d’une matrice et d’un vecteur colonne.

cbind(B, C)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    5    1    1    0    0
## [2,]    2    3    0    1    0
## [3,]    3    4    0    0    1
cbind(B, c(10,11,12))
##      [,1] [,2] [,3]
## [1,]    5    1   10
## [2,]    2    3   11
## [3,]    3    4   12

Pour ajouter des lignes à une matrice, la fonction rbind() peut être utilisée. Il s’agit de combiner (bind) les lignes (rows) de deux matrices ou d’une matrice et d’un vecteur ligne.

rbind(C, D)
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1
## [4,]   -2    2   -3
## [5,]   -1    1    3
## [6,]    4    0   -1
rbind(C, c(10,11,12))
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## [3,]    0    0    1
## [4,]   10   11   12

Note

Si on ajoute un vecteur colonne (ligne) à une matrice, et que la taille du vecteur est inférieure au nombre de colonnes (lignes), R effectue ce que l’on appelle un recyclage. C’est-à-dire que R va compléter le vecteur plus court à l’aide des valeurs de ce même vecteur, en repartant au début de celui-ci, afin d’obtenir deux objets de même taille.

cbind(B, c(10, 11))
##      [,1] [,2] [,3]
## [1,]    5    1   10
## [2,]    2    3   11
## [3,]    3    4   10

Exercice

Dans cet exercice, nous allons considérer un modèle de régression linéaire.

\[y_i = \beta_0 + \sum_{j=1}^{p} \beta_j x_{p,i} + \varepsilon_i,\]

avec \(i=1,\ldots, n\) indiçant les individus statistiques, \(y\) la variable à expliquer, \(\beta_0\) le coefficient de la constante, \(\beta_j\) le coefficient associé à la variable explicative \(x_j\) (avec \(j=1, \ldots, p\)), et \(\epsilon\) un terme d’erreur distribué normalement avec une espérance nulle et une variance \(\sigma^2\).

L’écriture matricielle du modèle est la suivante :

\[y = \boldsymbol{X} \beta + \varepsilon,\] avec \(y\) le vecteur de la variable à expliquer, \(\boldsymbol X\) la matrice contenant les variables explicatives (et la constante), et \(\varepsilon\) le terme d’erreur.

Dans cet exercice, vous allez utiliser vos connaissances acquises sur les matrices pour estimer les coefficients du modèle par la méthode des moindres carrés ordinaires.

Considérons le modèle suivant, pour les observations \(i=1,\ldots, n\) :

\[\textrm{consommation}_i = \beta_0 + \beta_1 \textrm{puissance}_i + \beta_2 \textrm{masse}_i + \varepsilon_i,\] où \(\textrm{consommation}\) est la variables à expliquer (\(y\)). Il s’agit d’un vecteur de valeurs de consommation de carburant (miles par gallons). \(\textrm{puissance}\) et \(\textrm{masse}\) sont des vecteurs de puissance (nombre de chevaux) et de masse du véhicule (en millième de livres) respectivement. Le vecteur \(\varepsilon\) est un terme d’erreurs que l’on suppose distribué selon une normale d’espérance nulle.

L’objectif de l’exercice est d’estimer les paramètres \(\beta_0\), \(\beta_1\) et \(\beta_2\).

Dans un premier temps, évaluez les instructions suivantes pour récupérer les valeurs (qui sont stockées dans un tableau de données nommé mtcars qui est fourni dans le package {datasets}).

consommation <- mtcars$mpg
puissance <- mtcars$hp
masse <- mtcars$wt

Créez également un vecteur pour la constante (ce vecteur ne contient que des 1) :

constante <- rep(1, nrow(mtcars))
  1. Créez la matrice X qui doit contenir 3 colonnes : une pour la constante (constante), une autre pour la puissance (puissance) et une dernière pour la masse (masse) ;
  2. Calculez la transposée de \(X\) : \(X^\top\) ;
  3. Calculez le produit matriciel : \(X^\top X\) ;
  4. Calculez l’inverse de ce produit matriciel : \((X^\top X)^{-1}\) ;
  5. Calculez le produit matriciel \(X^\top y\);
  6. Donnez les estimations des paramètres : \((X^\top X)^{-1} X^\top y\).

3.2 Listes

Tandis que les éléments d’un vecteur ou d’une matrice doivent nécessairement être de même type, les listes proposent une structure de données moins rigide à cet égard. Les types des élément d’une liste en R peuvent être différents.

l_1 <- list(c(10,12,15), c("Janvier", "Fevrier"))
l_1
## [[1]]
## [1] 10 12 15
## 
## [[2]]
## [1] "Janvier" "Fevrier"

Les classes d’objets à l’intérieur d’une liste ne sont pas non plus nécessairement identiques. Dans l’exemple qui suit, la liste l_2 contient un vecteur de numériques en premier élément, et une matrice de numériques en second :

l_2 <- list(c(1,2,3), matrix(c(1,2,3,4), ncol = 2))
l_2
## [[1]]
## [1] 1 2 3
## 
## [[2]]
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4

Les éléments peuvent être, comme dans un vecteur, nommés. Les noms peuvent être indiqués au moment de la création…

l_1 <- list(notes = c(10,12,5), mois = c("Janvier", "Fevrier"))
l_1
## $notes
## [1] 10 12  5
## 
## $mois
## [1] "Janvier" "Fevrier"

… ou une fois la liste créée, à l’aide de la fonction names() :

l_1 <- list(c(10,12,5),  c("Janvier", "Fevrier"))
names(l_1) <- c("notes", "mois")
l_1
## $notes
## [1] 10 12  5
## 
## $mois
## [1] "Janvier" "Fevrier"

3.2.1 Accès aux éléments

Comme pour les vecteurs, il est possible d’utiliser les crochets pour extraire des éléments d’une liste. La fonction crochet appliquée à une liste retourne une liste. On donne en arguments de cette fonction, comme pour les vecteurs, soit des positions, soit des noms, soit des valeurs logiques.

Créons une liste contenant 4 éléments :

l_3 <- list(nombres = 1:5, alphabet_min = letters,
            alphabet_maj = LETTERS, mois = month.name)
l_3
## $nombres
## [1] 1 2 3 4 5
## 
## $alphabet_min
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
## 
## $alphabet_maj
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
## 
## $mois
##  [1] "January"   "February"  "March"     "April"     "May"       "June"     
##  [7] "July"      "August"    "September" "October"   "November"  "December"

Note

Il existe 5 constantes intégrées en R :

  • LETTERS : les 26 lettres de l’alphabet occidental, en majuscules ;
  • letters : les 26 lettres de l’alphabet occidental, en minuscules ;
  • month : les noms des 12 mois de l’année du calendrier grégorien ;
  • month.abb : les abbréviations en 3 lettres des 12 mois du calendrier grégorien ;
  • pi : le ratio de la circonférence d’un cercle sur son diamiètre (\(pi\)).

L’indexation par position fonctionne comme pour un vecteur :

l_3[1]
## $nombres
## [1] 1 2 3 4 5
l_3[c(1,3)]
## $nombres
## [1] 1 2 3 4 5
## 
## $alphabet_maj
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
l_3[-c(2,3)]
## $nombres
## [1] 1 2 3 4 5
## 
## $mois
##  [1] "January"   "February"  "March"     "April"     "May"       "June"     
##  [7] "July"      "August"    "September" "October"   "November"  "December"

L’indexation par nom fonctionne aussi comme pour les vecteurs :

l_3[c("mois", "nombres")]
## $mois
##  [1] "January"   "February"  "March"     "April"     "May"       "June"     
##  [7] "July"      "August"    "September" "October"   "November"  "December" 
## 
## $nombres
## [1] 1 2 3 4 5

Il en est de même pour l’indexation par condition :

l_3[c(TRUE, FALSE, FALSE, TRUE)]
## $nombres
## [1] 1 2 3 4 5
## 
## $mois
##  [1] "January"   "February"  "March"     "April"     "May"       "June"     
##  [7] "July"      "August"    "September" "October"   "November"  "December"

Note

Nous verrons lors de la séance de travaux dirigés sur les boucles comment parcourir les éléments d’une liste tout en appliquant un test logique à chaque élément.

On note bien que le résultat retourné est une liste :

class(l_3[1])
## [1] "list"
class(l_3[c(1,3)])
## [1] "list"
class(l_3["nombres"])
## [1] "list"

Si l’on souhaite accéder au contenu d’un élément particulier, il faut utiliser la fonction double crochets ("[["()). De manière analogue à la fonction crochets ("["()), une syntaxe allégée est proposée.

l_3[[1]]
## [1] 1 2 3 4 5

Le résultat retourné est bien le contenu, ici un vecteur d’entiers :

class(l_3[[1]])
## [1] "integer"

La fonction str(), qui affiche la structure d’un objet de manière compacte, permet de mieux se fixer les idées :

str(l_3[1])
## List of 1
##  $ nombres: int [1:5] 1 2 3 4 5
str(l_3[[1]])
##  int [1:5] 1 2 3 4 5

Note

Lorsque les éléments de la liste son nommés et que l’on désire extraire le contenu d’un seul élément, il est possible d’utiliser le dollar en lieu et place des crochets, en indiquant le nom de l’élément.

l_3$nombres

Créons une liste comprenant trois éléments, dont le 3e est une liste de deux éléments :

l_4 <- 
  list(c(1,2,3),
     c("Bonjour", "Hello"),
     list(c(1,2,3), month.name))
l_4
## [[1]]
## [1] 1 2 3
## 
## [[2]]
## [1] "Bonjour" "Hello"  
## 
## [[3]]
## [[3]][[1]]
## [1] 1 2 3
## 
## [[3]][[2]]
##  [1] "January"   "February"  "March"     "April"     "May"       "June"     
##  [7] "July"      "August"    "September" "October"   "November"  "December"

Si on souhaite extraire le premier élément du troisième élément de l_4, on utilise dans un premier temps les doubles crochets (pour extraire le contenu du 3e élément de l_4), puis on utilise la fonction crochet sur le résultat (pour extraire le premier élément). Il s’agit d’une composition de fonctions, et la fonction appliquée en dernier étant la fonction crochet, le résultat est… une liste !

l_4[[3]][1]
## [[1]]
## [1] 1 2 3

Si l’on souhaite extraire le contenu du 1er élément du 3e élément de l_4, on utilisera deux fois la fonction double crochets : la première pour extraire le contenu du 3e élément (on récupère l’objet en 3e position, qui est une liste) puis la seconde pour extraire le contenu du premier élément de ce que l’on vient d’extraire :

l_4[[3]][[1]]
## [1] 1 2 3

3.2.2 Remplacement et ajout d’éléments

Pour remplacer un élément dans une liste, comme pour un vecteur ou une matrice, on utilise une nouvelle affectation.

l_3[["nombres"]] <- c(6,5,4,3,2,1,0)
l_3$mois <- c("January", "February")
l_3
## $nombres
## [1] 6 5 4 3 2 1 0
## 
## $alphabet_min
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
## 
## $alphabet_maj
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
## 
## $mois
## [1] "January"  "February"

Pour ajouter un élément, on effectue simplement une affectation. Soit on nomme le nouvel élément :

l_3["autres_nombres"] <- c(1,2,3)
l_3
## $nombres
## [1] 6 5 4 3 2 1 0
## 
## $alphabet_min
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
## 
## $alphabet_maj
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
## 
## $mois
## [1] "January"  "February"
## 
## $autres_nombres
## [1] 1

Si l’élément n’as pas vocation à être nommé, on utilise la fonction c() et on place le nouvel élément au sein d’une liste :

l_3 <- c(l_3, list(c(4,5,6)))
l_3
## $nombres
## [1] 6 5 4 3 2 1 0
## 
## $alphabet_min
##  [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
## [20] "t" "u" "v" "w" "x" "y" "z"
## 
## $alphabet_maj
##  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
## [20] "T" "U" "V" "W" "X" "Y" "Z"
## 
## $mois
## [1] "January"  "February"
## 
## $autres_nombres
## [1] 1
## 
## [[6]]
## [1] 4 5 6

Exercice

  1. Extrayez le 3e élément de la liste suivante :

    ma_liste <- list(rnorm(10), LETTERS[1:26], month.abb)

  2. Extrayez tous les éléments de la liste ma_liste sauf le second.

  3. Extrayez le contenu du troisième élément de la liste ma_liste_2, en utilisant le nom de l’élément.

    ma_liste_2 <- list(nombre = rnorm(10),
             lettre = LETTERS[1:26], mois = month.abb)

  4. Toujours en accédant par le nom, ajoutez 10 à chacune des valeurs du premier élément de ma_liste_2. Le résultat doit altérer ma_liste_2.

  5. Ajouter un élément au vecteur de nombres de l’élément nombre de la liste ma_liste_2. Cet élément doit être le numérique -10.