Listes en langage R : comment créer et sélectionner des éléments

Qu’est-ce que la liste R ?

Liste R est un objet dans la programmation R qui comprend des matrices, des vecteurs, des trames de données ou des listes. R List est également utilisé pour stocker une collection d'objets et les utiliser lorsque nous en avons besoin. On peut imaginer la liste R comme un sac pour mettre de nombreux objets différents. Lorsque nous avons besoin d’utiliser un article, nous pouvons ouvrir le sac et l’utiliser.

C’est le contraste avec un vecteur qui rend le sac utile. Un vecteur impose un type unique à chaque élément ; ainsi, placer un mot à côté d’un nombre transforme ce dernier en texte. Une liste n’applique pas une telle règle, c’est pourquoi elle peut contenir un vecteur à cinq éléments ou une ligne à deux éléments. matrice et un cadre de données de 714 lignes côte à côte sans en modifier aucune.

Syntaxe de liste dans R

Nous pouvons utiliser la fonction list() pour créer des listes en langage R :

list(element_1, ...)
arguments:
-element_1: store any type of R object
-...: pass as many objects as specifying. each object needs to be separated by a comma

Chaque argument peut être passé nu ou sous la forme balise = valeurUn argument nu devient un élément positionnel accessible uniquement par son numéro, tandis qu'un argument étiqueté acquiert également un nom. La documentation de base de R pour liste() Les documents contiennent à la fois des formulaires et des notes indiquant que unlist() agit comme l'inverse approximatif de as.list().

Comment créer une liste dans R

Vous trouverez ci-dessous un processus étape par étape sur la façon de créer une liste dans R :

Dans l'exemple ci-dessous, nous allons créer trois objets différents, un Vecteur, une Matrice et un Trame de données en utilisant la fonction de liste dans R.

Étape 1) Créer un vecteur

Utilisez le code ci-dessous pour créer un vecteur dans R

# Vector with numeric from 1 up to 5
vect  <- 1:5

L'opérateur deux-points construit la séquence 1, 2, 3, 4, 5 comme un vecteur d'entiers, et la flèche d'affectation le stocke sous le nom vect.

Étape 2) Créer une matrice

Maintenant, créez une matrice en utilisant le code suivant

# A 2x 5 matrix
mat  <- matrix(1:9, ncol = 5)
dim(mat)

Deux détails méritent d'être soulignés. Une grille de deux lignes et cinq colonnes nécessite dix valeurs, or seules neuf sont fournies. R réutilise donc la séquence et affiche un avertissement indiquant que la longueur des données n'est pas un sous-multiple du nombre de lignes. C'est pourquoi la deuxième ligne de la matrice affichée se termine par 1 et non par 10. L'appel à la fonction `dim()` renvoie ensuite la forme de la grille.

Sortie :

## [1] 2 5

Étape 3) Créer un bloc de données

Créez un bloc de données dans R en utilisant le code ci-dessous

# select the 10th row of the built-in R data set EuStockMarkets
df <- EuStockMarkets[1:10,]

Le commentaire mentionne la dixième ligne, mais l'expression conserve les lignes 1 à 10 de la série intégrée EuStockMarkets. La sélection de sous-ensembles supprime également la classe de série temporelle ; le résultat est donc une matrice numérique et non un véritable tableau de données. C'est pourquoi le résultat affiché ci-dessous comporte des étiquettes de lignes de type [1,] au lieu de noms de lignes. Encadrez l'appel avec as.data.frame() chaque fois qu'un véritable tableau de données est nécessaire.

Étape 4) Créer une liste dans R

Maintenant, nous pouvons mettre les trois objets dans la liste R en utilisant le code ci-dessous

# Construct list with these vec, mat, and df:
my_list <- list(vect, mat, df)
my_list

Sortie :

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

## [[2]]
##       [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8    1

## [[3]]
##          DAX    SMI    CAC   FTSE
##  [1,] 1628.75 1678.1 1772.8 2443.6
##  [2,] 1613.63 1688.5 1750.5 2460.2
##  [3,] 1606.51 1678.6 1718.0 2448.2
##  [4,] 1621.04 1684.1 1708.1 2470.4
##  [5,] 1618.16 1686.6 1723.1 2484.7
##  [6,] 1610.61 1671.6 1714.3 2466.8
##  [7,] 1630.75 1682.9 1734.5 2487.9
##  [8,] 1640.17 1703.6 1757.4 2508.4
##  [9,] 1635.47 1697.5 1754.0 2510.5
##  [10,] 1645.89 1716.3 1754.3 2497.4

Les trois en-têtes entre doubles crochets dans ce résultat correspondent aux positions des éléments dans la liste. Aucune transformation n'a été effectuée : le premier élément reste un vecteur d'entiers, le deuxième une matrice et le troisième contient toujours les dix lignes de cours boursiers.

Sélectionnez des éléments dans la liste R

Une fois notre liste créée, nous pouvons y accéder très facilement. Il suffit d'utiliser l'index ([[index]]) pour sélectionner un élément. La valeur entre doubles crochets représente la position de l'élément à sélectionner dans la liste.tract. Par exemple, si nous passons 2 entre parenthèses, R renvoie le deuxième élément listé.

Maintenant dans ce Tutoriel R, essayons de sélectionner le deuxième élément des listes dans R nommé ma_liste, nous utilisons ma_liste[[2]]

# Print second element of the list
my_list[[2]]

Sortie :

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8    1

Les parenthèses simples et doubles ne sont pas interchangeables, et les confondre est la source la plus fréquente d'erreurs dans les listes. Une parenthèse conserve l'élément englobant, deux parenthèses le suppriment.

# Compare the two bracket styles
class(my_list[[2]])   # the matrix itself
class(my_list[2])     # a list of length one

# Several elements, and everything but one element
my_list[c(1, 3)]
my_list[-2]

Listes nommées en R

Les index positionnels sont fragiles : l’insertion d’un élément entraîne un décalage à chaque insertion. Nommer les éléments élimine ce risque et rend le code plus lisible, reflétant ainsi les données qu’il décrit. Les noms peuvent être fournis lors de la création de la liste, ou ajoutés ultérieurement avec la fonction `names()`.

# Tag each element at creation time
named_list <- list(numbers = vect, grid = mat, prices = df)

# Three ways to reach the same element
named_list$grid
named_list[["grid"]]
named_list["grid"]      # returns a one-element list

# Read or replace the names later
names(named_list)
names(named_list)[2] <- "grid_2x5"

L'opérateur $ et les doubles crochets diffèrent sur un point qui peut induire en erreur les débutants. L'opérateur $ effectue une correspondance partielle ; ainsi, named_list$pri trouve toujours les prix, tandis que named_list[["pri"]] renvoie NULL car les doubles crochets correspondent exactement, sauf si exact = FALSE est spécifié. La correspondance partielle est pratique dans la console, mais risquée dans un script ; il est donc préférable d'utiliser la forme exacte dans le code enregistré.

# A compact map of the whole structure
str(named_list)

La fonction str() affiche une ligne par élément avec son type et sa taille, ce qui est le moyen le plus rapide de confirmer qu'une liste contient ce que vous attendez avant d'y accéder par index.

Modifier, ajouter et supprimer des éléments dans une liste R

Une liste n'est pas figée une fois créée. Les mêmes méthodes d'accès qui lisent un élément peuvent également y écrire ; ainsi, la mise à jour, l'extension et la réduction d'une liste utilisent toutes des affectations classiques.

# Replace an element in place
named_list[["numbers"]] <- 1:10

# Add a new element simply by naming it
named_list[["created"]] <- Sys.Date()

# Append without a name: the element lands at the end
named_list <- append(named_list, list(TRUE))

# Delete an element by assigning NULL to it
named_list[["created"]] <- NULL

• Remplacer: L'attribution d'un nom à un élément existant écrase cet élément et laisse sa position inchangée.
• Ajouter : L'attribution d'un nom inexistant ajoute un nouvel élément à la fin de la liste.
• Ajouter: La fonction append() prend une liste comme deuxième argument ; il faut donc encapsuler une valeur nue dans list() avant de la passer.
• Effacer: L'affectation de la valeur NULL entre doubles crochets supprime l'élément et raccourcit la liste.

Une conséquence qui induit souvent en erreur est la suivante : comme NULL signifie la suppression, on ne peut pas stocker une valeur NULL réelle entre doubles crochets. Il faut utiliser une affectation entre crochets simples, comme dans named_list["empty"] <- list(NULL), ce qui conserve l'emplacement et y place NULL.

Listes imbriquées et fonction unlist() en R

Puisqu'une liste peut contenir n'importe quel objet R, elle peut aussi contenir une autre liste. L'imbrication est la manière dont les objets de configuration, les réponses JSON et les résultats de modèles sont généralement représentés en R ; accéder à une liste imbriquée et l'aplatir sont donc des opérations courantes.

# A list whose elements are themselves lists
project <- list(
  meta = list(owner = "analyst", year = 2026),
  data = list(vect, mat)
)

# Chain the accessors to reach an inner value
project$meta$year
project[["data"]][[2]]

# Flatten every level into one atomic vector
flat <- unlist(project)

# Strip a single level and keep the rest as a list
half <- unlist(project, recursive = FALSE)

L'aplatissement a un coût qu'il convient de comprendre. La fonction `unlist()` doit renvoyer un vecteur atomique ; elle convertit donc chaque valeur dans le type le plus général disponible, selon l'ordre suivant : logique, entier, double, caractère. Une liste imbriquée contenant à la fois des nombres et du texte est donc renvoyée entièrement sous forme de texte. Les noms des éléments résultants sont construits en concaténant les balises externes et internes, ce qui explique pourquoi un élément est renvoyé sous le nom `meta.owner` plutôt que `owner`.

Utilisez `use.names = FALSE` lorsque les noms composés sont indésirables, et `recursive = FALSE` si seule la couche externe doit être supprimée. Si les valeurs doivent conserver leur type, laissez la structure intacte et parcourez la liste au lieu de l'aplatir.

Trame de données intégrée dans R

Les listes sont souvent remplies de données lues depuis le disque ou le web. Il est donc utile de comprendre comment un dataframe est constitué avant d'y être stocké. Avant de créer notre propre dataframe, nous pouvons examiner le jeu de données R disponible en ligne. Le jeu de données « prison » a une dimension de 714×5. La fonction `tail()` permet d'afficher rapidement le bas du dataframe. De même, `head()` affiche le haut du dataframe. Vous pouvez spécifier le nombre de lignes à afficher avec `head(df, 5)`. Nous aborderons plus en détail la fonction `read.csv()` dans la suite. importer des données dans R tutoriel.

PATH <-'https://raw.githubusercontent.com/guru99-edu/R-Programming/master/prison.csv'
df <- read.csv(PATH)[1:5]
head(df, 5)

Sortie :

##   X state year govelec black
## 1 1     1   80       0 0.2560
## 2 2     1   81       0 0.2557
## 3 3     1   82       1 0.2554
## 4 4     1   83       0 0.2551
## 5 5     1   84       0 0.2548

L'index [1:5] qui suit read.csv() sélectionne les cinq premières colonnes, et non les cinq premières lignes, car un data frame est lui-même une liste de colonnes. L'indexation par une seule accolade sur une liste renvoie une liste plus courte, et ici, cette liste plus courte est toujours un data frame.

Nous pouvons vérifier la structure de la trame de données avec str :

# Structure of the data
str(df)

Sortie :

## 'data.frame':    714 obs. of  5 variables:
##  $ X      : int  1 2 3 4 5 6 7 8 9 10 ...
##  $ state  : int  1 1 1 1 1 1 1 1 1 1 ...
##  $ year   : int  80 81 82 83 84 85 86 87 88 89 ...
##  $ govelec: int  0 0 1 0 0 0 1 0 0 0 ...
##  $ black  : num  0.256 0.256 0.255 0.255 0.255 ...

Toutes les variables sont stockées dans le numérique Le format. Le préfixe $ sur chaque ligne est le même opérateur que celui utilisé précédemment pour les listes nommées, ce qui confirme qu'un data frame est une liste de colonnes de longueur égale portant une étiquette rectangulaire. Tout ce qui a été appris concernant le nommage, la sélection et la suppression des éléments d'une liste s'applique donc directement à types de données R et aux colonnes du cadre de données.

FAQ