Lire des fichiers CSV et texte en R : read.csv et readr

Q: Comment lire un fichier CSV en R ?

Utilisez base R read.csv("file.csv") — elle lit un fichier séparé par des virgules dans un data frame, en prenant les noms de colonnes dans la première ligne. Pour une lecture plus rapide qui renvoie un tibble et indique comment chaque colonne a été analysée, installez readr et utilisez read_csv("file.csv"). Les deux cherchent dans votre répertoire de travail sauf si vous donnez un chemin complet.

Q: Comment lire un fichier txt en R ?

Pour un .txt délimité par tabulations, utilisez base R read.delim("file.txt") ou readr read_tsv("file.txt"). Pour tout autre délimiteur, utilisez read.table("file.txt", sep = "|", header = TRUE) (base) ou read_delim("file.txt", delim = "|") (readr), en remplaçant "|" par votre séparateur.

Q: Quelle est la différence entre read.csv et read_csv ?

read.csv() est de base R : aucune installation, renvoie un data.frame, plus lente sur les gros fichiers, ne donne aucun retour sur l’analyse. read_csv() vient de readr : ~10× plus rapide, renvoie un tibble, et affiche comment chaque colonne a été analysée. Elles lisent les mêmes fichiers — utilisez base R pour une lecture rapide sans configuration, readr pour la vitesse, le contrôle des types, et le tidyverse.

Q: Comment lire un CSV avec un séparateur point-virgule en R ?

Utilisez read.csv2() (base R) ou read_csv2() (readr). Les deux attendent ; comme séparateur de champs et , comme séparateur décimal — la convention de nombreuses locales européennes. De façon équivalente, read.table(file, sep = ";", dec = ",", header = TRUE).

Charger un .csv ou un .txt délimité par tabulations dans un data frame — base R et readr, côte à côte

Lisez des fichiers CSV et texte dans R avec les fonctions base R read.csv(), read.table() et read.delim(), ou avec readr read_csv(), read_tsv() et read_delim(). Réglez le séparateur, l’en-tête, les types de colonnes, les marqueurs de valeurs manquantes, le séparateur décimal, et lisez directement depuis une URL — les deux méthodes présentées ensemble pour que vous puissiez choisir celle qui vous convient.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

Points clés

base R : read.csv("file.csv") pour les fichiers à virgules, read.delim("file.txt") pour les fichiers à tabulations — aucun package nécessaire.
readr : read_csv() / read_tsv() sont ~10× plus rapides, renvoient un tibble, et indiquent comment chaque colonne a été analysée.
Contrôlez l’analyse avec sep =/col_types =, header =/col_names =, na.strings =/na =, et skip =.
Fichiers européens (séparateur ;, décimale ,) : base read.csv2() ou readr read_csv2().
Les deux méthodes lisent directement depuis une URL — passez le lien au lieu d’un chemin local.

Introduction

Vous avez un export .csv ou un fichier .txt délimité par tabulations et vous devez le charger dans R comme data frame. Il existe deux méthodes que vous rencontrerez dans du code réel :

base R — read.csv(), read.table(), read.delim(). Toujours disponible, aucun package à installer.
readr — read_csv(), read_tsv(), read_delim(). Plus rapide sur les gros fichiers, renvoie un tibble, et affiche un message clair indiquant comment chaque colonne a été analysée.

Cette leçon présente les deux, côte à côte, pour les cas que vous rencontrez réellement : fichiers à virgules ou à tabulations, avec ou sans ligne d’en-tête, forçage des types de colonnes, marqueurs de valeurs manquantes inhabituels, fichiers européens ;/,, et lecture depuis une URL. Pour que chaque bloc s’exécute ici et dans votre navigateur, nous écrivons d’abord un petit fichier à partir d’un jeu de données intégré, puis nous le relisons — le code de lecture est exactement celui que vous lanceriez sur votre propre fichier.

csv_path <- tempfile(fileext = ".csv")            # your own path goes here: "data/cars.csv"
write.csv(head(mtcars[, 1:4], 6), csv_path, row.names = FALSE)
file.exists(csv_path)

[1] TRUE

Lire un CSV avec base R

read.csv() lit un fichier séparé par des virgules et renvoie un data frame. Elle suppose que la première ligne est un en-tête — les noms de colonnes en proviennent directement.

my_data <- read.csv(csv_path)
my_data

   mpg cyl disp  hp
1 21.0   6  160 110
2 21.0   6  160 110
3 22.8   4  108  93
4 21.4   6  258 110
5 18.7   8  360 175
6 18.1   6  225 105

Voilà toute la recette pour un .csv standard : un seul appel. Les colonnes arrivent typées — les nombres en numérique, le texte en caractère.

Note

De façon interactive, read.csv(file.choose()) ouvre un sélecteur de fichiers pour vous éviter de saisir le chemin — pratique quand vous débutez. Et read.csv("data.csv") cherche dans votre répertoire de travail courant ; vérifiez-le avec getwd().

`read.csv()`, `read.table()` et `read.delim()`

Ce sont la même fonction avec des valeurs par défaut différentes. Choisissez selon le format du fichier :

read.csv() — séparé par des virgules (sep = ","), en-tête activé.
read.delim() — séparé par des tabulations (sep = "\t"), pour la plupart des exports .txt.
read.table() — le moteur général ; réglez sep =, header =, dec = vous-même.

Voici un .txt délimité par tabulations lu de trois façons équivalentes :

txt_path <- tempfile(fileext = ".txt")
write.table(head(iris, 6), txt_path, sep = "\t", row.names = FALSE)

# read.delim — the tab-file shortcut
read.delim(txt_path)

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

# read.table — spell out the separator and header yourself
read.table(txt_path, header = TRUE, sep = "\t")

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

Pour tout autre délimiteur — un tube |, une espace — utilisez read.table() et réglez sep = sur ce caractère.

Garder le texte comme texte, pas comme facteurs

Dans l’ancien R (avant la version 4.0), read.csv() transformait silencieusement chaque colonne de texte en facteur — une source fréquente de confusion lorsque vous tentiez de modifier les chaînes. Le R moderne utilise par défaut stringsAsFactors = FALSE, donc le texte reste du texte. Réglez-le explicitement quand vous voulez en être sûr, ou sur une installation plus ancienne :

chr_data <- read.csv(csv_path, stringsAsFactors = FALSE)
str(chr_data[1, ])

'data.frame':   1 obs. of  4 variables:
 $ mpg : num 21
 $ cyl : int 6
 $ disp: int 160
 $ hp  : int 110

Sauter des lignes et corriger les valeurs manquantes

Les exports réels comportent souvent une ligne de commentaire en haut, et « manquant » peut être marqué par autre chose qu’un blanc — NA, ., -, ou N/A. Supprimez les lignes de tête avec skip = et listez chaque marqueur de valeur manquante dans na.strings = :

messy_path <- tempfile(fileext = ".csv")
writeLines(c("# exported 2026-06-26", "id,score", "1,88", "2,.", "3,N/A"), messy_path)

read.csv(messy_path, skip = 1, na.strings = c("NA", ".", "N/A"))

  id score
1  1    88
2  2    NA
3  3    NA

skip = 1 supprime la ligne de commentaire pour que la ligne suivante devienne l’en-tête ; chaque valeur de na.strings est importée comme NA au lieu de texte.

Fichiers européens : séparateur point-virgule, décimale virgule

Dans de nombreux pays, un CSV utilise ; comme séparateur de champs et , comme séparateur décimal (parce que la virgule est déjà prise). Lire un tel fichier avec un simple read.csv() le déforme. Utilisez read.csv2(), qui inverse les deux valeurs par défaut :

eu_path <- tempfile(fileext = ".csv")
writeLines(c("x;y", "1,5;2,5", "3,0;4,0"), eu_path)

# read.csv2: sep = ";", dec = ","
read.csv2(eu_path)

    x   y
1 1.5 2.5
2 3.0 4.0

Les valeurs arrivent comme de vrais nombres — 1,5 devient 1.5. De façon équivalente, read.table(file, sep = ";", dec = ",", header = TRUE).

Lire avec readr (la méthode la plus rapide)

Le package readr lit les mêmes fichiers mais est environ 10× plus rapide sur les gros volumes, renvoie un tibble (un data frame à l’affichage plus soigné), et vous indique exactement comment il a analysé chaque colonne. Les fonctions reflètent celles de base :

read_csv() — séparé par des virgules.
read_tsv() — séparé par des tabulations.
read_delim() — n’importe quel délimiteur, via delim =.
read_csv2() — la variante européenne ; / ,.

library(readr)
my_data <- read_csv(csv_path)
my_data

# A tibble: 6 × 4
    mpg   cyl  disp    hp
  <dbl> <dbl> <dbl> <dbl>
1  21       6   160   110
2  21       6   160   110
3  22.8     4   108    93
4  21.4     6   258   110
5  18.7     8   360   175
6  18.1     6   225   105

La première ligne contient les noms de colonnes ; les étiquettes <dbl> sous chaque nom indiquent comment readr l’a analysée (dbl = nombre, chr = texte). Ce rapport d’analyse est l’atout de readr — vous voyez d’un coup d’œil si une colonne a bien le type que vous attendiez.

Un fichier à tabulations se lit avec read_tsv() ; un délimiteur personnalisé avec read_delim(file, delim = "|") :

library(readr)
read_tsv(txt_path)

# A tibble: 6 × 5
  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
         <dbl>       <dbl>        <dbl>       <dbl> <chr>  
1          5.1         3.5          1.4         0.2 setosa 
2          4.9         3            1.4         0.2 setosa 
3          4.7         3.2          1.3         0.2 setosa 
4          4.6         3.1          1.5         0.2 setosa 
5          5           3.6          1.4         0.2 setosa 
6          5.4         3.9          1.7         0.4 setosa

Forcer les types de colonnes avec `col_types`

Quand l’estimation de readr est fausse — une colonne d’ID lue comme un nombre perd ses zéros initiaux, ou un code se lit comme une date — fixez le type avec col_types =. Utilisez les codes à une lettre : "c" caractère, "i" entier, "d" double, "l" logique, "D" date, "_" ignorer.

library(readr)
read_csv(csv_path, col_types = cols(mpg = "d", cyl = "i", disp = "d", hp = "i"))

# A tibble: 6 × 4
    mpg   cyl  disp    hp
  <dbl> <int> <dbl> <int>
1  21       6   160   110
2  21       6   160   110
3  22.8     4   108    93
4  21.4     6   258   110
5  18.7     8   360   175
6  18.1     6   225   105

La forme abrégée read_csv(file, col_types = "didi") fonctionne aussi — une lettre par colonne, dans l’ordre.

Indiquer à readr ce qui compte comme manquant

Par défaut, readr ne traite que les chaînes vides comme NA. Ajoutez vos propres marqueurs avec na = :

library(readr)
read_csv(messy_path, skip = 1, na = c("", "NA", ".", "N/A"))

# A tibble: 3 × 2
     id score
  <dbl> <dbl>
1     1    88
2     2    NA
3     3    NA

Si un fichier présente des problèmes d’analyse, readr vous avertit de leur nombre et vous pouvez les inspecter avec problems().

Lire directement depuis une URL

Les deux méthodes acceptent une adresse web à la place d’un chemin local — pratique pour un jeu de données publié que vous ne voulez pas télécharger à la main. (Cela nécessite une connexion internet, donc c’est présenté ici comme un modèle à copier plutôt qu’à exécuter sur la page.)

# base R
my_data <- read.csv("https://example.com/data.csv")

# readr — also auto-decompresses .gz / .zip URLs
my_data <- read_csv("https://example.com/data.csv")

readr va plus loin : une URL se terminant par .gz, .bz2, ou .zip est téléchargée et décompressée automatiquement.

base R ou readr — laquelle utiliser ?

	base R	readr
Installation requise	aucune	`install.packages("readr")`
Renvoie	`data.frame`	tibble
Vitesse (gros fichiers)	plus lente	~10× plus rapide
Retour sur l’analyse	aucun	rapport sur les types de colonnes
Virgule / tabulation / personnalisé	`read.csv` / `read.delim` / `read.table`	`read_csv` / `read_tsv` / `read_delim`
Européen `;` `,`	`read.csv2`	`read_csv2`

Pour une lecture rapide sur n’importe quelle machine sans installation, base R suffit. Pour les gros fichiers, un contrôle reproductible des types et le rapport d’analyse, readr est la valeur par défaut moderne — et c’est ce que le reste du tidyverse attend.

Essayez en direct

Les blocs ci-dessus se sont exécutés au moment de la génération. Modifiez celui-ci et appuyez sur Run — il écrit un petit CSV, puis le relit des deux façons, entièrement dans votre navigateur via webR (aucune installation).

🟢 Avec un agent IA

Collez les premières lignes désordonnées de votre fichier et demandez à Prova « de quels arguments de lecture ai-je besoin — sep, skip, na, ou col_types ? » Elle écrit l’appel read_csv(), et comme le runtime est juste là, vous l’exécutez pour confirmer que les données arrivent correctement depuis votre fichier. Demander à Prova →

Vous travaillez en Python ? Un guide pandas read_csv arrive dans la série Python.

Problèmes courants

Tout le fichier a atterri dans une seule colonne. Le séparateur est incorrect. Un fichier européen délimité par ; lu avec read.csv() (qui attend ,) place chaque ligne dans une seule colonne — utilisez read.csv2() (ou read_csv2()), ou réglez sep = ";" dans read.table(). Vérifiez d’abord les lignes brutes avec readLines(path, n = 3).

Les nombres sont arrivés comme du texte, ou les décimales paraissent énormes. Un fichier utilisant , comme séparateur décimal (1,5) lu avec le dec = "." par défaut échoue à l’analyse ou lit 1,5 comme le texte "1,5". Utilisez read.csv2() / read_csv2(), ou passez dec = "," à read.table().

Une colonne de texte est devenue un facteur (ancien R). Avant R 4.0, read.csv() utilisait par défaut stringsAsFactors = TRUE, transformant les chaînes en facteurs. Si vous êtes sur une installation plus ancienne ou héritez d’un tel code, ajoutez stringsAsFactors = FALSE — ou passez à readr, qui ne le fait jamais.

Une colonne d’ID a perdu ses zéros initiaux. "00123" paraît numérique, donc est lu comme 123. Forcez-le en texte : base read.csv(file, colClasses = c(id = "character")), ou readr read_csv(file, col_types = cols(id = "c")).

Questions fréquentes

Comment lire un fichier CSV en R ?

Utilisez base R read.csv("file.csv") — elle lit un fichier séparé par des virgules dans un data frame, en prenant les noms de colonnes dans la première ligne. Pour une lecture plus rapide qui renvoie un tibble et indique comment chaque colonne a été analysée, installez readr et utilisez read_csv("file.csv"). Les deux cherchent dans votre répertoire de travail sauf si vous donnez un chemin complet.

Comment lire un fichier txt en R ?

Pour un .txt délimité par tabulations, utilisez base R read.delim("file.txt") ou readr read_tsv("file.txt"). Pour tout autre délimiteur, utilisez read.table("file.txt", sep = "|", header = TRUE) (base) ou read_delim("file.txt", delim = "|") (readr), en remplaçant "|" par votre séparateur.

Quelle est la différence entre read.csv et read_csv ?

read.csv() est de base R : aucune installation, renvoie un data.frame, plus lente sur les gros fichiers, ne donne aucun retour sur l’analyse. read_csv() vient de readr : ~10× plus rapide, renvoie un tibble, et affiche comment chaque colonne a été analysée. Elles lisent les mêmes fichiers — utilisez base R pour une lecture rapide sans configuration, readr pour la vitesse, le contrôle des types, et le tidyverse.

Comment lire un CSV avec un séparateur point-virgule en R ?

Utilisez read.csv2() (base R) ou read_csv2() (readr). Les deux attendent ; comme séparateur de champs et , comme séparateur décimal — la convention de nombreuses locales européennes. De façon équivalente, read.table(file, sep = ";", dec = ",", header = TRUE).

Comment lire un fichier CSV depuis une URL en R ?

Passez l’adresse web là où vous passeriez un chemin de fichier : read.csv("https://example.com/data.csv") ou read_csv("https://example.com/data.csv"). readr télécharge et décompresse aussi automatiquement les URL .gz, .bz2 et .zip. Vous avez besoin d’une connexion internet.

Testez vos connaissances

Exercice : lire un fichier de deux façons et confirmer qu’elles concordent

Écrivez iris dans un .txt délimité par tabulations, puis relisez-le une fois avec base R (read.delim) et une fois avec readr (read_tsv). Confirmez que les deux ont les mêmes noms de colonnes.

library(readr)

path <- tempfile(fileext = ".txt")
write.table(head(iris, 5), path, sep = "\t", row.names = FALSE)

base_way  <- read.delim(path)
readr_way <- read_tsv(path)

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

Vérification rapide : quel appel lit un fichier européen ; / , ?

Un fichier sépare les champs avec ; et utilise , pour les décimales. Lequel le lit correctement ?

A. read.csv("file.csv") B. read.csv2("file.csv") C. read.table("file.csv")

Afficher la réponse

B. read.csv2() règle sep = ";" et dec = "," — exactement la convention européenne. A utilise des séparateurs virgule et placerait chaque ligne dans une seule colonne. C utilise par défaut la séparation par espaces et ne découpera pas non plus sur ;. L’équivalent readr est read_csv2().

Conclusion

Lire des fichiers plats dans R se résume à deux jeux d’outils équivalents. Base R — read.csv() pour les fichiers à virgules, read.delim() pour les fichiers à tabulations, read.table() pour tout le reste, read.csv2() pour les données européennes — ne nécessite aucune installation. readr — read_csv(), read_tsv(), read_delim() — est plus rapide, renvoie un tibble, indique l’analyse, et fixe les types avec col_types =. Adaptez la fonction au séparateur, réglez na/skip pour les fichiers désordonnés, et les deux méthodes lisent directement depuis une URL.

Leçons connexes

Lire des fichiers Excel en R — la méthode readxl / openxlsx pour .xls et .xlsx. · Enregistrer RDS et RData — stockez des objets R natifs pour que les types et les facteurs survivent. · Exporter des données depuis R — la vue d’ensemble complète pour sortir vos données (write.csv, write_csv). · Renommer des colonnes en R — nettoyez les noms juste après l’import.
Pour aller plus loin : Importer et exporter des 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 Importer et exporter des données en 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 = {Lire des fichiers CSV et texte en R : read.csv et readr},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/importing-exporting-data/read-csv-txt-in-r},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Lire des fichiers CSV et texte en R : read.csv et readr.” 2026. June 26. https://www.datanovia.com/learn/programming/importing-exporting-data/read-csv-txt-in-r.