Importer des données dans R - deuxième partie

Dans la continuité de notre tutoriel d’introduction à l’import de données dans R – première partie, DataCamp poursuit avec un guide complet mais accessible pour importer rapidement des données dans R, en partant de simples fichiers texte plats jusqu’aux fichiers plus avancés comme SPSS et SAS.

Comme beaucoup d’entre vous l’ont justement relevé à la lecture du premier article, d’excellents packages pour importer des données dans R n’avaient pas encore été abordés, et nous n’avions pas non plus distingué explicitement le travail avec des jeux de données « standards » et des jeux de données volumineux. C’est précisément l’objectif de ce nouvel article.

Poursuivez votre lecture pour découvrir d’autres façons d’importer vos fichiers spécifiques dans R, et n’hésitez pas à nous contacter si vous avez des questions complémentaires ou si vous repérez une erreur à corriger.

(Testez ce cours interactif : Importing Data in R (Part 1), pour travailler avec des fichiers CSV et Excel dans R.)

Importer des données issues de sources courantes dans R

Nous allons d’abord approfondir les méthodes pour charger dans R des données issues de sources courantes, souvent de type tableur. Comme dans le précédent article, l’accent est mis sur la lecture de données autres qu’Excel ou assimilés.

Ensuite, nous aborderons des sources comme les logiciels statistiques, les bases de données, le web scraping, etc.

Si vous souhaitez en savoir plus sur les étapes préalables avant l’import, consultez notre premier article, qui explique comment préparer vos données et votre espace de travail avant de les charger dans R.

Lire des fichiers plats dans R avec `scan()`

En plus de read.table(), mentionnée dans la première partie du tutoriel, la fonction scan() est également adaptée pour lire des données stockées dans des fichiers texte délimités simples. Contrairement à read.table(), scan() retourne une liste ou un vecteur, et non pas un data frame.

Supposons que vous ayez le document .txt suivant :

24 1991
21 1993
53 1962
Propulsé par

Vous pouvez lire ces données (à télécharger ici) avec la commande suivante :

data <- scan("birth.txt")
Propulsé par

Remarque : votre fichier peut aussi être un jeu de données en ligne. Dans ce cas, passez simplement l’URL en premier argument de scan().

Vous pouvez aussi lire les données dans une matrice :

data <- matrix(scan("birth.txt"),
               nrow=2,
               byrow=TRUE)
Propulsé par

Astuce : pour un contrôle fin, précisez des arguments supplémentaires afin d’obtenir exactement la matrice souhaitée. Consultez cette page pour plus d’informations sur matrix().

Vous pouvez également lire les colonnes du fichier source dans des vecteurs séparés :

data <- scan("age.txt",
             what = list(Age = 0,
                         Birthyear= 0),
             skip=1,
             quiet=TRUE)
Propulsé par

Remarque : vous passez d’abord le fichier (ou son chemin) avec son extension (selon que vous ayez défini ou non le répertoire de travail sur le dossier contenant votre jeu de données), puis vous indiquez le type de données à lire, si vous souhaitez ignorer la première ligne du fichier, quel caractère sépare les champs, et si vous voulez afficher ou non un message indiquant le nombre d’éléments lus.

Si vos données contiennent plusieurs types, ajustez légèrement scan(), comme dans cet exemple :

data <- scan("age.csv",
             what = list(Age = 0,
                         Name= "",
                         Birthyear= 0),
             skip=1,
             sep=";",
             quiet=TRUE)
Propulsé par

Astuce : essayez vous-même ! Téléchargez le fichier texte utilisé ci-dessus ici.

Vous pouvez ensuite lire les données dans un data frame :

data <- data.frame(scan("age.csv",
                        what = list(Age = 0,
                                    Name = "",
                                    Birthyear= 0),
                        skip=1,
                        sep=";",
                        quiet=TRUE)
Propulsé par

Astuce : de nombreux arguments de scan() sont identiques à ceux de read.table(). Un coup d’œil à la documentation est toujours utile ! C’est par ici pour les arguments de scan().

Mémo : pour obtenir et définir le répertoire de travail, utilisez respectivement :

getwd()
setwd("<path to your folder>")
Propulsé par

Charger des données à colonnes de largeur fixe avec `read.fwf()`

Pour lire dans un data frame R une table « à colonnes de largeur fixe », utilisez la fonction read.fwf() du package utils.

Cette fonction est utile lorsque votre fichier contient des colonnes séparées par des espaces variables, ou accolées sans séparateur.

   Phys / 00 / 1:    M  abadda
   Math / 00 / 2:    F  bcdccb
   Lang / 00 / 3:    F  abcdab
   Chem / 00 / 4:    M  cdabaa
Propulsé par

Ici, vous savez par exemple que la matière occupe toujours les 7 premiers caractères de chaque ligne, que le sexe est toujours au caractère 22, et que les notes commencent aux caractères 25 à 30.

Pour vous entraîner à charger ces données dans R, téléchargez le fichier texte ici.

Exécutez la commande suivante pour importer correctement les données ci-dessus :

read.fwf("scores.txt",
         widths= c(7,-14,1,-2,1,1,1,1,1,1),
         col.names=c("subject","sex","s1","s2","s3","s4","s5","s6"),
         strip.white=TRUE)
Propulsé par

Remarque : l’argument widths indique la largeur des champs. Ici, les 7 premiers caractères sont réservés aux matières ; vous ne voulez pas lire les 14 suivants : vous passez -14. Ensuite, un caractère pour le sexe, mais pas les deux suivants : -2. Les caractères restants sont lus en colonnes distinctes, d’où 1,1,1,1,1,1. Ces valeurs varieront selon les colonnes à importer.

De nombreux arguments supplémentaires peuvent être passés à read.fwf(). Plus de détails ici.

Remarque : pour charger un fichier avec des formats à la Fortran, utilisez read.fortran() :

data <- tempfile()
cat(file = data, "345678", "654321", sep = "\n")
read.fortran(data, c("F2.1","F2.0","I2"))
Propulsé par

Comme le montre cet exemple, vous fournissez en second argument les spécifications de format Fortran. Les formats possibles suivent le style : « rFl.d », « rDl.d », « rXl », « rAl » ou « rIl », où « l » est la largeur (colonnes), « d » le nombre de décimales, et « r » le nombre de répétitions. Ici, 2.1, 2.0 et 2 signifient trois colonnes de largeur 2 ; la première a une décimale, la deuxième et la troisième aucune.

Pour le type des colonnes, vous avez :

« F » et « D » pour des formats numériques ;
« A » pour des chaînes de caractères ;
« I » pour des entiers ;
Et « X » pour indiquer des colonnes à ignorer.

Ici, les deux premières colonnes sont numériques et la troisième contient des entiers.

Remarque : les codes de répétition « r » et de décimales « d » sont optionnels. La longueur « l » est requise, sauf pour « X » quand « r » est présent.

Importer vos feuilles de calcul (Google) dans R

Vous pouvez importer des feuilles de calcul dans R de multiples façons, comme expliqué dans notre tutoriel sur la lecture des fichiers Excel dans R ou dans notre premier article This R Data Import Tutorial Is Everything You Need. Allons plus loin ici, avec aussi les Google Sheets et les fichiers DIF.

Faites défiler pour découvrir comment importer vos feuilles de calcul dans R.

Importer des feuilles Excel dans R

Au-delà du package xlsx, plusieurs options existent pour lire des feuilles de calcul dans R :

1. Depuis le presse-papiers

Si votre feuille est ouverte, copiez son contenu dans le presse-papiers et importez-le rapidement dans R. Pour cela, utilisez readClipboard() ou read.table() :

readClipboard() #Only on Windows
read.table(file="clipboard")`
Propulsé par

Vous le constaterez, la première approche est pratique pour des vecteurs, mais devient vite complexe pour des tableaux. Pour en savoir plus sur read.table(), consultez la première partie ou notre tutoriel sur l’import de fichiers Excel dans R.

2. Via le package RODBC

La deuxième méthode consiste à utiliser le package RODBC :

Une première façon de l’utiliser :

library(RODBC)
connection <- odbcConnect("<DSN>")
Propulsé par

Remarque : l’argument de odbcConnect() est un DSN. Pour un guide complet (création du DSN, connexion, etc.), rendez-vous sur cette page, un tutoriel détaillé et accessible.

Une fois la connexion établie, utilisez sqlQuery() pour extraire des données de feuilles .xls :

query <- "<SQL Query>"
data <- sqlQuery(connection,
                 query)
str(data)
Propulsé par

Grand conseil : consultez ce tutoriel très complet et pédagogique.

En fin de session R, n’oubliez pas de fermer les connexions :

odbcCloseAll()
Propulsé par

Astuce : pour en savoir plus sur l’import de feuilles de calcul ou de fichiers Excel dans R, lisez notre premier tutoriel sur l’import de données dans R ou notre guide sur la lecture des fichiers Excel, qui traite entre autres de readxl et XLConnect.

Importer des Google Sheets dans R

Le package googlesheets et sa fonction gs_read() permettent de lire des feuilles Google dans R.

Commencez par exécuter :

gs_ls()
Propulsé par

Laissez le navigateur s’ouvrir et terminez l’authentification. Ensuite, pour lire ou modifier, enregistrez la feuille par son titre ou par sa clé :

data <- gs_title("<your spreadsheet>")
data <- gs_key()
Propulsé par

Puis lisez les données :

gs_read(data)
Propulsé par

Ceci n’est qu’un aperçu des possibilités de googlesheets. Pour les détails, consultez cette page, ainsi que celle-ci.

Lire des fichiers DIF (Data Interchange Format) dans R

Utilisez read.DIF() pour importer vos fichiers DIF dans R :

data <- read.DIF("<your spreadsheet>",
                 header=FALSE,
                 as.is = !stringsAsFactors)
Propulsé par

Remarque : vous pouvez indiquer si votre feuille contient un en-tête et si vous souhaitez importer les données « telles quelles », c’est-à-dire sans convertir automatiquement les chaînes en facteurs. Ici, vous ne le souhaitez pas, d’où !stringsAsFactors.

Pour plus d’informations sur cette fonction et ses arguments, rendez-vous ici.

Importer des fichiers Excel dans R

Au-delà des feuilles de calcul, vous voulez peut-être importer directement vos fichiers Excel. Voici comment procéder.

Remarque : cette section prolonge notre tutoriel sur la lecture des fichiers Excel dans R et le premier article This R Data Import Tutorial Is Everything You Need.

Importer des fichiers Excel avec `readxl`

Bien que ce package soit toujours en développement actif, il mérite votre attention : il offre une manière très simple de lire des fichiers Excel :

library(readxl)
read_excel("<path to file")
Propulsé par

Mémo : si le fichier se trouve dans votre répertoire de travail, indiquez simplement son nom avec l’extension. Pour obtenir et définir le répertoire de travail :

getwd()
setwd("<Path to your folder>")
Propulsé par

Remarque : vous pouvez préciser la feuille à lire, les noms et types de colonnes, les valeurs manquantes et le nombre de lignes à ignorer avec les arguments sheet, col_names, col_types, na et skip. Détails ici.

Lire des fichiers Excel avec `openxlsx`

Le package openxlsx permet aussi de lire simplement des fichiers .xlsx dans R :

library(openxlsx)
read.xlsx("<path to your file>")
Propulsé par

Pour plus de détails sur le package et les arguments de read.xlsx(), cliquez ici.

Astuce : pour approfondir l’import Excel dans R, voyez notre premier tutoriel sur l’import de données dans R ou notre guide détaillé sur la lecture des fichiers Excel, qui couvre également XLConnect, entre autres.

Importer des feuilles OpenDocument dans R

Utilisez read.ods() du package readODS pour lire vos feuilles OpenDocument dans R et les convertir en data frames :

library(readODS)
read.ods("<path to your file>",
         sheet = 1,
         formulaAsFormula = FALSE)
Propulsé par

Remarque : outre le fichier à importer, vous pouvez indiquer la feuille à lire et choisir d’afficher les formules comme formules (par exemple « SUM(B1:B3) ») ou leurs valeurs calculées.

Importer des fichiers JSON (JavaScript Object Notation) dans R

Dans notre premier article sur l’import de données dans R, nous avons mentionné le package rjson pour charger des fichiers JSON.

D’autres packages permettent également d’importer du JSON dans R. Voyons lesquels.

Importer du JSON avec le package `jsonlite`

Récemment classé dans le top 25 des packages R les plus téléchargés avec 66 952 téléchargements, jsonlite est un favori des utilisateurs de R.

Vous importez des fichiers JSON avec fromJSON() :

library(jsonlite)
data <- fromJSON("<Path to your JSON file>")
Propulsé par

Pour un démarrage rapide bien expliqué avec jsonlite, rendez-vous ici.

Importer du JSON avec le package `RJSONIO`

Le troisième package bien connu pour lire du JSON dans R est RJSONIO. Comme avec jsonlite, vous utilisez fromJSON() :

library(RJSONIO)
data <- fromJSON("<Path to your JSON file")
Propulsé par

Le meilleur package JSON ?

Le sujet fait débat. Pour aller plus loin, consultez :

cette page, riche en exemples de code illustrant le comportement et les performances des packages JSON dans R ;
cet article de blog, qui cherche à déterminer quel package gère le mieux le JSON dans R.

Importer des données de logiciels statistiques dans R

Si vos données ne sont pas de type tableur et ne sont ni Excel ni JSON, elles proviennent peut-être d’un logiciel statistique.

Cette section présente plusieurs méthodes pour lire des fichiers SPSS, Stata ou SAS, et un aperçu pour S-plus et Epi Info. N’hésitez pas à revenir à notre premier article ou à suivre les liens ci-dessous pour plus d’informations.

Importer des fichiers SPSS dans R

Plutôt que d’utiliser le package foreign, vous pouvez vous tourner vers haven pour lire des fichiers SPSS dans R.

Mémo : installez et chargez le package dans votre espace de travail avant de commencer.

Le package haven propose read_spss() pour lire des fichiers SPSS :

library(haven)
data <- read_spss("<path to your SPSS file>")
Propulsé par

Importer des fichiers Stata dans R

Comme foreign, le package haven fournit read_dta() pour lire des fichiers Stata dans R :

data <- read_dta("<path to your STATA file>")
Propulsé par

Mémo : installez vos packages si nécessaire et chargez-les. Par exemple, pour haven :

install.packages("haven")
library(haven)
Propulsé par

Importer des fichiers SAS dans R

Le package sas7bdat a été cité dans le précédent article ; concentrons-nous ici sur d’autres méthodes :

1. Importer des fichiers SAS XPORT avec foreign

Le package foreign et sa fonction read.xport() permettent de lire des fichiers SAS XPORT :

library(foreign)
data <- read.xport("<path to your SAS file>")
Propulsé par

2. Importer des fichiers SAS XPORT avec SASxport

Le package sasXPORT permet aussi de lire des fichiers SAS XPORT avec read.xport() :

library(SASxport)
data <- read.xport("<path to your SAS file>")
Propulsé par

3. Importer des fichiers SAS avec haven

Comme foreign et sas7bdat, le package haven permet de lire des fichiers b7dat avec read_sas() :

library(haven)
data <- read_sas("<path to your SAS file>")
Propulsé par

Importer des fichiers S-plus dans R

Pour d’anciens jeux de données S-plus (Windows 3.x, 4.x, 2000 ou Unix 3.x avec entiers 4 octets), utilisez read.S() du package foreign :

library(foreign)
data <- read.S("<Path to your file>")
Propulsé par

Lire des fichiers Epi Info dans R

Comme vu précédemment, le package foreign propose de nombreuses fonctions pour importer des formats spécifiques, dont Epi Info. Utilisez read.epiinfo() :

library(foreign)
data <- read.epiinfo("<Path to your file>")
Propulsé par

Pour plus d’informations sur Epi Info, cliquez ici.

Importer des données issues d’autres sources dans R

Au-delà des sources courantes et des logiciels statistiques, bien d’autres sources peuvent alimenter vos analyses dans R.

En voici quelques-unes. Poursuivez la lecture.

Importer des fichiers MATLAB dans R

Utilisez le package R.matlab et sa fonction readMat() pour importer des fichiers MATLAB dans R.

Le premier argument peut être une chaîne (interprétée comme un nom de fichier) ou un vecteur brut (connexion binaire) :

library(R.matlab)
data <- readMat("<Path to your file>")
Propulsé par

readMat() retourne une liste nommée contenant toutes les variables du fichier MAT importé.

Lire des fichiers Octave dans R

Le package foreign revient ici aussi. Utilisez read.octave() pour importer des données texte Octave dans R :

library(foreign)
data <- read.octave("<Path to your file>")
Propulsé par

Importer des données fitbitScraper dans R

Le package fitbitScraper permet de récupérer des données depuis fitbit.

(Pour rappel, l’entreprise propose des traqueurs d’activité et d’autres dispositifs mesurant des données personnelles comme le nombre de pas ou la qualité du sommeil.)

Un tutoriel court et pratique est disponible ici pour utiliser fitbitScraper.

Importer des données quantmod dans R

Ce package sert à extraire des données financières en ligne avec R. La fonction utilisée est getSymbols(), comme dans cet exemple :

library(quantmod)
data <- getSymbols("YHOO", src="google")
Propulsé par

Remarque : vous indiquez d’abord un vecteur de caractères avec les symboles à charger, ici "YHOO". Puis vous définissez la source. Les sources disponibles à ce jour sont yahoo, google, MySQL, FRED, csv, RData et oanda.

Ensuite, définissez les paramètres de recherche et enregistrez-les pour de futures sessions :

setSymbolLookup(YHOO='google',GOOG='yahoo')
saveSymbolLookup(file="mysymbols.rda")
Propulsé par

Les nouvelles sessions appellent alors

loadSymbolLookup(file="mysymbols.rda")
getSymbols(c("YHOO","GOOG"))
Propulsé par

Pour plus d’informations sur la finance quantitative avec R, cliquez ici ou consultez ce tutoriel détaillé pour débuter avec quantmod.

Importer des fichiers ARFF dans R

Les fichiers ARFF (Attribute-Relation File Format) de Weka se lisent avec read.arff() :

library(foreign)
data <- read.arff("<Path to your file>")
Propulsé par

Plus d’informations sur cette fonction ici.

Remarque : le package RWeka propose la même fonction pour importer des ARFF. Plus d’infos ici.

Importer des données de bases de données dans R

Outre MonetDB.R, rmongodb et RMySQL couverts précédemment, d’autres packages permettent de se connecter à vos bases dans R.

Vous avez aussi mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.

Pour des tutoriels sur ces packages, consultez :

Pour débuter avec mongolite, ce tutoriel ;
Pour RMongo, lisez cet article ;
Le package RODBC est également détaillé dans ce tutoriel. Pour une version plus courte, c’est ici ;
Pour ROracle, consultez cette présentation ;
Pour RPostgreSQL, voyez ici ou là ;
Un excellent tutoriel pour RSQLite se trouve ici ;
Enfin, pour se connecter à SQL Server avec RJDBC, lisez cet article, et pour Oracle avec RJDBC, cette page. Remarque : cette dernière page propose aussi d’autres options pour Oracle.

Remarque : le package d’interface base de données DBI permet la communication entre R et les SGBDR. Plus d’infos ici.

Des explications sur l’usage de ce package sont disponibles ici.

Importer des fichiers binaires dans R

Les fichiers binaires stockent l’information sous forme de bits (0/1). Huit bits forment un octet. Pour lire des données binaires, utilisez readBin() :

connection <- file("<path to your file>", "rb") #You open the connection as "reading binary"(rb)
data <- readBin(connection,
                what="numeric") #Mode of the vector to be read
Propulsé par

Pour un exemple détaillé, consultez cette page. Pour la documentation de readBin(), cliquez ici.

Lire des formats binaires dans R

Les packages hdf5, h5r, rhdf5, RNetCDF, ncdf et ncdf4 proposent des interfaces vers les formats HDF5 (NASA) et netCDF (UCAR).

Pour des tutoriels sur HDF5 ou netCDF dans R, consultez :

Un excellent exemple d’utilisation des fichiers HDF dans R, avec le package pathfinder, est proposé ici ;
Un tutoriel accessible pour débuter avec netCDF dans R est disponible sur cette page.

Importer vos fichiers DBF dans R

Un fichier DBF (DataBase File) est le format sous-jacent de dBase. Lisez des DBF avec le package foreign, via read.dbf() :

library(foreign)
data <- read.dbf("<Path to your file>")
Propulsé par

Remarque : sous Windows, vous pouvez aussi utiliser RODBC avec odbcConnectDbase() pour lire des DBF via le pilote ODBC dBase de Microsoft.

Importer des tables de contingence « plates » dans R

Le package foreign sait lire de nombreux formats ; les tables de contingence « plates » en font partie. Utilisez read.ftable() :

library(foreign)
data <- read.ftable("<Path to your file>")
Propulsé par

Mémo : les tables de contingence « plates » sont proches des tables « classiques » (effectifs de chaque combinaison de niveaux de facteurs), mais réorganisées en matrice dont lignes et colonnes correspondent aux combinaisons uniques des niveaux des variables de ligne et de colonne. Elles sont souvent préférées pour représenter des tables de contingence de dimension plus élevée.

Lire des fichiers SIG (systèmes d’information géographique) dans R

Utilisez notamment les packages rgdal et raster pour importer des fichiers SIG dans R.

Si vous ne savez pas par où commencer avec rgdal, lisez cet article d’introduction aux données géospatiales dans R.

Consultez aussi ce tutoriel, qui utilise à la fois rgdal et raster.

Importer des tables ITIS (Integrated Taxonomical Information) dans R

Importez des tables ITIS avec read.table() :

data <- read.table("<Path to your file>")
Propulsé par

Pour plus d’informations sur ITIS, cliquez ici.

Importer des jeux de données volumineux dans R

L’import de gros volumes de données suscite souvent des discussions chez les utilisateurs de R. Outre les packages de connexion aux bases, d’autres se distinguent pour le big data.

Importer des gros volumes avec le package `data.table`

Décrit comme le « fast and friendly file finagler », le très populaire data.table est à la fois puissant et simple. Sa fonction fread() importe des fichiers délimités réguliers directement dans R, sans détours.

Remarque : « régulier » signifie que chaque ligne comporte le même nombre de colonnes. Exemple :

  V1 V2 V3
1  1  6  a
2  2  7  b
3  3  8  c
4  4  9  d
5  5 10  e
Propulsé par

Parmi ses atouts, la détection automatique des paramètres comme sep, colClasses et nrows. Les types bit64::integer64 sont aussi détectés et lus directement sans conversion préalable en caractères.

Mémo : les bit64::integer64 sont des entiers 64 bits (par défaut, 32 bits). La détection garantit une lecture en tant que nombres, sans passage par des chaînes.

Exemple d’utilisation de fread() :

library(data.table)
data <- fread("http://assets.datacamp.com/blog_assets/chol.txt")
data
Propulsé par

##      AGE HEIGHT WEIGHT CHOL  SMOKE BLOOD  MORT
##   1:  20    176     77  195 nonsmo     b alive
##   2:  53    167     56  250 sigare     o  dead
##   3:  44    170     80  304 sigare     a  dead
##   4:  37    173     89  178 nonsmo     o alive
##   5:  26    170     71  206 sigare     o alive
##  ---
## 196:  35    174     57  222   pipe     a alive
## 197:  38    172     91  227 nonsmo     b alive
## 198:  26    170     60  167 sigare     a alive
## 199:  39    165     74  259 sigare     o alive
## 200:  49    178     81  275   pipe     b alive
Propulsé par

Remarque : la lecture via fread() renvoie un data.table :

str(data)
Propulsé par

## Classes 'data.table' and 'data.frame':   200 obs. of  7 variables:
##  $ AGE   : int  20 53 44 37 26 41 39 28 33 39 ...
##  $ HEIGHT: int  176 167 170 173 170 165 174 171 180 166 ...
##  $ WEIGHT: int  77 56 80 89 71 62 75 68 100 74 ...
##  $ CHOL  : int  195 250 304 178 206 284 232 152 209 150 ...
##  $ SMOKE : chr  "nonsmo" "sigare" "sigare" "nonsmo" ...
##  $ BLOOD : chr  "b" "o" "a" "o" ...
##  $ MORT  : chr  "alive" "dead" "dead" "alive" ...
##  - attr(*, ".internal.selfref")=<externalptr>
Propulsé par

Ce qui diffère de read.table(), qui crée un data frame.

Les différences entre data frames et data.tables sont détaillées ici. En bref, tous les data.tables sont aussi des data.frames et peuvent être utilisés par les packages attendant des data.frames, y compris avec la syntaxe [.data.frame. En savoir plus sur data.table ici.

library(data.table)
data <- fread("http://assets.datacamp.com/blog_assets/chol.txt",
              sep=auto,
              nrows = -1,
              na.strings = c("NA","N/A",""),
              stringsAsFactors=FALSE
              )
Propulsé par

Remarque : l’entrée peut être un fichier local et pas nécessairement une URL. Notez aussi combien d’arguments sont similaires à ceux de read.table().

Astuce : envie d’en savoir plus sur data.table ? Notre cours Data Analysis In R, The data.table Way pourrait vous intéresser. Guidé par Matt Dowle et Arun Srinivasan, vous passerez rapidement de novice à expert.

Importer des gros volumes avec le package `ff`

Le package ff permet un « stockage économe en mémoire de grandes données sur disque et un accès rapide ». C’est une solution souvent citée lorsque l’on traite de gros fichiers au format data frame, comme ici.

Pour importer des fichiers plats séparés dans des ff data frames, utilisez read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() ou read.delim2.ffdf(), à l’image de read.table() et ses variantes, décrits dans un précédent article :

bigdata <- read.table.ffdf(file="<Path to file>",
                           nrows=n)
Propulsé par

Remarque : le premier argument peut être NULL (comme ici) ou un objet ffdf auquel les enregistrements lus sont ajoutés. Plus d’infos ici. Ensuite, vous nommez le fichier via l’argument file. Vous pouvez aussi spécifier un nombre maximal de lignes à lire avec nrows (comme avec read.table()).

Vous pouvez aller plus loin et préciser l’encodage, les niveaux, ou la fonction appelée pour chaque bloc :

library(ff)
bigdata <- read.table.ffdf(file="<Path to file>",
                           nrows=n,
                           fileEncoding="",
                           levels=NULL,
                           FUN="read.table")
Propulsé par

Astuce : d’autres arguments pour read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() ou read.delim2.ffdf() sont listés ici.

Importer des gros volumes avec `bigmemory`

Autre package souvent cité pour les grands jeux de données : bigmemory, qui permet de « gérer des matrices massives avec mémoire partagée et fichiers mappés en mémoire ».

Remarque : ce package n’est pas utilisable sous Windows : pas de binaire Windows disponible.

library(bigmemory)
bigdata <- read.big.matrix(filename="<File name>",
                           sep="",
                           header=TRUE,
                           skip=2)
Propulsé par

Comme d’habitude, vous passez le nom de fichier, puis vous précisez le séparateur, la présence d’un en-tête et le nombre de lignes à ignorer via sep, header et skip.

Remarque : ce ne sont que quelques exemples. De nombreux autres arguments sont disponibles dans la documentation de read.big.matrix().

Lire des gros volumes avec le package `sqldf`

Le package sqldf est aussi à considérer avec de gros jeux de données. Il permet « d’exécuter des requêtes SQL sur R », et sa fonction read.csv.sql() est très pratique pour lire un fichier dans R en filtrant via une requête SQL : seule une portion des données est alors traitée par R.

library(sqldf)
bigdata <- read.csv.sql(file="<Path to your file>",
                        sql="select * from file where ...",
                        colClasses=c("character",
                                     rep("numeric",10)))
Propulsé par

Remarque : l’exemple ressemble aux autres fonctions d’import pour gros volumes, à ceci près que le second argument de read.csv.sql() est une requête SQL. Les tables mentionnées dans la requête proviennent du fichier indiqué dans file.

Astuce : pour en savoir plus sur sqldf, regardez ce tutoriel vidéo ou cet aperçu écrit des bases.

Importer de gros volumes avec la fonction `read.table()`

Vous pouvez utiliser la fonction « standard » read.table(), mais elle sera généralement plus lente que des packages conçus pour le big data. Pour un rappel sur read.table(), revenez à notre premier article.

Pour l’accélérer, vous pouvez l’« optimiser » en ajoutant des arguments, par exemple :

df <- read.table("<Path to your file>",
                 header = FALSE,
                 sep="",
                 quote = "",
                 na.strings = "EMPTY",
                 colClasses = c("character", "numeric", "factor"),
                 strip.white = TRUE,
                 comment.char="",
                 stringsAsFactors = FALSE,
                 nrows = n
                 )
Propulsé par

Remarque :

vous passez d’abord le fichier (ou son chemin), selon votre répertoire de travail ;
header indique si la première ligne contient les noms de variables (ici, non) ;
le séparateur de champs est / via sep ;
quote="" désactive la gestion des guillemets ;
la chaîne « EMPTY » est interprétée comme NA ;
colClasses définit les classes des colonnes : caractère, numérique, facteur ;
avec strip.white, on supprime les espaces en tête/fin dans les champs texte (applicable si sep est utilisé) ;
comment.char="" désactive l’interprétation des commentaires ;
vous ne voulez pas convertir les chaînes en facteurs, d’où stringsAsFactors = FALSE (et la redondance avec colClasses renforce le contrôle).
Astuce : avec colClasses et comment.char, c’est l’un des arguments clés pour un import fluide.
enfin, vous fixez un nombre maximal de lignes à lire.

Astuce : pour la liste complète des arguments de read.table(), voyez notre article sur la lecture des fichiers Excel dans R.

Importer de gros volumes avec le package `readr`

Un package plus rapide pour importer de grands fichiers tabulaires est readr, qui lit des données texte tabulaires comme read.table, mais avec « un ensemble de fonctions de remplacement plus riches et plus rapides » (voir ici).

df <- read_table("<Path to your file>",
                 col_names=TRUE)
Propulsé par

Remarque : readr propose aussi read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() et bien d’autres, plus rapides que leurs équivalents d’origine. Détails ici.

Astuce : plus d’infos sur cette page GitHub.

Quelques remarques sur la gestion du big data dans R

Pour d’autres conseils, consultez cette discussion StackOverflow, qui évoque des packages mais aussi des astuces comme le stockage en formats binaires, l’usage de saveRDS/readRDS ou le package rhdf5 pour HDF5.

Remarque : ce dernier format est présenté plus haut et de nombreux autres packages existent en plus de ceux listés. Par exemple, les packages de connexion aux bases (RODBC, MonetDB.R, etc.) facilitent aussi la gestion de jeux volumineux, et dplyr est précieux pour travailler directement avec des données stockées dans plusieurs types de base.

Astuce : envie de manipuler des données dans R ? Découvrez notre cours interactif sur dplyr avec Garrett Grolemund pour apprendre à mener des manipulations avancées avec dplyr.

Ne manquez pas non plus cet article, qui compare les performances de chargement de plusieurs packages listés ci-dessus.

Importer vos données dans R avec le package `rio`

Ce « couteau suisse de l’Input/Output » simplifie grandement l’entrée et la sortie de données dans R. Vous pouvez importer/exporter presque n’importe quel format. En installant rio, vous regroupez de nombreux packages de lecture en un seul. Pour importer ou exporter, retenez deux fonctions : import() et export(). rio s’appuie sur les packages spécialisés pour déduire la structure depuis l’extension, lire nativement des sources web et définir des valeurs par défaut pertinentes.

En bref, rio gère un large éventail de formats courants en import comme en export.

Importer vos fichiers avec rio se fait ainsi :

library(rio)
data <- import("<Path to your file>")
Propulsé par

Pour la liste complète des formats pris en charge par rio, consultez cette page.

Pour conclure

Si vous souhaitez approfondir le travail avec le big data dans R, découvrez les cours How To Work With Quandl in R et Big Data Analysis With Revolution R Enterprise sur DataCamp.

Sujets

R Science des données