Listes en R : créer, accéder et modifier avec list()

Q: Comment créer une liste en R ?

Utilisez list(), en donnant à chaque élément un nom pour un accès facile : list(name = "Nic", age = 27, scores = c(90, 85)). Les éléments peuvent être de n’importe quel type et de n’importe quelle longueur — un nombre, un vecteur character, un data frame, même une autre liste — le tout dans un seul objet. Omettez les noms (list(42, "x")) si vous n’avez besoin que d’un accès par position.

Q: Quelle est la différence entre [ ] et [[ ]] pour une liste en R ?

[[ ]] (crochets doubles) extrait un élément et le renvoie tel quel — le vecteur, le data frame ou la valeur à l’intérieur. [ ] (crochets simples) renvoie une liste plus petite contenant le ou les éléments sélectionnés, pas le contenu. Donc mylist[["x"]] est la valeur, tandis que mylist["x"] est une liste de longueur 1. Utilisez [[ ]] (ou $) pour sortir un élément ; utilisez [ ] pour garder un sous-ensemble sous forme de liste.

Q: Comment accéder à un élément de liste par son nom en R ?

Utilisez $ ou [[ ]] avec le nom : mylist$score ou mylist[["score"]] renvoient tous deux l’élément. Utilisez $ quand vous tapez le nom littéralement dans votre code ; utilisez [[ ]] quand le nom est stocké dans une variable (nm <- "score"; mylist[[nm]]) ou quand vous indexez par position (mylist[[2]]).

Q: Comment ajouter ou supprimer un élément d’une liste en R ?

Pour ajouter ou remplacer, affectez à un nom : mylist$new <- value (ou mylist[["new"]] <- value). Pour supprimer un élément, affectez-lui NULL : mylist[["old"]] <- NULL le supprime et réduit la liste. $ comme [[ ]] fonctionnent pour l’affectation.

Q: Comment boucler sur une liste en R ?

Utilisez lapply(mylist, FUN) pour appliquer une fonction à chaque élément — elle renvoie une nouvelle liste de résultats. Utilisez sapply(mylist, FUN) pour la même chose mais simplifiée en vecteur quand les résultats sont tous de longueur 1. Pour réduire une liste de valeurs uniques en un seul vecteur, utilisez unlist(mylist). Pour toute la famille (vapply, mapply, tapply), voir la leçon sur la famille apply.

Q: Comment convertir une liste en vecteur en R ?

Utilisez unlist(mylist), qui aplatit la liste en un seul vecteur et conserve les noms des éléments. Cela n’a de sens que lorsque les éléments sont atomiques (nombres, chaînes, logicals) ; les types mélangés sont coercés vers un type commun — tout élément character transforme l’ensemble du résultat en chaînes. Pour une liste de data frames ou de structures inégales, unlist() n’est pas le bon outil ; gardez la liste.

Le conteneur qui accueille n’importe quoi — construisez une liste, atteignez ses éléments avec [[ ]], $ et [ ], imbriquez-la et bouclez dessus avec lapply()

Créez et manipulez des listes en R : construisez-les avec list() (nommées ou non) ; extrayez les éléments avec le crucial [[ ]] (sortir l’élément) vs [ ] (garder une sous-liste) vs $ (par nom) ; contenez des éléments de types mélangés et imbriqués ; inspectez avec str()/length()/names() ; ajoutez, modifiez et supprimez des éléments (l$new <- ..., l[["x"]] <- NULL) ; et itérez avec lapply()/sapply() et aplatissez avec unlist().

Date de publication

12 juillet 2026

Modifié

12 juillet 2026

Points clés

Une liste est le conteneur le plus flexible de R : elle réunit des éléments de n’importe quel type et n’importe quelle longueur — un nombre à côté d’un vecteur character à côté d’un data frame entier.
Créez-la avec list(), en nommant les éléments (list(a = 1, b = "x")) ou en les laissant sans nom.
Accès — la distinction qui compte : [[ ]] et $ sortent un élément ; [ ] renvoie une liste plus petite. mylist[["x"]] est la valeur ; mylist["x"] est une liste à un élément.
Imbriquez des listes dans des listes et atteignez-les en enchaînant : res$model$r2 ou res[["model"]][["r2"]].
Faites croître et élaguez : ajoutez ou remplacez avec l$new <- value ; supprimez avec l[["x"]] <- NULL.
Inspectez avec str() (le meilleur aperçu), length() et names() ; itérez avec lapply() (renvoie une liste) ou sapply() (simplifie en vecteur), et aplatissez avec unlist().

Introduction

Exécutez un modèle linéaire en R et le résultat — lm() — est une liste : les coefficients (un vecteur numeric), les résidus (un autre vecteur), l’appel du modèle, les données. Un seul objet, plusieurs morceaux, chacun d’un type et d’une longueur différents. C’est à cela que sert une liste. Chaque fois que vous devez garder ensemble des choses liées mais différentes — les multiples sorties d’une fonction, un enregistrement aux champs mélangés, des résultats groupés par catégorie — une liste est le conteneur.

C’est le gain de flexibilité par rapport au vecteur et à la matrice, qui ne contiennent tous deux qu’un seul type. Une liste lève cette restriction : l’élément 1 peut être un nombre, l’élément 2 un vecteur character, l’élément 3 un data frame ou même une autre liste. Le prix de cette liberté est une seule chose à maîtriser — comment sortir un élément par opposition à comment garder un sous-ensemble — et cette leçon la rend limpide.

Nous couvrons la boîte à outils pratique : créer une liste, y accéder, l’imbriquer, ajouter et supprimer des éléments, l’inspecter et boucler dessus. Chaque exemple s’exécute dans votre navigateur.

Créer une liste

Construisez une liste avec list(). Donnez à chaque élément un nom (element = value) pour pouvoir l’atteindre par nom plus tard — le choix habituel et lisible. Les éléments peuvent être de types et de longueurs complètement différents ; c’est tout l’intérêt.

person <- list(
  name   = "Nicolas",
  age    = 27,
  scores = c(90, 85, 78),   # a numeric vector
  active = TRUE
)
person

$name
[1] "Nicolas"

$age
[1] 27

$scores
[1] 90 85 78

$active
[1] TRUE

L’affichage montre chaque élément sous son en-tête $name. Notez le mélange : une seule chaîne, un seul nombre, un vecteur numeric de longueur 3 et un logical — le tout dans un seul objet.

Vous pouvez aussi laisser les éléments sans nom, auquel cas vous ne les atteignez que par position :

mixed <- list(42, "hello", c(TRUE, FALSE))
mixed

[[1]]
[1] 42

[[2]]
[1] "hello"

[[3]]
[1]  TRUE FALSE

Ici les en-têtes s’affichent comme [[1]], [[2]], [[3]] — des positions, parce qu’il n’y a pas de noms. Les éléments nommés valent presque toujours le petit effort ; les listes uniquement positionnelles deviennent fragiles dès que l’ordre change.

Accéder aux éléments : `[[ ]]`, `$` et `[ ]`

C’est la seule chose à bien maîtriser sur les listes. Il y a deux tâches — sortir un élément, ou garder une liste plus petite — et des crochets différents font chacune.

[[ ]] va à l’intérieur de la liste et renvoie l’élément lui-même. $ est le raccourci lisible de [[ ]] quand vous connaissez le nom au moment où vous le tapez.

person <- list(name = "Nicolas", age = 27, scores = c(90, 85, 78))

person[["name"]]     # the value inside: the string "Nicolas"

[1] "Nicolas"

person$scores        # $ shortcut: the numeric vector, length 3

[1] 90 85 78

person[[3]]          # same element, by position

[1] 90 85 78

person$scores vous donne le vecteur numeric — vous pouvez l’indexer davantage, person$scores[1], pour obtenir le premier score.

Les crochets simples [ ] font quelque chose de différent : ils renvoient une liste plus petite, pas le contenu. C’est la distinction qui fait trébucher tout le monde au début.

person <- list(name = "Nicolas", age = 27, scores = c(90, 85, 78))

person["name"]            # a LIST of length 1

$name
[1] "Nicolas"

class(person["name"])     # "list"  — still a list!

[1] "list"

class(person[["name"]])   # "character" — the value itself

[1] "character"

Donc person["name"] est une liste contenant le nom ; person[["name"]] est le nom. Utilisez les crochets simples quand vous voulez un sous-ensemble de plusieurs éléments sous forme de liste, et utilisez-les avec un vecteur de noms ou de positions :

person <- list(name = "Nicolas", age = 27, scores = c(90, 85, 78))

person[c("name", "age")]   # a smaller list with two elements

$name
[1] "Nicolas"

$age
[1] 27

La règle en une ligne : [[ ]] / $ extraient un élément ; [ ] garde une (sous-)liste. Ce sont les mêmes opérateurs que vous rencontrez sur les vecteurs et les matrices — pour toute la mécanique (index négatifs, conditions logiques, which()) voir Indexation et sous-ensembles (?"[[").

Inspecter une liste : `str()`, `length()`, `names()`

Les listes deviennent profondes, donc un moyen rapide de voir ce qu’elles contiennent compte. str() est la fonction la plus utile ici — elle affiche une structure compacte et indentée de chaque élément, son type et un aperçu.

person <- list(name = "Nicolas", age = 27, scores = c(90, 85, 78), active = TRUE)

str(person)

List of 4
 $ name  : chr "Nicolas"
 $ age   : num 27
 $ scores: num [1:3] 90 85 78
 $ active: logi TRUE

Lisez str() de haut en bas : chaque ligne $ name : nomme un élément, donne son type (chr, num, logi) et prévisualise ses valeurs. C’est la première chose à exécuter sur toute liste inconnue — un objet de modèle, une réponse d’API, un résultat imbriqué.

Deux fonctions plus modestes renseignent la forme : length() compte les éléments de premier niveau (pas les valeurs à l’intérieur), et names() renvoie leurs noms.

person <- list(name = "Nicolas", age = 27, scores = c(90, 85, 78), active = TRUE)

length(person)   # 4 top-level elements

[1] 4

names(person)    # their names

[1] "name"   "age"    "scores" "active"

length(person) vaut 4 — quatre éléments — même si scores à lui seul contient trois nombres ; length() ne regarde jamais à l’intérieur d’un élément.

Ajouter, modifier et supprimer des éléments

Les listes sont faciles à faire croître et à élaguer sur place. Affectez à un nouveau nom pour ajouter un élément ; affectez à un nom existant pour le remplacer.

person <- list(name = "Nicolas", age = 27)

person$email <- "nic@example.com"   # add a new element
person[["age"]] <- 28               # modify an existing one
str(person)

List of 3
 $ name : chr "Nicolas"
 $ age  : num 28
 $ email: chr "nic@example.com"

person$email <- ... ajoute un nouvel élément ; person[["age"]] <- 28 écrase l’ancienne valeur. $ comme [[ ]] fonctionnent pour l’affectation — utilisez [[ ]] quand le nom est contenu dans une variable.

Pour supprimer un élément, affectez-lui NULL. C’est l’idiome base-R à mémoriser :

person <- list(name = "Nicolas", age = 28, email = "nic@example.com")

person[["email"]] <- NULL   # remove the email element
names(person)               # email is gone

[1] "name" "age"

Définir person[["email"]] <- NULL supprime entièrement l’élément — la liste passe de trois éléments à deux. (Ne confondez pas cela avec le stockage d’une valeur valant NULL ; pour garder un élément tout en le vidant, il faut list(x = NULL) à la création, un cas plus rare.)

Listes imbriquées

Un élément de liste peut lui-même être une liste — c’est ainsi que R représente tout ce qui a une forme d’arbre : la sortie d’un modèle, une configuration, du JSON. Atteignez l’imbrication en enchaînant les opérateurs, un niveau à la fois.

result <- list(
  model = list(formula = "y ~ x", r2 = 0.87),
  data  = list(n = 120, source = "survey")
)

result$model$r2               # chain $ down two levels

[1] 0.87

result[["data"]][["n"]]       # same idea with [[ ]]

[1] 120

str(result)                   # str() shows the whole tree at a glance

List of 2
 $ model:List of 2
  ..$ formula: chr "y ~ x"
  ..$ r2     : num 0.87
 $ data :List of 2
  ..$ n     : num 120
  ..$ source: chr "survey"

result$model$r2 descend dans model, puis dans r2 — chaque $ (ou [[ ]]) descend d’un niveau. str() est précieux ici : son indentation rend la forme de l’arbre évidente, si bien que vous savez quelle chaîne écrire.

Itérer sur une liste : `lapply()` et `sapply()`

Pour appliquer la même fonction à chaque élément d’une liste, utilisez lapply() — elle renvoie une nouvelle liste de résultats, un par élément. sapply() fait de même mais simplifie le résultat en vecteur ou en matrice quand elle le peut proprement.

measures <- list(a = c(1, 2, 3), b = c(10, 20), c = c(4, 5, 6, 7))

lapply(measures, length)   # a LIST of lengths, one per element

$a
[1] 3

$b
[1] 2

$c
[1] 4

sapply(measures, length)   # simplified to a named vector

a b c 
3 2 4

sapply(measures, mean)     # the mean of each element, as a vector

   a    b    c 
 2.0 15.0  5.5

lapply() renvoie toujours une liste (sûr, prévisible) ; sapply() renvoie un vecteur nommé propre quand les résultats sont tous de longueur 1 — pratique pour une synthèse rapide, mais elle retombe silencieusement sur une liste quand ce n’est pas le cas, donc utilisez lapply() quand vous avez besoin d’une forme garantie. La famille élargie — vapply(), mapply(), tapply() — est traitée dans La famille apply.

Pour aplatir une liste de valeurs atomiques en un seul vecteur, utilisez unlist() :

scores <- list(math = 90, reading = 85, science = 78)

unlist(scores)   # one named numeric vector

   math reading science 
     90      85      78

unlist() réduit la liste en un simple vecteur, en emportant les noms au passage. C’est la manière standard de retransformer une liste de valeurs uniques en vecteur — mais rappelez-vous la liberté d’une liste : unlist() sur des types mélangés va tout coercer vers un seul type (les nombres deviennent des chaînes si un élément est character), donc ne l’utilisez que sur des morceaux du même type.

Un cas d’usage réel : des résultats groupés par catégorie

Les listes sont l’endroit naturel pour les résultats groupés. split() divise un vecteur selon un facteur de regroupement et renvoie une liste nommée — un élément par groupe — sur laquelle vous bouclez ensuite. Ici, nous divisons la consommation de carburant par nombre de cylindres à l’aide du jeu de données intégré mtcars, puis calculons une moyenne par groupe.

# One list element per cylinder group (4, 6, 8), each a vector of mpg values
by_cyl <- split(mtcars$mpg, mtcars$cyl)
str(by_cyl)

List of 3
 $ 4: num [1:11] 22.8 24.4 22.8 32.4 30.4 33.9 21.5 27.3 26 30.4 ...
 $ 6: num [1:7] 21 21 21.4 18.1 19.2 17.8 19.7
 $ 8: num [1:14] 18.7 14.3 16.4 17.3 15.2 10.4 10.4 14.7 15.5 15.2 ...

split() retourne une liste dont les noms sont les libellés de groupe ("4", "6", "8") et dont les éléments sont les valeurs de mpg dans chaque groupe. Maintenant, un seul sapply() donne la moyenne de mpg par groupe :

by_cyl <- split(mtcars$mpg, mtcars$cyl)

sapply(by_cyl, mean)   # mean mpg for each cylinder group

       4        6        8 
26.66364 19.74286 15.10000

Ce motif diviser-puis-appliquer — grouper en une liste, appliquer par élément, simplifier — est le cœur base-R du « calculer un nombre par groupe », et c’est exactement pourquoi les listes apparaissent partout dans le vrai code d’analyse.

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la construction. Éditez celui-ci et appuyez sur Run pour construire une liste, y accéder, la modifier et boucler dessus — il s’exécute dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Collez une liste qui vous bloque — un objet de modèle, une réponse d’API imbriquée, un résultat de split() — et demandez à Prova « comment sortir juste ce morceau avec [[ ou $ ? ». Comme le runtime est juste là, vous exécutez sa réponse pour confirmer qu’elle renvoie l’élément que vous vouliez, pas une sous-liste à un seul élément. Demandez à Prova →

Problèmes fréquents

[ m’a donné une liste alors que je voulais la valeur. Les crochets simples sur une liste renvoient toujours une liste. Pour obtenir l’élément lui-même, utilisez les crochets doubles ou $ : person[["scores"]] (ou person$scores), pas person["scores"]. La forme à crochets simples sert à garder un sous-ensemble de la liste sous forme de liste plus petite.

$ renvoie NULL et le code casse plus loin. $ fait correspondre les noms littéralement et reste silencieux sur une faute de frappe — person$scor (des lettres manquantes) renvoie discrètement NULL au lieu de lever une erreur. Vérifiez le nom avec names(person), ou testez d’abord l’appartenance : "scores" %in% names(person).

Ma liste s’est transformée en simple vecteur. unlist() (et sapply() quand chaque résultat est de longueur 1) aplatit une liste en vecteur, coerçant tout vers un seul type — donc un élément character transforme vos nombres en chaînes. Si vous devez garder les éléments séparés et typés, restez sur la liste et utilisez lapply().

Questions fréquentes

Comment créer une liste en R ?

Utilisez list(), en donnant à chaque élément un nom pour un accès facile : list(name = "Nic", age = 27, scores = c(90, 85)). Les éléments peuvent être de n’importe quel type et de n’importe quelle longueur — un nombre, un vecteur character, un data frame, même une autre liste — le tout dans un seul objet. Omettez les noms (list(42, "x")) si vous n’avez besoin que d’un accès par position.

Quelle est la différence entre [ ] et [[ ]] pour une liste en R ?

[[ ]] (crochets doubles) extrait un élément et le renvoie tel quel — le vecteur, le data frame ou la valeur à l’intérieur. [ ] (crochets simples) renvoie une liste plus petite contenant le ou les éléments sélectionnés, pas le contenu. Donc mylist[["x"]] est la valeur, tandis que mylist["x"] est une liste de longueur 1. Utilisez [[ ]] (ou $) pour sortir un élément ; utilisez [ ] pour garder un sous-ensemble sous forme de liste.

Comment accéder à un élément de liste par son nom en R ?

Utilisez $ ou [[ ]] avec le nom : mylist$score ou mylist[["score"]] renvoient tous deux l’élément. Utilisez $ quand vous tapez le nom littéralement dans votre code ; utilisez [[ ]] quand le nom est stocké dans une variable (nm <- "score"; mylist[[nm]]) ou quand vous indexez par position (mylist[[2]]).

Comment ajouter ou supprimer un élément d’une liste en R ?

Pour ajouter ou remplacer, affectez à un nom : mylist$new <- value (ou mylist[["new"]] <- value). Pour supprimer un élément, affectez-lui NULL : mylist[["old"]] <- NULL le supprime et réduit la liste. $ comme [[ ]] fonctionnent pour l’affectation.

Comment boucler sur une liste en R ?

Utilisez lapply(mylist, FUN) pour appliquer une fonction à chaque élément — elle renvoie une nouvelle liste de résultats. Utilisez sapply(mylist, FUN) pour la même chose mais simplifiée en vecteur quand les résultats sont tous de longueur 1. Pour réduire une liste de valeurs uniques en un seul vecteur, utilisez unlist(mylist). Pour toute la famille (vapply, mapply, tapply), voir la leçon sur la famille apply.

Comment convertir une liste en vecteur en R ?

Utilisez unlist(mylist), qui aplatit la liste en un seul vecteur et conserve les noms des éléments. Cela n’a de sens que lorsque les éléments sont atomiques (nombres, chaînes, logicals) ; les types mélangés sont coercés vers un type commun — tout élément character transforme l’ensemble du résultat en chaînes. Pour une liste de data frames ou de structures inégales, unlist() n’est pas le bon outil ; gardez la liste.

Testez vos connaissances

Exercice : construire, extraire, modifier et résumer une liste

Créez une liste nommée student avec name = "Ana", grades = c(88, 92, 79) et passed = TRUE. Puis (1) extrayez le vecteur grades lui-même (pas une sous-liste), (2) ajoutez un élément email = "ana@example.com", (3) supprimez l’élément passed, et (4) calculez la moyenne de grades.

# list() takes name = value pairs; grades is c(88, 92, 79).
# To extract the vector itself, use [[ ]] or $ (not single [ ]).
# Add an element by assigning to a new name with $.
# Remove an element by assigning NULL to it.

student <- list(name = "Ana", grades = c(88, 92, 79), passed = TRUE)

# 1. the grades vector itself
g <- student[["grades"]]     # or student$grades

# 2. add an email element
student$email <- "ana@example.com"

# 3. remove the passed element
student[["passed"]] <- NULL

# 4. mean of the grades
mean(g)

Vérification rapide : quel appel renvoie la valeur, et non une sous-liste ?

l <- list(x = 1:3, y = "ok"). Quel appel renvoie le character "ok" lui-même ?

A. l["y"] B. l[["y"]] C. l[2]

Afficher la réponse

B. [[ ]] extrait l’élément, donc l[["y"]] (et l$y) renvoie "ok". A et C utilisent tous deux les crochets simples, qui renvoient une liste de longueur 1 — le class() de A et C est "list", pas "character".

Conclusion

Une liste est le conteneur universel de R : elle contient des éléments de n’importe quel type et longueur, et c’est pourquoi la sortie d’un modèle, une configuration et des résultats groupés arrivent tous sous forme de listes. Construisez-en une avec list() et nommez les éléments. Puis gardez la distinction unique bien en tête — [[ ]] et $ sortent un élément, [ ] garde une sous-liste — et tout le reste en découle : enchaînez les opérateurs pour atteindre les listes imbriquées, affectez pour ajouter ou remplacer, affectez NULL pour supprimer, exécutez str() pour voir la forme, et lapply()/sapply() pour boucler. Maîtrisez la liste et le reste des objets riches de R s’ouvre à vous, car presque tous sont des listes en dessous.

Leçons connexes

Vecteurs et types de données en R — le conteneur à type unique qu’une liste généralise, et les règles de coercition que suit unlist(). · Indexation et sous-ensembles — toute la mécanique de [, [[, $ sur les vecteurs, les listes et les matrices, y compris les index négatifs et logiques. · La famille apply — lapply()/sapply()/vapply()/tapply() pour boucler sur les listes, les vecteurs et les groupes. · Matrices en R — la grille bidimensionnelle à type unique, pour quand chaque colonne est du même type.
Aller plus loin : Fondations R — la série complète. · Science computationnelle et IA — le pilier.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Les bases de R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code affiché — modifiez n’importe quel bloc et appuyez sur Run pour le reproduire dans votre navigateur. The runtime is the judge.

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Listes en R : créer, accéder et modifier avec list()},
  date = {2026-07-12},
  url = {https://www.datanovia.com/learn/programming/r-foundations/lists-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Listes en R : créer, accéder et modifier avec list().” 2026. July 12. https://www.datanovia.com/learn/programming/r-foundations/lists-in-r.