Sélectionner des colonnes en R : dplyr et base R

Q: Comment sélectionner des colonnes spécifiques en R ?

Avec dplyr : select(df, col1, col2) garde les colonnes nommées. Avec base R : df[, c("col1", "col2")]. Les deux renvoient un data frame avec uniquement ces colonnes, dans l’ordre où vous les avez listées.

Q: Comment supprimer (retirer) une colonne en R ?

Négativez-la. dplyr : select(df, -col) en supprime une, select(df, -c(a, b)) en supprime plusieurs. Base R : df[, -2] supprime par position, ou subset(df, select = -col) supprime par nom (plus sûr, car cela résiste au réordonnancement des colonnes).

Q: Comment sélectionner des colonnes par motif de nom en R ?

Utilisez les fonctions d’aide dplyr à l’intérieur de select() : starts_with("Sepal"), ends_with("Width"), contains("date"), matches("regex"), ou where(is.numeric) pour sélectionner par type. Elles choisissent les colonnes sans que vous tapiez chaque nom — pratique sur les data frames larges.

Q: Quelle est la différence entre [ et [[ pour sélectionner des colonnes ?

df[, "x"] et df["x"] gardent une colonne (un data frame, ou un vecteur si une seule colonne se réduit). df[["x"]] et df$x extraient la colonne sous forme de vecteur de valeurs. Utilisez [[ lorsque vous voulez les valeurs brutes ; utilisez select() ou [, c(...)] lorsque vous voulez récupérer un data frame.

Q: Comment réordonner des colonnes en R ?

La sélection fixe l’ordre. dplyr : select(df, Species, everything()) déplace Species en premier et garde le reste. Base R : listez les colonnes dans le nouvel ordre, df[, c("Species", "Sepal.Length", ...)]. Rien n’est supprimé — seul l’ordre change.

Garder, supprimer et réordonner les colonnes d’un data frame — par nom, plage ou fonction d’aide, de deux façons

Sélectionnez les colonnes d’un data frame en R avec dplyr select() (par nom, plage a:c, fonctions d’aide comme starts_with()/where(is.numeric), et -col pour supprimer) ou en base-R df[, c("a","b")], df[["a"]] et subset(df, select = ...). Gardez, supprimez et réordonnez des colonnes — les deux moteurs, côte à côte, même résultat.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

Points clés

dplyr : select(df, a, b) garde des colonnes ; select(df, -a) en supprime ; select(df, a:c) garde une plage.
Les fonctions d’aide choisissent les colonnes par motif : starts_with("Sepal"), ends_with("Width"), contains("." ), where(is.numeric).
base R : df[, c("a", "b")] garde par nom, df[, -2] supprime par position, df[["a"]] extrait une colonne sous forme de vecteur.
Réordonnez en listant les colonnes dans le nouvel ordre : select(df, Species, everything()) place Species en premier.
Les routes dplyr et base-R donnent les mêmes colonnes — choisissez celle qui convient à votre base de code.

Introduction

Un jeu de données a souvent plus de colonnes que nécessaire. Avant de tracer un graphique, de modéliser ou d’exporter, vous voulez généralement garder quelques colonnes, supprimer le reste, ou les placer dans un ordre judicieux. C’est la sélection de colonnes.

Il existe deux routes que vous croiserez dans le code des autres :

dplyr select() — noms, plages et fonctions d’aide par motif ; se lit comme une phrase.
base R — indexez avec [, extrayez une colonne avec [[, ou utilisez subset(select = ...) ; aucun paquet nécessaire.

Cette leçon montre les deux, côte à côte, pour garder, supprimer, réordonner et filtrer les colonnes par motif. Les deux donnent le même résultat, vous pouvez donc lire n’importe quelle base de code et choisir celle que vous préférez. Nous utilisons le jeu de données intégré iris :

names(iris)

[1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"  "Species"

Garder des colonnes par nom

dplyr — `select(df, col, col, ...)`

select() prend le data frame, puis les colonnes à garder — non entre guillemets, séparées par des virgules. Ici, nous gardons uniquement les deux colonnes de sépale :

library(dplyr)
iris_sepal <- select(iris, Sepal.Length, Sepal.Width)
head(iris_sepal)

  Sepal.Length Sepal.Width
1          5.1         3.5
2          4.9         3.0
3          4.7         3.2
4          4.6         3.1
5          5.0         3.6
6          5.4         3.9

Tout le reste est supprimé ; les colonnes gardées restent dans l’ordre où vous les avez listées.

base R — `df[, c("a", "b")]`

Le crochet [ prend les lignes avant la virgule et les colonnes après. Laissez l’emplacement des lignes vide pour garder toutes les lignes, et passez un vecteur de noms de colonnes à garder :

iris_sepal <- iris[, c("Sepal.Length", "Sepal.Width")]
head(iris_sepal)

  Sepal.Length Sepal.Width
1          5.1         3.5
2          4.9         3.0
3          4.7         3.2
4          4.6         3.1
5          5.0         3.6
6          5.4         3.9

Les deux mêmes colonnes. Pour extraire une seule colonne sous forme de vecteur simple (et non un data frame à une colonne), utilisez [[ ou $ :

head(iris[["Sepal.Length"]])   # same as iris$Sepal.Length

[1] 5.1 4.9 4.7 4.6 5.0 5.4

select(iris, Sepal.Length) renvoie toujours un data frame ; iris[["Sepal.Length"]] renvoie un vecteur. Utilisez [[ lorsque vous voulez les valeurs brutes pour les passer à une fonction.

Supprimer des colonnes

Pour retirer une colonne, négativez-la.

dplyr — `select(df, -col)`

Placez un moins devant le nom de la colonne pour la supprimer et garder le reste :

library(dplyr)
no_species <- select(iris, -Species)
head(no_species)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2
4          4.6         3.1          1.5         0.2
5          5.0         3.6          1.4         0.2
6          5.4         3.9          1.7         0.4

Supprimez-en plusieurs d’un coup en négativant un vecteur : select(iris, -c(Species, Sepal.Width)).

base R — indice négatif ou `subset(select = ...)`

En base R, vous supprimez par position avec un indice négatif — Species est la 5e colonne, donc -5 :

no_species <- iris[, -5]
head(no_species)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2
4          4.6         3.1          1.5         0.2
5          5.0         3.6          1.4         0.2
6          5.4         3.9          1.7         0.4

Compter les positions est fragile : si l’ordre des colonnes change, -5 supprime la mauvaise colonne. subset() vous permet de supprimer par nom, ce qui résiste au réordonnancement :

no_species <- subset(iris, select = -Species)
head(no_species)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2
4          4.6         3.1          1.5         0.2
5          5.0         3.6          1.4         0.2
6          5.4         3.9          1.7         0.4

subset(df, select = ...) est l’outil de base-R le plus proche en esprit de select() — noms non entre guillemets, et un - en tête pour supprimer.

Garder une plage de colonnes

Lorsque les colonnes que vous voulez sont adjacentes, nommez la première et la dernière avec un deux-points au lieu de les lister une par une.

dplyr — `a:c`

library(dplyr)
petals <- select(iris, Petal.Length:Species)
head(petals)

  Petal.Length Petal.Width Species
1          1.4         0.2  setosa
2          1.4         0.2  setosa
3          1.3         0.2  setosa
4          1.5         0.2  setosa
5          1.4         0.2  setosa
6          1.7         0.4  setosa

Cela garde Petal.Length, Petal.Width et Species — tout, de la première colonne nommée à la dernière.

base R — indexer une plage

La même idée avec les positions. Petal.Length est la colonne 3 et Species la colonne 5 :

petals <- iris[, 3:5]
head(petals)

  Petal.Length Petal.Width Species
1          1.4         0.2  setosa
2          1.4         0.2  setosa
3          1.3         0.2  setosa
4          1.5         0.2  setosa
5          1.4         0.2  setosa
6          1.7         0.4  setosa

La plage dplyr est par nom (robuste au réordonnancement) ; la plage base-R est par position. Préférez les noms dans les scripts que vous relancerez.

Sélectionner des colonnes par motif (fonctions d’aide dplyr)

Lorsque vous ne voulez pas taper chaque nom — « garder toutes les colonnes Sepal », « garder chaque colonne numérique » — les fonctions d’aide à la sélection de dplyr filtrent par motif. C’est la raison pour laquelle select() brille face à l’indexation simple.

library(dplyr)
select(iris, starts_with("Sepal")) |> head()

  Sepal.Length Sepal.Width
1          5.1         3.5
2          4.9         3.0
3          4.7         3.2
4          4.6         3.1
5          5.0         3.6
6          5.4         3.9

En voici quelques-unes que vous utiliserez constamment :

library(dplyr)
# columns whose name ends with "Width"
select(iris, ends_with("Width")) |> head(3)

  Sepal.Width Petal.Width
1         3.5         0.2
2         3.0         0.2
3         3.2         0.2

# columns whose name contains a dot
select(iris, contains(".")) |> head(3)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2

# every numeric column (drops the factor Species)
select(iris, where(is.numeric)) |> head(3)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2

where(is.numeric) est particulièrement pratique — elle garde les colonnes par type, et non par nom, donc elle fonctionne sur n’importe quel data frame. L’équivalent en base-R nécessite un sapply() explicite :

num_only <- iris[, sapply(iris, is.numeric)]
head(num_only, 3)

  Sepal.Length Sepal.Width Petal.Length Petal.Width
1          5.1         3.5          1.4         0.2
2          4.9         3.0          1.4         0.2
3          4.7         3.2          1.3         0.2

Même résultat — select(where(is.numeric)) est le raccourci lisible de ce motif sapply().

Réordonner les colonnes

La sélection réordonne aussi : les colonnes ressortent dans l’ordre où vous les listez. Pour déplacer Species en tête et garder tout le reste à sa suite, utilisez everything() :

library(dplyr)
reordered <- select(iris, Species, everything())
names(reordered)

[1] "Species"      "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"

everything() signifie « toutes les colonnes pas encore nommées », donc rien n’est supprimé — Species saute simplement en tête. La version base-R liste explicitement le nouvel ordre :

reordered <- iris[, c("Species", "Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width")]
names(reordered)

[1] "Species"      "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width"

Même ordre de colonnes, de deux façons. everything() vous évite de retaper tous les autres noms.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la compilation. Modifiez celui-ci et appuyez sur Run pour sélectionner des colonnes par vous-même — il s’exécute dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Sélectionner les bonnes colonnes dans un fichier large et désordonné, c’est là que cela devient délicat — des dizaines de colonnes, des noms incohérents. Collez vos names() et demandez à Prova « garde uniquement les colonnes numériques et l’ID, supprime le reste » ; elle écrit l’appel select(), et comme le runtime est juste là, vous l’exécutez pour confirmer que les colonnes gardées sont bien celles que vous vouliez sur vos données. Demander à Prova →

Vous travaillez en Python ? Un guide de sélection de colonnes pandas (df[[...]], .filter(), .select_dtypes()) arrive bientôt dans la série Python.

Problèmes courants

select() est « not found » ou sélectionne la mauvaise chose. Un autre paquet (souvent MASS ou raster) définit lui aussi un select(), et celui chargé en dernier l’emporte. Si select() se comporte mal, appelez-le explicitement : dplyr::select(iris, Sepal.Length).

Supprimer une seule colonne renvoie un vecteur en base R. iris[, 5] vous donne un vecteur, mais iris[, -5] (suppression) garde un data frame — la règle est que le [ de base simplifie en vecteur lorsque le résultat a une colonne. Forcez un data frame avec drop = FALSE : iris[, 5, drop = FALSE]. dplyr select() renvoie toujours un data frame, donc il ne vous surprend jamais ici.

Noms entre guillemets ou non. dplyr select() prend des noms non entre guillemets (select(iris, Species)) ; le [, c(...)] de base prend des chaînes entre guillemets (iris[, "Species"]). Les confondre est l’erreur de copier-coller la plus fréquente — select(iris, "Species") fonctionne par tolérance, mais iris[, Species] provoque une erreur car Species n’est pas un objet.

Questions fréquentes

Comment sélectionner des colonnes spécifiques en R ?

Avec dplyr : select(df, col1, col2) garde les colonnes nommées. Avec base R : df[, c("col1", "col2")]. Les deux renvoient un data frame avec uniquement ces colonnes, dans l’ordre où vous les avez listées.

Comment supprimer (retirer) une colonne en R ?

Négativez-la. dplyr : select(df, -col) en supprime une, select(df, -c(a, b)) en supprime plusieurs. Base R : df[, -2] supprime par position, ou subset(df, select = -col) supprime par nom (plus sûr, car cela résiste au réordonnancement des colonnes).

Comment sélectionner des colonnes par motif de nom en R ?

Utilisez les fonctions d’aide dplyr à l’intérieur de select() : starts_with("Sepal"), ends_with("Width"), contains("date"), matches("regex"), ou where(is.numeric) pour sélectionner par type. Elles choisissent les colonnes sans que vous tapiez chaque nom — pratique sur les data frames larges.

Quelle est la différence entre [ et [[ pour sélectionner des colonnes ?

df[, "x"] et df["x"] gardent une colonne (un data frame, ou un vecteur si une seule colonne se réduit). df[["x"]] et df$x extraient la colonne sous forme de vecteur de valeurs. Utilisez [[ lorsque vous voulez les valeurs brutes ; utilisez select() ou [, c(...)] lorsque vous voulez récupérer un data frame.

Comment réordonner des colonnes en R ?

La sélection fixe l’ordre. dplyr : select(df, Species, everything()) déplace Species en premier et garde le reste. Base R : listez les colonnes dans le nouvel ordre, df[, c("Species", "Sepal.Length", ...)]. Rien n’est supprimé — seul l’ordre change.

Testez vos connaissances

Exercice : garder les colonnes numériques, de deux façons

À partir d’iris, gardez uniquement les colonnes numériques (supprimez le facteur Species). D’abord avec dplyr select() et une fonction d’aide, puis avec l’indexation base-R — et confirmez que les deux donnent les mêmes names().

library(dplyr)

dplyr_way <- select(iris, where(is.numeric))

base_way <- iris[, sapply(iris, is.numeric)]

identical(names(dplyr_way), names(base_way))  # TRUE

Vérification rapide : quel appel supprime la colonne Species ?

iris a les colonnes Sepal.Length, Sepal.Width, Petal.Length, Petal.Width, Species. Lequel garde tout sauf Species ?

A. select(iris, Species) B. select(iris, -Species) C. iris[, "Species"]

Afficher la réponse

B. Un - en tête supprime une colonne en dplyr, donc select(iris, -Species) garde les quatre colonnes numériques. A garde uniquement Species, et C garde aussi uniquement Species (base-R, par nom). La façon base-R de supprimer est subset(iris, select = -Species) ou iris[, -5].

Conclusion

Sélectionner des colonnes se résume à deux outils équivalents : dplyr select() (noms, plages a:c, fonctions d’aide comme starts_with()/where(), et -col pour supprimer), ou base-R df[, c("a", "b")] / subset(select = ...). Gardez par nom, supprimez par négation, filtrez par motif avec les fonctions d’aide dplyr, et réordonnez en listant les colonnes dans l’ordre voulu — les deux routes aboutissent au même data frame.

Leçons connexes

Renommer des colonnes en R — changez les noms de colonnes avec rename() / names(). · Filtrer des lignes en R — gardez les lignes qui remplissent une condition. · Réordonner des lignes en R — triez avec arrange() / order(). · Supprimer les lignes en double en R — éliminez les observations répétées.
Aller plus loin : Manipulation de données — 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 Manipulation de données en R et Python — 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 = {Sélectionner des colonnes en R : dplyr et base R},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/data-wrangling/select-columns-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Sélectionner des colonnes en R : dplyr et base R.” 2026. June 26. https://www.datanovia.com/learn/programming/data-wrangling/select-columns-in-r.