Importer des données dans R
Importer consiste à choisir un lecteur, préserver les types de colonnes voulus et vérifier l’objet obtenu avant l’analyse. Ce guide couvre les fichiers locaux délimités, Excel, JSON, RData et RDS tenant en mémoire ; les requêtes de bases de données et le traitement en flux en sont exclus. Commencez par les vecteurs, tableaux de données et valeurs manquantes de R si ces opérations ne vous sont pas familières.
Les exemples de texte intégré et de fichiers temporaires ne nécessitent aucune donnée de projet. Les chemins sous data/data-import/ sont illustratifs, pas des jeux de données fournis : remplacez-les par vos fichiers et vérifiez l’existence du répertoire parent avant d’écrire. Les chemins relatifs partent de getwd(). Les lecteurs de base ne nécessitent aucun paquet supplémentaire ; les exemples readr, data.table, readxl et jsonlite supposent ces paquets déjà installés.
Fichiers séparés par un symbole
Les fichiers séparés par un symbole sont les formats de données les plus courants. Il est essentiel de savoir les importer. Ici, « symbole » désigne tout délimiteur qui sépare les données, le plus souvent les virgules (,) et les tabulations (\t), appelés respectivement fichiers CSV et TSV.
CSV
Les fichiers CSV ont généralement l’extension .csv. L’extension ne modifie pas le contenu du fichier, mais aide à identifier rapidement le format et facilite son interprétation automatique par certains logiciels. Par exemple, un fichier CSV représentant les notes d’élèves peut ressembler à ceci :
student,chinese,math,english
stu1,99,100,98
stu2,60,50,88
R fournit read.table() pour importer des fichiers délimités. Voici comment l’utiliser pour importer directement les données depuis du texte :
stu <- read.table(text = "
student,chinese,math,english
stu1,99,100,98
stu2,60,50,88
", header = TRUE, sep = ",")
stu
class(stu)
Les données sont généralement stockées dans des fichiers sur l’ordinateur. Pour importer un fichier CSV avec read.table() :
cars <- read.table(file = "data/data-import/mtcars.csv", header = TRUE, sep = ",")
Examinez les premières lignes :
head(cars)
Vous pouvez aussi utiliser read.csv() pour les fichiers CSV, qui simplifie l’opération :
cars2 <- read.csv(file = "data/data-import/mtcars.csv")
head(cars2)
Préserver le sens avant de calculer
L’inférence de type peut transformer l’identifiant 001 en nombre 1. Une virgule entre guillemets appartient au champ, tandis qu’une virgule non citée sépare les champs ; une simple découpe de chaînes perdrait cette distinction. Déclarez types et marqueurs de valeurs manquantes lorsque le format est connu :
csv <- 'id,score,note
001,10,"good, complete"
002,,pending'
scores <- read.csv(
text = csv,
colClasses = c("character", "numeric", "character"),
na.strings = c("", "NA"),
check.names = FALSE
)
stopifnot(
identical(names(scores), c("id", "score", "note")),
nrow(scores) == 2L,
identical(scores$id, c("001", "002")),
is.na(scores$score[2]),
!anyDuplicated(scores$id),
all(is.na(scores$score) | (scores$score >= 0 & scores$score <= 100))
)
str(scores)
colSums(is.na(scores))
Le résultat a deux lignes et trois colonnes ; le second score est manquant, pas nul. Les contrôles d’unicité et de plage expriment le schéma de cet exemple, pas des règles universelles du CSV. head() seul ne détecte pas une valeur mal formée en fin de fichier. Vérifiez aussi le nombre de lignes attendu, les colonnes obligatoires, les unités et l’interprétation des dates. fileEncoding = "UTF-8" demande ce décodage si c’est l’encodage réel du fichier ; le deviner ne répare pas un texte endommagé. read.csv2() traite la variante courante séparée par des points-virgules avec virgule décimale. read.table() utilise par défaut comment.char = "#", tandis que read.csv() désactive les commentaires ; employez comment.char = "" si # fait partie des données.
Importer efficacement avec readr et data.table
readr et data.table::fread() proposent d’autres lecteurs. Comparez options d’analyse, classes retournées, mémoire utilisée et temps mesuré sur vos données, plutôt que de supposer un lecteur toujours plus rapide.
Créez un fichier CSV temporaire afin que chaque lecteur traite la même entrée :
temp_csv <- tempfile(fileext = ".csv")
writeLines(c("id,value", "1,10", "2,20"), temp_csv)
z1 <- read.csv(temp_csv)
Avec readr
z2 <- readr::read_csv(temp_csv, show_col_types = FALSE)
Avec data.table
z3 <- data.table::fread(temp_csv)
Les trois fonctions renvoient des classes d’objets liées, mais différentes :
class(z1)
class(z2)
class(z3)
unlink(temp_csv)
Avec readr, indiquez col_types lorsque l’inférence est risquée et examinez readr::problems(z2) pour les échecs d’analyse. show_col_types = FALSE masque le message de types, pas le besoin de validation. Une lecture réussie peut encore avoir des types erronés, des noms réparés ou des valeurs manquantes inattendues. Tous ces exemples chargent les données en mémoire ; un lecteur plus rapide ne supprime pas cette limite de capacité.
TSV et autres variantes de CSV
Les fichiers TSV utilisent la tabulation comme délimiteur et s’importent de manière semblable en indiquant sep = "\t" :
mt <- read.table("data/data-import/mtcars.tsv", sep = "\t", header = TRUE)
mt
Avec readr :
mt2 <- readr::read_tsv("data/data-import/mtcars.tsv")
mt2
Avec data.table :
mt3 <- data.table::fread("data/data-import/mtcars.tsv")
mt3
Excel
Les fichiers Excel sont couramment utilisés pour stocker et traiter des données. Le paquet readxl importe les données Excel :
library(readxl)
mt_excel <- read_excel("data/data-import/mtcars.xlsx")
head(mt_excel)
Pour lire une feuille précise, définissez d’abord le chemin du classeur :
excel_path <- "data/data-import/example.xlsx"
readxl::excel_sheets(excel_path)
iris <- readxl::read_excel(excel_path, sheet = "iris")
head(iris)
Le classeur et le nom de feuille sont des entrées du projet ; remplacez-les par des chemins qui existent réellement.
Vérifiez le rectangle sélectionné, la ligne d’en-tête et les types, pas seulement le nom de feuille. readxl::read_excel() accepte range, skip, col_types et na ; imposez par exemple "text" à un identifiant dont l’inférence perdrait le sens. Les cellules vides sont manquantes par défaut. Si Excel a déjà stocké 001 comme le nombre 1 avec un format d’affichage, lire du texte ne reconstitue pas automatiquement l’identifiant voulu.
JSON
JSON est un format léger d’échange de données. Le paquet jsonlite convertit entre JSON et objets R :
jsonlite::toJSON(letters)
jsonlite::toJSON(c(a = 1L, b = 2.0))
jsonlite::toJSON(data.frame(a = 1:3, b = 2:4))
jsonlite::toJSON(list(a = 1L, b = 2:5, c = c(TRUE, FALSE), d = NULL))
Enregistrez des données JSON dans un fichier :
jsonlite::write_json(list(a = 1L, b = 2:5, c = c(TRUE, FALSE), d = NULL), path = "data/data-import/example.json")
Lisez des données JSON :
jsonlite::read_json("data/data-import/example.json")
jsonlite::read_json("data/data-import/example.json", simplifyVector = TRUE)
read_json() renvoie des listes imbriquées par défaut ; simplifyVector = TRUE tente de convertir les structures compatibles en vecteurs ou tableaux de données. Examinez str() avant de supposer des lignes tabulaires. Un champ absent, JSON null et un tableau vide ont des sens différents ; décidez comment chacun devient une valeur manquante dans votre analyse. JSON ne préserve pas toutes les classes ou tous les attributs R : il ne remplace donc pas généralement RDS si la structure exacte de l’objet compte.
Fichiers de données R
Employer les formats de stockage natifs de R, RData et RDS, est efficace et courant pour enregistrer et charger des objets R.
RData
Les fichiers RData peuvent enregistrer plusieurs objets nommés. Comme load() les écrit dans un environnement, utilisez un environnement dédié lorsque les noms ne doivent pas fuir dans l’espace de travail global :
d1 <- head(mtcars)
d2 <- head(iris)
save(d1, d2, file = "data/data-import/example.RData")
loaded <- new.env(parent = emptyenv())
load("data/data-import/example.RData", envir = loaded)
ls(loaded)
RDS
Les fichiers RDS servent à stocker un seul objet et permettent de le renommer au chargement :
saveRDS(mtcars, file = "data/data-import/mtcars.rds")
mtcars_rename <- readRDS("data/data-import/mtcars.rds")
head(mtcars_rename)
RDS stocke un objet, qui peut lui-même être une liste de nombreux objets. readRDS() le retourne pour affectation ; load() restaure les noms enregistrés dans un environnement et retourne ces noms. L’environnement séparé ci-dessus évite les remplacements de noms accidentels, mais n’est pas un bac à sable de sécurité. Ne désérialisez que des fichiers R de sources fiables.
Problèmes courants et solutions
Charger des données depuis le presse-papiers
Cette connexion "clipboard" est une méthode Windows, pas un chemin portable ; sur les autres plateformes, l’accès dépend de la session et des outils disponibles. Voir les connexions R. Pour une analyse répétable, enregistrez plutôt l’entrée dans un fichier.
data <- read.table('clipboard', header=TRUE)
Lire ligne par ligne
Utilisez readLines() pour lire le contenu d’un fichier ligne par ligne :
fil <- tempfile(fileext = ".data")
cat("TITLE extra line", "2 3 5 7", "", "11 13 17", file = fil, sep = "\n")
readLines(fil, n = -1)
unlink(fil) # Clean up
Format de fichier à largeur fixe
Utilisez read.fwf() ou readr::read_fwf() pour les formats de fichiers à largeur fixe.