Opérations sur les listes avec R

Détails
Catégorie parente: Logiciel R
Catégorie : Les listes dans R

Maintenant que vous avez vu un exemple simple de création d'une liste, regardons comment accéder et travailler avec les listes.


1 Indexer la liste
Vous pouvez accéder à un composant de liste de différentes façons:

  1. > j$salary
  2. [1] 55000
  3. > j[["salary"]]
  4. [1] 55000
  5. > j[[2]]
  6. [1] 55000
Source code
Nous pouvons nous référer à la liste des composants par leurs indices numériques, en traitant la liste en tant que vecteur. Cependant, notez que, dans ce cas, nous utilisons des brackets double au lieu de simples. Donc, il existe trois façons d'accéder à un composant individuel c d'une liste 1ère et de le renvoyer dans le type de données de c:
• 1er $ c
• 1er [["c"]]
• 1er [[i]], où i est l'index de c au 1er
Chacune d'entre elles est utile dans différents contextes, comme vous le verrez dans les exemples suivants. Mais notez la phrase de qualification, "renvoyez-la dans le type de données de c". Une alternative à la deuxième et à la troisième techniques répertoriées consiste à utiliser des brackets simples plutôt que des crochets double:
• 1er ["c"]
• 1er [i], où i est l'index de c au 1er
Les éléments de liste d'accès à l'indexation à une seule parenthèse et à double bracket en mode index vectoriel. Mais il existe une différence importante par rapport à l'indexation vectorielle (atomique) ordinaire. Si des supports individuels [] sont utilisés, le résultat est une autre liste - une sous-partition de l'original. Par exemple, en continuant l'exemple précédent, nous avons ceci:

  1. > j[1:2]
  2. $name
  3. [1] "Joe"
  4. $salary
  5. [1] 55000
  6. > j2 <- j[2]
  7. > j2
  8. $salary
  9. [1] 55000
  10. > class(j2)
  11. [1] "list"
  12. > str(j2)
  13. List of 1
  14. $ salary: num 55000
Source code

L'opération de sous-ensemble a renvoyé une autre liste consistant en les deux premiers composants de la liste d'origine j. Notez que le mot retourné est logique, car les brackets d'index sont des fonctions. Ceci est similaire à d'autres cas que vous avez vus pour les opérateurs qui ne semblent pas être des fonctions, comme par exemple +.
En revanche, vous pouvez utiliser deux brackets [[]] pour référencer uniquement un seul composant, le résultat ayant le type de ce composant.

  1. > j[[1:2]]
  2. Error in j[[1:2]] : subscript out of bounds
  3. > j2a <- j[[2]]
  4. > j2a
  5. [1] 55000
  6. > class(j2a)
  7. [1] "numeric"
Source code

2 Ajout et suppression d'éléments de liste
Les opérations d'ajout et de suppression d'éléments de liste se produisent dans un nombre surprenant de contextes. Ceci est particulièrement vrai pour les structures de données dans lesquelles les listes constituent la base, telles que les trames de données et les classes R.
Les nouveaux composants peuvent être ajoutés après la création d'une liste.


  1. > z <- list(a="abc",b=12)
  2. > z
  3. $a
  4. [1] "abc"
  5. $b
  6. [1] 12
  7. > z$c <- "sailing" # ajouter un composant c
  8. > # c est-il ajouter?
  9. > z
  10. $a
  11. [1] "abc"
  12. $b
  13. [1] 12
  14. $c
  15. [1] "sailing"
Source code

 L'ajout de composants peut également être effectué via un index vectoriel:

  1. > z[[4]] <- 28
  2. > z[5:7] <- c(FALSE,TRUE,TRUE)
  3. > z
  4. $a
  5. [1] "abc"
  6. $b
  7. [1] 12
  8. $c
  9. [1] "sailing"
  10. [[4]]
  11. [1] 28
  12. [[5]]
  13. [1] FALSE
  14. [[6]]
  15. [1] TRUE
  16. [[7]]
  17. [1] TRUE
Source code

Notez que lors de la suppression de z $ b, les indices des éléments après avoir déplacé vers le haut par 1. Par exemple, l'ancien z [[4]] est devenu z [[3]].
Vous pouvez également concaténer des listes.

  1. > c(list("Joe", 55000, T),list(5))
  2. [[1]]
  3. [1] "Joe"
  4. [[2]]
  5. [1] 55000
  6. [[3]]
  7. [1] TRUE
  8. [[4]]
  9. [1] 5
Source code


3 Obtenir la taille d'une liste
Étant donné qu'une liste est un vecteur, vous pouvez obtenir le nombre de composants dans une liste via 1 length ().

  1. > length(j)
  2. [1] 3
Source code