Ga naar hoofdinhoud

Gegevens importeren in R - Deel twee

Een tutorial over het importeren van data in R. De focus ligt op het inlezen van data uit bronnen zoals statistische software, databases, webscraping en meer.
· 15 min lezen

Verken met AI

In deze vervolgtutorial op This R Data Import Tutorial Is Everything You Need-Part One gaat DataCamp verder met een uitgebreide maar toegankelijke gids om snel data in R te importeren, van eenvoudige platte tekstbestanden tot de meer geavanceerde SPSS- en SAS-bestanden.

Zoals veel van onze lezers terecht opmerkten bij de eerste post, hebben enkele geweldige packages om data in R te importeren nog geen aandacht gekregen, en maakte de post ook niet expliciet het onderscheid tussen werken met standaard datasets en grote datasets. Daarom ligt daar vandaag de focus op.

Lees verder om andere en nieuwe manieren te ontdekken om jouw specifieke bestand in R te importeren, en voel je vrij om contact op te nemen als je extra vragen hebt of een fout ziet die we moeten corrigeren.

(Probeer deze interactieve cursus: Importing Data in R (Part 1), om met CSV- en Excel-bestanden in R te werken.)

Data uit veelvoorkomende bronnen naar R halen

Allereerst gaat deze post dieper in op manieren om data uit veelvoorkomende bronnen, vaak spreadsheet-achtige data, in R te krijgen. Net als in de vorige post ligt de focus op het inlezen van data in R die anders is dan Excel of andere bestandstypes.

Vervolgens komen data uit andere bronnen zoals statistische software, databases, web scraping, enz. aan bod.

Wil je meer weten over mogelijke stappen die je moet nemen vóór je je data importeert, ga dan naar onze eerste post, die uitlegt hoe je je data en werkruimte voorbereidt voordat je je data in R haalt.

Platte bestanden inlezen in R met scan()

Naast read.table(), dat genoemd werd in de eerste post van de R-data-importtutorial, kan de functie scan() ook werken voor data die is opgeslagen in eenvoudige, door scheidingstekens afgebakende tekstbestanden. In tegenstelling tot de functie read.table() retourneert de functie scan() een lijst of een vector, niet een dataframe.

Stel dat je het volgende .txt-document hebt:

24 1991
21 1993
53 1962

Je kunt de data (die je hier kunt downloaden) inlezen met het volgende commando:

data <- scan("birth.txt")

Let op dat je bestand ook een online dataset kan zijn. In dat geval geef je gewoon de URL door als eerste argument van de functie scan().

Je kunt de data ook in een matrix inlezen:

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

Tip: wil je dit grondig doen, dan moet je mogelijk extra argumenten opgeven om de matrix precies te maken zoals jij wilt. Ga naar deze pagina voor meer informatie over de functie matrix().

Je kunt de kolommen van het invoerbestand ook in losse vectoren lezen:

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

Let op hoe je eerst het (pad naar het) bestand met extensie als argument doorgeeft (afhankelijk van of je de werkdirectory hebt gezet naar de map met je dataset) en daarna het datatype dat moet worden ingelezen, of je de eerste regel van je dataset wilt overslaan, welk teken de velden scheidt en of je een regel wilt afdrukken met het aantal ingelezen items.

Als je data ook andere datatypes kan bevatten, moet je de functie scan() een beetje bijstellen, zoals in dit voorbeeld:

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

Tip: dit kun je zelf ook! Download het hierboven gebruikte tekstbestand hier.

En daarna kun je de data ook in een data frame inlezen:

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

Tip: veel van de argumenten die de functie scan() kan aannemen, zijn dezelfde als die je bij de functie read.table() kunt gebruiken. Daarom is het altijd handig om de documentatie te checken! Ga hierheen als je meer wilt lezen over de argumenten van scan().

Onthoud dat je de werkdirectory kunt opvragen en instellen met respectievelijk de volgende commando's:

getwd()
setwd("<path to your folder>")

Fixed-width kolomdata in R krijgen met read.fwf()

Om een tabel met “fixed width formatted data” in een data frame in R te lezen, kun je de functie read.fwf() uit de package utils gebruiken.

Je gebruikt deze functie wanneer je databestand kolommen met spaties bevat, of kolommen zonder spaties ertussen.

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

Hier weet je bijvoorbeeld dat de vakwaarden altijd in de eerste 7 tekens van elke regel staan, dat de geslachtswaarden altijd op 22 staan, en dat de scores lopen van teken 25 tot 30.

Wil je proberen deze data in R te laden, dan kun je het tekstbestand eenvoudig hier downloaden.

Je zou het volgende commando moeten uitvoeren om de bovenstaande data correct in R te krijgen:

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)

Let op dat het argument widths de breedtes van de fixed-width velden aangeeft. In dit geval zijn de eerste zeven tekens in het bestand gereserveerd voor de cursusnamen; Vervolgens wil je de volgende veertien tekens niet inlezen: je geeft -14 door. Daarna heb je één teken nodig om het geslacht te representeren, maar je wilt de twee volgende tekens niet, dus geef je -2 door. Alle volgende tekens moeten in aparte kolommen worden ingelezen, dus splits je ze door 1,1,1,1,1,1 door te geven aan het argument. Deze waarden verschillen natuurlijk afhankelijk van de kolommen die je wilt importeren.

Er zijn een aantal extra argumenten die je aan de functie read.fwf() kunt doorgeven. Klik hier om daarover te lezen.

Let op dat je, als je een bestand wilt laden met Fortran-achtige formatspecificaties, de functie read.fortran() kunt gebruiken:

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

Zoals je in het kleine voorbeeld hierboven ziet, gebruik je Fortran-achtige formatspecificaties als tweede argument van de functie read.fortran(). De argumenten die je mogelijk doorgeeft, volgen de stijl: “rFl.d”, “rDl.d”, “rXl”, “rAl” of “rIl”, waarbij “l” het aantal kolommen is, “d” het aantal decimalen en “r” het aantal herhalingen. In dit geval zie je 2.1, 2.0 en 2 opgesomd via de functie c(), wat betekent dat je drie kolommen met twee rijen hebt. In de eerste kolom heb je waarden met één decimaal, in de tweede en derde kolom waarden zonder decimalen.

Wat betreft het type waarden dat de kolommen bevatten, kun je hebben:

  • “F” en “D” voor numerieke formats;
  • “A” als je tekstwaarden hebt;
  • “I” voor integerwaarden;
  • En “X” om kolommen aan te geven die kunnen worden overgeslagen.

In dit geval bevatten de eerste en tweede kolom numerieke formats, terwijl de derde kolom integerwaarden bevat.

Let op dat de herhalingscode “r” en het aantal decimalen “d” altijd optioneel zijn. De lengtecode “l” is vereist, behalve voor “X”-formats wanneer “r” aanwezig is.

Je (Google-)spreadsheets in R krijgen

Spreadsheets kunnen op verschillende manieren in R worden geïmporteerd, zoals je wellicht al hebt gelezen in onze tutorial over Excel-bestanden lezen en importeren in R of onze eerste post This R Data Import Tutorial Is Everything You Need. Deze sectie bouwt daarop voort en gaat nog verder, inclusief Google Spreadsheets en DIF-bestanden!

Scroll verder om meer te weten te komen over het importeren van je spreadsheets in R.

Excel-spreadsheets importeren in R

Naast de package xlsx heb je nog een aantal andere opties om spreadsheets in R in te lezen:

1. Excel-spreadsheets in R lezen via het klembord

Als je een spreadsheet open hebt, kun je de inhoud kopiëren naar je klembord en snel in R importeren. Hiervoor kun je de functies readClipboard() of read.table() gebruiken:

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

Zoals je zult zien als je dit probeert, werkt de eerste aanpak goed voor vectordata, maar wordt het vrij ingewikkeld als je tabeldata in je klembord hebt. Wil je meer weten over read.table(), ga dan zeker naar het eerste deel van de R-data-importtutorial of onze tutorial over Excel-bestanden lezen en importeren in R.

2. Excel-spreadsheets in R lezen via de RODBC-package

De tweede manier om je Excel-spreadsheets in R te krijgen, is via de package RODBC:

  • Een eerste manier om deze package te gebruiken is als volgt:
library(RODBC)
connection <- odbcConnect("<DSN>")

Let op dat het argument dat je aan odbcConnect() doorgeeft, eigenlijk een DSN is. Voor een volledige gids over het instellen van je DSN, het opzetten van een connectie, enz., ga naar deze pagina met een uitgebreide maar toegankelijke tutorial!

  • Als je je connectie hebt opgezet, kun je ook de functie sqlQuery() gebruiken om data uit .xls-spreadsheets te halen:
query <- "<SQL Query>"
data <- sqlQuery(connection,
                 query)
str(data)

Grote tip: ga naar deze pagina met een uitgebreide maar toegankelijke tutorial!

Vergeet aan het einde van een R-sessie niet om de connecties te sluiten:

odbcCloseAll()

Tip: Wil je meer weten over het importeren van spreadsheets of Excel-bestanden in R, ga dan zeker naar onze eerste tutorial over data importeren in R of lees onze tutorial over Excel-bestanden lezen en importeren in R, waarin onder andere de packages readxl en XLConnect aan bod komen.

Google Spreadsheets importeren in R

De package googlesheets met de functie gs_read() laat je Google Spreadsheets in R inlezen.

Begin met het uitvoeren van de volgende regel code:

gs_ls()

Laat de browser opstarten en voltooi het authenticatieproces. Als je daarna de data wilt lezen of bewerken, moet je deze registreren. Dat kan door je spreadsheet te specificeren op titel of op key:

data <- gs_title("<your spreadsheet>")
data <- gs_key()

Vervolgens kun je de data inlezen:

gs_read(data)

Dit is slechts een kort overzicht van wat je met de package googlesheets kunt doen. Lees zeker alle details hier, en bekijk ook deze pagina.

Data Interchange Format (DIF)-bestanden in R inlezen

Gebruik de functie read.DIF() om je DIF-bestanden in R te krijgen:

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

Let op dat je kunt aangeven of je spreadsheet een header heeft of niet en of je de data “as is” wilt importeren, dus of je tekstvariabelen wilt omzetten naar factoren. In dit geval wilde je dat niet, dus gaf je !stringsAsFactors op.

Voor meer informatie over deze functie of de argumenten, ga naar deze pagina.

Excel-bestanden in R krijgen

Naast spreadsheets ben je misschien ook geïnteresseerd in het inlezen van je daadwerkelijke Excel-bestanden in R. Lees verder om te zien hoe je dat doet!

Let op dat deze post slechts verder ingaat op wat is beschreven in onze tutorial over Excel-bestanden lezen en importeren in R en onze eerste post This R Data Import Tutorial Is Everything You Need!

Excel-bestanden importeren in R met readxl

Hoewel deze package nog actief in ontwikkeling is, is het echt de moeite waard om te bekijken, omdat het je een vrij eenvoudige manier biedt om Excel-bestanden in te lezen:

library(readxl)
read_excel("<path to file")

Onthoud dat je gewoon de bestandsnaam met extensie kunt typen als je map in je werkdirectory staat. Haal en zet je werkdirectory met de volgende regels code:

getwd()
setwd("<Path to your folder>")

Let op dat je met de argumenten sheet, col_names, col_types, na en skip respectievelijk het tabblad, de kolomnamen en -types, de missende waarden en het aantal over te slaan rijen vóór het inlezen kunt opgeven. Lees hierover meer hier.

Excel-bestanden inlezen in R met openxlsx

De package openxlsx biedt je ook een eenvoudige manier om Excel-.xlsx-bestanden in R in te lezen:

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

Wil je meer details over deze package of de argumenten die je aan de functie read.xlsx() kunt doorgeven, klik dan zeker hier.

Tip: Wil je meer weten over het importeren van Excel-bestanden in R, ga dan zeker naar onze eerste tutorial over “data importeren in R” of lees onze uitgebreide tutorial over Excel-bestanden lezen en importeren in R, waarin onder andere de package XLConnect wordt behandeld.

OpenDocument-spreadsheets in R krijgen

Gebruik de functie read.ods() uit de package readODS om je OpenDocument-spreadsheets in R in te lezen en in data frames te plaatsen:

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

Let op dat je, naast het bestand dat je in R wilt krijgen, het tabblad kunt specificeren en de mogelijkheid hebt om formules als formules weer te geven (bijvoorbeeld “SUM(B1:B3)”) of de resulterende waarden.

JavaScript Object Notation (JSON)-bestanden importeren in R

In onze eerste post over data importeren in R werd de package rjson genoemd om JSON-bestanden in R te krijgen.

Er zijn echter ook andere packages die je kunt gebruiken om JSON-bestanden in R te importeren. Lees verder om meer te ontdekken!

JSON-bestanden importeren in R met de package jsonlite

Onlangs in de top 25 van meest gedownloade R-packages gerankt met 66.952 downloads, is de package jsonlite zeker een favoriet onder R-gebruikers.

Je importeert JSON-bestanden met de functie fromJSON():

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

Voor een duidelijke quickstart met de package jsonlite, ga hierheen.

JSON-bestanden importeren in R met de package RJSONIO

De derde, bekende package om JSON-bestanden in R te krijgen is RJSONIO. Net als bij de packages jsonlite en jsonlite gebruik je de functie fromJSON():

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

De beste JSON-package?

Over dit onderwerp is flink gediscussieerd. Wil je meer weten, bekijk dan zeker de volgende pagina's en posts:

  • deze pagina biedt vooral illustraties via codevoorbeelden die je meer inzicht geven in het gedrag en de performance van JSON-packages in R.
  • Lees zeker deze blogpost, die probeert te achterhalen welke package JSON-data het best afhandelt in R.

Data uit statistische software in R krijgen

Als je data niet echt spreadsheet-achtig is en geen Excel- of JSON-bestand is, is het misschien wel gemaakt met een van de vele statistische softwarepakketten.

Deze sectie geeft je meer manieren om je SPSS-, Stata- of SAS-bestanden in te lezen, en geeft ook een overzicht van het importeren van bestanden uit S-plus en Epi Info. Ga zeker terug naar onze eerste post of naar de links hieronder als je meer informatie wilt!

SPSS-bestanden importeren in R

In plaats van de package foreign te gebruiken, kun je ook terecht bij de package haven om je SPSS-bestanden in R te krijgen.

Onthoud dat je de package moet installeren en activeren in je werkruimte voordat je begint!

De package haven biedt de functie read_spss() om SPSS-bestanden in R te lezen:

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

Stata-bestanden importeren in R

Net als de package foreign biedt de package haven ook een functie om Stata-bestanden in R te lezen, namelijk read_dta():

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

Onthoud altijd je packages te installeren indien nodig en te activeren in je werkruimte. Je kunt bijvoorbeeld de package haven installeren en activeren met de volgende commando's:

install.packages("haven")
library(haven)

SAS-bestanden importeren in R

Aangezien de package sas7bdat in de vorige post werd genoemd, richt deze vervolgtutorial zich op andere manieren om SAS-bestanden in te lezen:

1. SAS XPORT-bestanden importeren in R met de package foreign

De package foreign met de functie read.xport() stelt je ook in staat om je SAS XPORT-bestanden in R te krijgen:

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

2. SAS XPORT-bestanden importeren in R met de package SASxport

De package sasXPORT laat ook SAS XPORT-bestanden inlezen met de functie read.xport():

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

3. SAS-bestanden importeren in R met de package haven

Net als de packages foreign en sas7bdat laat de package haven je ook b7dat-bestanden inlezen in R met de functie read_sas():

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

S-plus-bestanden in R krijgen

Voor oude S-plus-datasets, namelijk die zijn geproduceerd op Windows-versies 3.x, 4.x of 2000 of Unix, versie 3.x met 4-byte integers, kun je de functie read.S() uit de package foreign gebruiken:

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

Epi Info-bestanden in R inlezen

Zoals je in onze vorige tutorial of in deze hebt gelezen, biedt de package foreign veel functies om specifieke bestanden in R te lezen, en Epi Info is daar één van. Je kunt de functie read.epiinfo() gebruiken om je data in R te krijgen:

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

Voor meer informatie over Epi Info, klik hier.

Data uit andere bronnen in R krijgen

Naast de veelvoorkomende bronnen en de statistische software zijn er ook veel andere bronnen waarvan je data wilt inlezen in R.

Een paar staan hieronder. Lees verder!

MATLAB-bestanden importeren in R

Je kunt de package R.matlab met de functie readMat() gebruiken om MATLAB-bestanden in R te importeren.

Je kunt als eerste argument ofwel een tekenreeks doorgeven aan deze functie, ofwel een raw vector. In het eerste geval wordt je invoer geïnterpreteerd als een bestandsnaam, in het tweede geval als een ruwe binaire connectie:

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

De functie readMat() retourneert een benoemde lijststructuur die alle variabelen bevat uit het MAT-bestand dat je hebt geïmporteerd.

Octave-bestanden in R inlezen

De package foreign is er weer! Gebruik de functie read.octave() om Octave-tekstdata in R te importeren:

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

FitbitScraper-data in R krijgen

Je kunt de package fitbitScraper gebruiken om data van fitbit te krijgen.

(Voor wie niet bekend is met het bedrijf: het bedrijf biedt producten zoals activity trackers en andere technologische apparaten die persoonlijke data meten, zoals het aantal gezette stappen of de kwaliteit van slaap.)

Ga hierheen voor een korte en praktische tutorial over het gebruik van de package fitbitScraper.

Quantmod-data importeren in R

Je kunt deze package gebruiken om financiële data uit een internetbron te halen met R. De functie die je gebruikt om je data in R te krijgen is getSymbols(), zoals in dit voorbeeld:

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

Let op dat je eerst een tekenvector specificeert met de namen van elk symbool dat moet worden geladen. In dit geval is dat "YHOO". Vervolgens definieer je een sourcingmethode. De sourcingmethoden die op dit moment beschikbaar zijn, zijn yahoo, google, MySQL, FRED, csv, RData en oanda.

Vervolgens specificeer je de opzoekparameters en sla je ze op voor toekomstige sessies:

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

De nieuwe sessies roepen dan aan

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

Wil je meer informatie over kwantitatieve finance-toepassingen in R, klik hier of ga naar deze pagina voor een gedetailleerde tutorial voor beginners over werken met quantmod.

ARFF-bestanden in R krijgen

Data uit Weka Attribute-Relation File Format (ARFF)-bestanden kan worden ingelezen met de functie read.arff():

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

Voor meer informatie over deze functie, ga naar deze pagina.

Let op dat de package RWeka dezelfde functie biedt om ARFF-bestanden te importeren. Ga hierheen als je meer wilt weten!

Data uit databases importeren in R

Naast MonetDB.R, rmongodb en RMySQL, die in de vorige post aan bod kwamen, heb je ook andere packages om met je databases te verbinden in R.

je hebt ook mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.

Voor tutorials over deze packages, bekijk de volgende lijst:

Let op dat er ook een database-interfacepackage DBI is dat communicatie tussen R en relationele databasebeheersystemen mogelijk maakt. Voor meer informatie, klik hier.

Uitleg over hoe je met deze package werkt, vind je hier.

Binaire bestanden in R krijgen

Binaire databestanden bevatten informatie die is opgeslagen in groepen binaire cijfers. Elk binair cijfer is een nul of één. Acht binaire cijfers die samen gegroepeerd zijn, vormen een byte. Je kunt binaire data inlezen met de functie 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

Voor een uitgebreider voorbeeld, ga naar deze pagina. Voor meer informatie over de functie readBin(), klik hier.

Binaire dataformaten in R inlezen

De packages hdf5, h5r, rhdf5, RNetCDF, ncdf en ncdf4 bieden interfaces naar NASA's HDF5 en UCAR's netCDF-databestanden.

Voor wie geïnteresseerd is in tutorials over werken met HDF5- of netCDF-bestanden in R, bekijk de volgende bronnen:

  • Je vindt een uitstekende tutorial over werken met HDF-bestanden in R, ook met de pathfinder-package, hier;
  • Een toegankelijke tutorial voor beginners over netCDF in R vind je op deze pagina.

Je DBF-bestanden in R krijgen

Een DBF of DataBase File is het onderliggende formaat van dBase. Je kunt DBF-bestanden inlezen met de package foreign, die de functie read.dbf() biedt:

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

Let op dat je op Windows ook de package RODBC met de functie odbcConnectDbase() kunt gebruiken om DBF-bestanden te lezen via Microsoft's dBase ODBC-driver.

Platte kruistabellen importeren in R

De package foreign laat je meerdere bestandsformaten lezen; 'Platte' kruistabellen zijn geen uitzondering. Je kunt de functie read.ftable() gebruiken om dit te doen:

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

Onthoud dat “platte” kruistabellen sterk lijken op de “normale” kruistabellen: ze bevatten
de tellingen van elke combinatie van de niveaus van de betrokken variabelen (factoren). Deze informatie is echter herschikt als een matrix waarvan de rijen en kolommen overeenkomen met de unieke combinaties van de niveaus van de rij- en kolomvariabelen. “Platte” kruistabellen worden daarom vaak verkozen om hogere-dimensionale kruistabellen te representeren.

Geografische informatiesysteem (GIS)-bestanden in R inlezen

Je kunt de packages rgdal en raster, onder andere, gebruiken om je GIS-bestanden in R te krijgen.

Weet je niet goed hoe je met de package rgdal moet beginnen, bekijk dan deze leuke blogpost, die je introduceert in het werken met georuimtelijke data in R.

Je kunt ook deze tutorial bekijken, die werkt met zowel rgdal als raster.

Integrated Taxonomical Information (ITIS)-tabellen importeren in R

Je kunt ITIS-tabellen importeren met de functie read.table():

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

Voor meer informatie over ITIS, klik hier.

Grote datasets importeren in R

Het importeren van grote datasets zorgt vaak voor discussie onder R-gebruikers. Naast de packages die bedoeld zijn om met databases te verbinden, zijn er ook andere die opvallen bij het werken met big data.

Grote datasets importeren in R met de package data.table

Omschreven als de “fast and friendly file finagler”, is de populaire package data.table extreem nuttig en gemakkelijk te gebruiken. De functie fread() is bedoeld om data uit reguliere door scheidingstekens afgebakende bestanden direct in R te importeren, zonder omwegen of gedoe.

Let op dat “regulier” in dit geval betekent dat elke rij van je data hetzelfde aantal kolommen moet hebben. Een voorbeeld:

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

Een van de fijne dingen aan deze functie is dat alle instellingen, uitgedrukt in argumenten zoals sep, colClasses en nrows, automatisch worden gedetecteerd. Ook bit64::integer64-types worden gedetecteerd en direct ingelezen zonder eerst als tekst te hoeven lezen en dan te converteren.

Onthoud dat bit64::integer64-types 64-bits integers zijn: deze getallen worden in de computer als 64 bits lang opgeslagen. Standaard zijn dit slechts 32 bits. Doordat de bit64::integer64-types worden gedetecteerd, weet het systeem dat het om een getal gaat en wordt het niet als tekst ingelezen om daarna naar een integer te converteren.

Een voorbeeld van de functie fread() is:

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

##      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

Let op dat het inlezen van je data met de functie fread() je een data table teruggeeft:

str(data)

## 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>

Dit is anders dan read.table(), dat een data frame van je data maakt.

Je kunt meer over de verschillen tussen data frames en data tables vinden hier. Kort gezegd is het belangrijkste om te weten dat alle data.tables ook data.frames zijn: data.tables zijn óók data.frames. Een data.table kan aan elke package worden doorgegeven die alleen een data.frame accepteert en die package kan de [.data.frame-syntax op de data.table gebruiken. Lees meer over data.table hier.

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
              )

Let op dat de input ook een bestand kan zijn dat je wilt inlezen en niet altijd een URL hoeft te zijn. Let ook op hoe veel van de argumenten hetzelfde zijn als die je bijvoorbeeld in read.table() gebruikt.

Tip: meer weten over data.table? Misschien is onze cursus Data Analysis In R, The data.table Way iets voor jou! Met de begeleiding van Matt Dowle en Arun Srinivasan groei je razendsnel van beginner tot expert in data.table.

Grote datasets in R krijgen met de package ff

De package ff biedt “geheugenefficiënte opslag van grote data op schijf en snelle toegang”. Het is een van de oplossingen die vaak naar voren komt wanneer je discussies bekijkt over het inlezen van big data als data frames, zoals hier.

Als je gescheiden platte bestanden wilt importeren in ff-dataframes, kun je de functies read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() of read.delim2.ffdf() gebruiken, net als de functie read.table() en diens varianten of convenience-wrappers, die in een van onze vorige posts zijn beschreven:

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

Let op dat je eerste argument NULL kan zijn (zoals in dit geval) of een optioneel ffdf-object kan aanduiden waarnaar de ingelezen records worden toegevoegd. Wil je meer weten, ga dan hierheen. Vervolgens noem je met het argument file het bestand waaruit de data gelezen wordt. Je kunt ook een maximum aantal rijen aangeven met nrows (wat hetzelfde is als bij read.table()!).

Je kunt nog verder gaan en de bestandscodering, de levels of de naam van een functie die wordt aangeroepen voor het lezen van elke chunk, specificeren:

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

Tip meer argumenten die je kunt toevoegen aan de functies read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() of read.delim2.ffdf() vind je hier.

Grote datasets importeren in R met bigmemory

Een andere package die vaak opduikt in de zoekresultaten voor vragen rond grote datasets in R is de package bigmemory. Deze package laat je “enorme matrices beheren met gedeeld geheugen en memory-mapped files”.

Let op dat je deze package niet op Windows kunt gebruiken: er zijn geen Windows-binaries beschikbaar.

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

Zoals gebruikelijk geef je eerst de bestandsnaam aan de functie, en kun je daarna andere zaken specificeren, zoals het scheidingsteken, de header of het aantal regels dat je wilt overslaan voordat je begint in te lezen met respectievelijk de argumenten sep, header en skip.

Let op dat dit slechts enkele voorbeelden zijn! Je kunt veel meer argumenten doorgeven aan de functie read.big.matrix()! Lees de documentatie als je meer wilt weten.

Grote datasets inlezen in R met de package sqldf

De package sqldf is ook een van de packages die je kunt overwegen wanneer je met grote datasets werkt. Deze package laat je “SQL-selects uitvoeren op R”, en vooral de functie read.csv.sql() is erg handig als je een bestand in R wilt lezen en het wilt filteren met een SQL-statement. Dan wordt slechts een deel van de data door R verwerkt:

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

Let op dat het bovenstaande voorbeeld sterk lijkt op andere functies die je toelaten om grote datasets in R te importeren, met als enig verschil dat het tweede argument dat je aan de functie read.csv.sql() doorgeeft, een SQL-statement is. De tabellen waarnaar je in je SQL-query verwijst, maken deel uit van het bestand dat je noemt in het argument file van read.csv.sql().

Tip: voor meer informatie over werken met sqldf, kun je hier een videotutorial bekijken of hier een geschreven overzicht van de basis.

Grote datasets importeren in R met de functie read.table()

Je kunt de “standaard”-functie read.table() gebruiken om je data te importeren, maar dit zal waarschijnlijk meer tijd kosten dan andere packages die speciaal ontworpen zijn om beter met grotere datasets te werken. Ga terug naar onze eerste post om te zien hoe de functie read.table() werkt.

Om deze functie iets sneller te maken, kun je haar zelf tweaken tot een geoptimaliseerde functie read.table(). Dit tweaken bestaat in feite alleen uit het toevoegen van argumenten aan de gebruikelijke functie read.table(), zo:

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
                 )

Let op dat

  • je eerst het (pad naar je) bestand doorgeeft, afhankelijk van of je je werkdirectory hebt gezet naar de map waarin het bestand zich bevindt.
  • Je vervolgens met het argument header aangeeft of het bestand de namen van de variabelen als eerste regel bevat. Dat is in het bovenstaande voorbeeld niet het geval.
  • Het veldscheidingsteken als / is ingesteld met het argument sep; Dit betekent dat de waarden op elke regel van het bestand door dit teken worden gescheiden.
  • Vervolgens kun je ook kiezen om quoten uit of aan te zetten. In dit geval schakel je quoten uit, aangezien quote="".
  • Je definieert ook dat de string “EMPTY” in je dataset moet worden geïnterpreteerd als een NA-waarde.
  • Daarna definieer je de klassen van je kolommen: in dit geval geef je aan dat de eerste kolom een tekstkolom is, de tweede een numerieke en de laatste een factor.
  • Met strip.white sta je toe dat leidende en volgende spaties uit ongequoteerde tekstvelden worden gestript; Dit is alleen van toepassing wanneer je het argument sep hebt gebruikt!
  • Wanneer comment.char is ingesteld als "", zet je de interpretatie van commentaar uit.
  • Je wilt niet dat tekens naar factoren worden geconverteerd! Daarom heb je ook colClasses gedefinieerd. Je bevestigt dit door stringsAsFactors op FALSE te zetten.
    Tip: dit argument is, samen met colClasses en comment.char, waarschijnlijk een van de belangrijkere als je je data soepel wilt importeren!
  • Tot slot zet je een maximum aantal rijen om in te lezen.

Tip: wil je meer informatie over alle argumenten die je aan de functie read.table() kunt doorgeven, lees dan zeker onze post over Excel-bestanden lezen in R.

Grote datasets in R krijgen met de package readr

Een van de snellere packages die je kunt gebruiken om je grote dataset in R te importeren, is de package readr, die je tabulaire tekstdata laat lezen, net als read.table. Toch biedt de package readr “een aantal vervangende functies die extra functionaliteit bieden en veel sneller zijn” (zie hier).

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

Let op dat de package readr ook de functies read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() en veel andere functies biedt die sneller zijn dan de originelen! Details vind je hier.

Tip: meer informatie over deze package vind je op deze GitHub-pagina.

Enkele opmerkingen over het omgaan met big data in R

Voor verdere tips over het omgaan met big data in R kun je waarschijnlijk het beste kijken naar deze StackOverflow-discussie, die gaat over packages maar ook over tips zoals het opslaan van je data in binaire formaten en het gebruik van saveRDS/readRDS of de package rhdf5 voor het HDF5-formaat.

Let op dat dit laatste bestandsformaat hierboven is behandeld en dat er veel andere packages bestaan naast die hierboven zijn besproken. Zo kunnen de packages die worden gebruikt om met databases te verbinden, zoals RODBC en MonetDB.R, ook gemakkelijk worden gebruikt om grotere datasets te verwerken en bewijst de package dplyr ook zijn waarde wanneer je direct wilt werken met data die in verschillende types database is opgeslagen.

Tip: geïnteresseerd in data manipuleren in R? Dan is onze interactieve cursus over dplyr misschien iets voor jou! Met de begeleiding van Garrett Grolemund leer je geavanceerde datamanipulatietaken uitvoeren met dplyr.

Bekijk ook zeker deze interessante post, die de laadtijd van enkele van de hierboven genoemde packages test!

Je data in R krijgen met de package rio

Dit “Zwitserse zakmes voor data-in/uitvoer” maakt het in- en uitvoeren van data in R eenvoudiger voor je! Je kunt data uit bijna elk bestandsformaat in- of uitvoeren: wanneer je de package rio installeert, trek je veel losse data-leespakketten in één samen. Als je vervolgens data wilt in- of uitvoeren, hoef je maar twee functies te onthouden: import() en export(): rio zal vertrouwen op de afzonderlijke data-leespakketten om de datastructuur af te leiden uit de bestandsextensie, om webgebaseerde databronnen native te lezen en om redelijke standaarden voor import en export te zetten.

Kortom, rio ondersteunt een breed scala aan veelgebruikte bestandstypes voor import en export.

Je bestanden importeren met rio doe je als volgt:

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

Als je precies wilt zien welke bestandsformaten door rio worden ondersteund, bezoek dan deze pagina.

Tot slot

Als je meer wilt leren over werken met big data in R, bekijk dan zeker de cursussen How To Work With Quandl in R en “Big Data Analysis With Revolution R Enterprise” op DataCamp!

Onderwerpen

RData Science

Gerelateerd

Meer bekijken →