Daten in R importieren – Teil zwei

Im Anschluss an This R Data Import Tutorial Is Everything You Need–Part One setzt DataCamp sein umfassendes, zugleich leicht verständliches Tutorial fort, um Daten schnell in R zu importieren – von einfachen, flachen Textdateien bis hin zu fortgeschrittenen Formaten wie SPSS und SAS.

Viele Leserinnen und Leser haben im ersten Beitrag zurecht angemerkt, dass einige starke Pakete zum Datenimport in R noch keine Erwähnung gefunden haben. Zudem fehlte die klare Unterscheidung zwischen dem Arbeiten mit Standard- und sehr großen Datensätzen. Genau darauf konzentriert sich der heutige Beitrag.

Lies weiter, um weitere Wege kennenzulernen, wie du deine spezifischen Dateien in R importierst – und melde dich gern, wenn du zusätzliche Fragen hast oder einen Fehler entdeckst, den wir korrigieren sollten.

(Probier diesen interaktiven Kurs: Importing Data in R (Part 1), um in R mit CSV- und Excel-Dateien zu arbeiten.)

Daten aus gängigen Quellen in R bringen

Zunächst steigen wir tiefer in Wege ein, tabellenartige Daten aus gängigen Quellen in R zu laden. Wie im vorherigen Beitrag liegt der Fokus auf allem, was nicht Excel oder vergleichbare Dateitypen sind.

Anschließend gehen wir auf Daten aus anderen Quellen ein, etwa Statistiksoftware, Datenbanken, Webscraping usw.

Wenn du mehr über mögliche Vorbereitungsschritte vor dem Import erfahren willst, sieh dir unseren ersten Beitrag an. Dort erklären wir, wie du Daten und Arbeitsumgebung vorbereitest, bevor du in R loslegst.

Flache Dateien mit scan() in R einlesen

Neben read.table(), das im ersten Teil des Tutorials erwähnt wurde, kann auch die Funktion scan() einfache, durch Trennzeichen strukturierte Textdateien verarbeiten. Im Unterschied zu read.table() liefert scan() eine Liste oder einen Vektor zurück, nicht ein Dataframe.

Angenommen, du hast folgendes .txt-Dokument:

24 1991
21 1993
53 1962

Du kannst die Daten (Download hier) mit folgendem Befehl einlesen:

data <- scan("birth.txt")

Hinweis: Deine Datei kann auch online liegen. In dem Fall übergibst du die URL als erstes Argument an scan().

Alternativ kannst du die Daten auch direkt in eine Matrix lesen:

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

Tipp: Wenn du das sauber aufsetzen willst, solltest du zusätzliche Argumente angeben, um die Matrix exakt zu formen. Mehr Infos zur Funktion matrix() findest du hier.

Du kannst die Spalten der Eingabedatei auch als separate Vektoren einlesen:

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

Beachte, dass du zuerst die (Pfad‑)Angabe inklusive Erweiterung übergibst (abhängig davon, ob dein Arbeitsverzeichnis auf den Ordner mit dem Datensatz gesetzt ist oder nicht). Danach spezifizierst du den zu lesenden Datentyp, ob die erste Zeile übersprungen werden soll, welches Zeichen die Felder trennt und ob eine Meldung zur Anzahl gelesener Elemente ausgegeben wird.

Wenn deine Daten auch andere Typen enthalten, passt du scan() entsprechend an, zum Beispiel so:

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

Tipp: Probier es selbst aus! Lade die oben verwendete Textdatei hier herunter.

Die Daten kannst du anschließend auch als Data Frame einlesen:

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

Tipp: Viele Argumente von scan() sind identisch mit denen von read.table(). Ein Blick in die Doku lohnt sich immer! Mehr zu den Argumenten von scan() findest du hier.

Merke: Mit folgenden Befehlen liest du das aktuelle Arbeitsverzeichnis aus bzw. setzt es:

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

Fixed-Width-Daten mit read.fwf() einlesen

Um eine Tabelle mit „Fixed Width Formatted“-Daten in einen Data Frame zu laden, nutzt du die Funktion read.fwf() aus dem Paket utils.

Diese Funktion ist sinnvoll, wenn deine Datei Spalten mit festen Breiten hat – also ohne oder mit uneinheitlichen Trennzeichen.

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

Hier weißt du z. B., dass die Fachbezeichnung immer in den ersten 7 Zeichen steht, das Geschlecht bei Zeichen 22 und die Scores von Zeichen 25 bis 30.

Wenn du das Laden der Daten testen möchtest, lade die Textdatei hier herunter.

Mit folgendem Befehl liest du die Daten korrekt ein:

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)

Hinweis: Das Argument widths legt die Breite der festen Felder fest. In diesem Fall sind die ersten 7 Zeichen für die Kursnamen reserviert. Die nächsten 14 Zeichen sollen nicht eingelesen werden: -14. Danach wird 1 Zeichen für das Geschlecht benötigt, die folgenden 2 nicht: -2. Alle weiteren Zeichen werden als einzelne Spalten gelesen, daher die Aufteilung 1,1,1,1,1,1. Die genauen Werte hängen natürlich von deinen Spalten ab.

Weitere Argumente zu read.fwf() findest du hier.

Hinweis: Wenn du Dateien mit Fortran-Formatangaben laden willst, nutze read.fortran():

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

Wie du siehst, übergibst du Fortran-Formatspezifikationen als zweites Argument an read.fortran(). Mögliche Codes sind „rFl.d“, „rDl.d“, „rXl“, „rAl“ oder „rIl“, wobei „l“ die Spaltenlänge, „d“ die Dezimalstellen und „r“ die Wiederholungen angibt. Im Beispiel bedeuten 2.1, 2.0 und 2, dass drei Spalten à zwei Stellen gelesen werden, die erste mit einer Dezimalstelle, die zweite und dritte ohne.

Zu den möglichen Typen gehören:

• „F“ und „D“ für numerische Formate,
• „A“ für Zeichenwerte,
• „I“ für ganze Zahlen,
• und „X“ für zu überspringende Spalten.

In unserem Beispiel sind die ersten beiden Spalten numerisch, die dritte enthält Ganzzahlen.

Hinweis: Der Wiederholungscode „r“ und die Dezimalstellen „d“ sind optional. Die Länge „l“ ist erforderlich, außer bei „X“-Formaten, wenn „r“ gesetzt ist.

(Google-)Tabellen in R bringen

Tabellen lassen sich in R auf verschiedene Arten importieren – das hast du vielleicht schon in unserem Tutorial zum Einlesen von Excel-Dateien in R oder im ersten Beitrag This R Data Import Tutorial Is Everything You Need gelesen. Hier gehen wir weiter ins Detail und nehmen auch Google-Tabellen sowie DIF-Dateien mit!

Scroll weiter, um zu erfahren, wie du Tabellen in R importierst.

Excel-Tabellen in R importieren

Neben dem Paket xlsx gibt es weitere Optionen, Tabellen in R zu lesen:

1. Excel-Tabellen über die Zwischenablage einlesen

Wenn deine Tabelle geöffnet ist, kannst du Inhalte in die Zwischenablage kopieren und schnell in R importieren. Dafür nutzt du readClipboard() oder read.table():

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

Wie du feststellst, eignet sich die erste Variante gut für Vektordaten, wird aber bei Tabellen schnell unhandlich. Mehr zu read.table() findest du im ersten Teil oder in unserem Tutorial zum Lesen und Importieren von Excel-Dateien.

2. Excel-Tabellen mit dem RODBC-Paket einlesen

Die zweite Option ist das Paket RODBC:

• Eine erste Nutzungsmöglichkeit sieht so aus:

library(RODBC)
connection <- odbcConnect("<DSN>")

Hinweis: Das Argument von odbcConnect() ist ein DSN. Eine vollständige Anleitung zum Einrichten des DSN und der Verbindung findest du in diesem ausführlichen, leicht zugänglichen Tutorial!

• Nach dem Aufbau der Verbindung kannst du mit sqlQuery() Daten aus .xls-Tabellen ziehen:

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

Großer Tipp: Sieh dir dieses Tutorial an – ausführlich und trotzdem gut verständlich!

Am Ende der R-Session nicht vergessen, Verbindungen zu schließen:

odbcCloseAll()

Tipp: Mehr zum Import von Tabellen oder Excel-Dateien in R findest du im ersten Tutorial zum Datenimport in R oder in unserem Tutorial zum Lesen und Importieren von Excel-Dateien, u. a. mit readxl und XLConnect.

Google-Tabellen in R importieren

Das Paket googlesheets mit der Funktion gs_read() erlaubt das Einlesen von Google-Tabellen in R.

Starte mit folgender Zeile:

gs_ls()

Lass den Browser öffnen und schließe die Authentifizierung ab. Wenn du die Daten lesen oder bearbeiten willst, registriere das Sheet – per Titel oder Key:

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

Dann liest du die Daten ein:

gs_read(data)

Das ist nur ein kurzer Überblick zu googlesheets. Lies die Details hier und wirf auch einen Blick auf diese Seite.

DIF-Dateien (Data Interchange Format) in R einlesen

Nutze die Funktion read.DIF(), um DIF-Dateien in R zu laden:

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

Hinweis: Du kannst angeben, ob deine Tabelle eine Kopfzeile hat und ob du die Daten „as is“ importieren willst – also ob Zeichenvariablen in Faktoren umgewandelt werden sollen. Hier wollten wir das nicht, daher !stringsAsFactors.

Weitere Infos zu Funktion und Argumenten findest du hier.

Excel-Dateien in R bringen

Neben Tabellen möchtest du vielleicht auch echte Excel-Dateien in R einlesen. Hier erfährst du, wie das geht!

Hinweis: Dieser Abschnitt vertieft unser Tutorial zum Lesen und Importieren von Excel-Dateien sowie den ersten Beitrag This R Data Import Tutorial Is Everything You Need.

Excel-Dateien mit readxl importieren

Auch wenn das Paket noch aktiv entwickelt wird, lohnt es sich sehr: Es bietet einen einfachen Weg, Excel-Dateien zu lesen:

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

Merke: Liegt die Datei im Arbeitsverzeichnis, reicht der Dateiname inklusive Erweiterung. Arbeitsverzeichnis abrufen und setzen mit:

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

Hinweis: Mit den Argumenten sheet, col_names, col_types, na und skip legst du das Sheet, Spaltennamen/-typen, fehlende Werte und zu überspringende Zeilen fest. Details hier.

Excel-Dateien mit openxlsx einlesen

Das Paket openxlsx bietet ebenfalls einen einfachen Weg, .xlsx-Dateien in R zu lesen:

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

Mehr Details zu Paket und Argumenten der Funktion read.xlsx() findest du hier.

Tipp: Mehr zum Excel-Import in R im ersten Tutorial zum „Datenimport in R“ oder in unserem ausführlichen Tutorial zum Lesen und Importieren von Excel-Dateien, u. a. mit XLConnect.

OpenDocument-Tabellen in R laden

Nutze die Funktion read.ods() aus dem Paket readODS, um OpenDocument-Tabellen in R zu lesen und als Data Frames abzulegen:

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

Hinweis: Neben der Datei kannst du das gewünschte Sheet wählen und bestimmen, ob Formeln als Formeln (z. B. „SUM(B1:B3)“) oder als berechnete Werte angezeigt werden.

JSON-Dateien (JavaScript Object Notation) in R importieren

Im ersten Beitrag zum Datenimport in R wurde das Paket rjson zum Einlesen von JSON-Dateien genannt.

Es gibt jedoch weitere Pakete für den JSON-Import in R. Lies weiter!

JSON-Import mit dem Paket jsonlite

Mit 66.952 Downloads kürzlich in den Top 25 der meistgeladenen R-Pakete: jsonlite ist ein Favorit vieler R-Nutzender.

Du importierst JSON mit fromJSON():

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

Einen schnellen, gut erklärten Einstieg in jsonlite findest du hier.

JSON-Import mit dem Paket RJSONIO

Ein drittes, bekanntes Paket für JSON in R ist RJSONIO. Wie bei jsonlite nutzt du fromJSON():

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

Welches JSON-Paket ist das beste?

Dazu gab es bereits einige Diskussionen. Wenn du tiefer einsteigen willst, sieh dir diese Seiten an:

• Diese Seite zeigt vor allem Codebeispiele und vergleicht Verhalten und Performance von JSON-Paketen in R.
• Lies auch diesen Blogpost, der herausarbeitet, welches Paket JSON-Daten in R am besten handhabt.

Daten aus Statistiksoftware in R bringen

Wenn deine Daten nicht tabellenartig sind und keine Excel- oder JSON-Dateien, stammen sie vielleicht aus Statistiksoftware.

In diesem Abschnitt zeigen wir weitere Wege, um SPSS-, Stata- oder SAS-Dateien einzulesen, und geben einen Überblick zu S-plus und Epi Info. Für mehr Informationen schau gern zurück in den ersten Beitrag oder in die verlinkten Ressourcen.

SPSS-Dateien in R importieren

Statt dem Paket foreign kannst du auch haven nutzen, um SPSS-Dateien in R zu bringen.

Merke: Installiere und lade das Paket vorab in deiner Arbeitsumgebung!

Das Paket haven bietet die Funktion read_spss() für SPSS-Dateien:

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

Stata-Dateien in R importieren

Analog zu foreign stellt haven die Funktion read_dta() für Stata-Dateien bereit:

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

Merke: Installiere benötigte Pakete und lade sie in deiner Session. haven installierst und aktivierst du z. B. so:

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

SAS-Dateien in R importieren

Da das Paket sas7bdat im letzten Beitrag genannt wurde, zeigen wir hier weitere Wege, SAS-Dateien zu lesen:

1. SAS XPORT-Dateien mit dem Paket foreign importieren

Das Paket foreign mit read.xport() liest ebenfalls SAS-XPORT-Dateien:

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

2. SAS XPORT-Dateien mit dem Paket SASxport importieren

Mit dem Paket sasXPORT kannst du via read.xport() ebenfalls SAS-XPORT-Dateien lesen:

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

3. SAS-Dateien mit dem Paket haven importieren

Wie foreign und sas7bdat erlaubt haven das Lesen von b7dat-Dateien mit read_sas():

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

S-plus-Dateien in R laden

Für ältere S-plus-Datensätze (Windows 3.x, 4.x oder 2000 bzw. Unix 3.x mit 4-Byte-Integern) nutzt du read.S() aus dem Paket foreign:

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

Epi-Info-Dateien in R einlesen

Wie bereits erwähnt, bietet das Paket foreign viele Importfunktionen – auch für Epi Info. Verwende read.epiinfo(), um die Daten zu laden:

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

Mehr zu Epi Info findest du hier.

Daten aus weiteren Quellen in R bringen

Neben den gängigen Quellen und Statistikpaketen gibt es viele weitere Ursprünge für Daten, die du in R lesen möchtest.

Einige davon stellen wir hier vor. Lies weiter!

MATLAB-Dateien in R importieren

Mit dem Paket R.matlab und der Funktion readMat() importierst du MATLAB-Dateien in R.

Als erstes Argument übergibst du entweder einen Dateinamen (Zeichenkette) oder einen „raw“-Vektor. Im ersten Fall interpretiert R den Input als Dateiname, im zweiten als binäre Verbindung:

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

readMat() liefert eine benannte Liste mit allen Variablen aus der importierten MAT-Datei zurück.

Octave-Dateien in R einlesen

Das Paket foreign ist wieder am Start! Nutze read.octave(), um Octave-Textdaten in R zu importieren:

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

fitbitScraper-Daten in R bringen

Mit dem Paket fitbitScraper kannst du Daten von fitbit beziehen.

(Für alle, die die Marke nicht kennen: Das Unternehmen bietet Activity-Tracker und weitere Geräte, die persönliche Daten wie Schrittanzahl oder Schlafqualität erfassen.)

Eine kurze, praktische Anleitung zum Paket fitbitScraper findest du hier.

Quantmod-Daten in R importieren

Mit diesem Paket extrahierst du Finanzdaten aus Internetquellen in R. Die Funktion zum Laden der Daten heißt getSymbols(), z. B. so:

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

Hinweis: Zuerst definierst du einen Zeichenvektor mit den Symbolen, die geladen werden sollen, hier "YHOO". Dann legst du die Quelle fest. Verfügbar sind derzeit yahoo, google, MySQL, FRED, csv, RData und oanda.

Anschließend definierst du Lookup-Parameter und speicherst sie für zukünftige Sessions:

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

Neue Sessions laden dann:

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

Mehr zu quantitativer Finanzanalyse in R findest du hier oder im Einsteiger-Tutorial zu quantmod.

ARFF-Dateien in R bringen

Daten im Weka-Format ARFF (Attribute-Relation File Format) liest du mit read.arff() ein:

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

Weitere Informationen zur Funktion findest du hier.

Hinweis: Auch das Paket RWeka bietet dieselbe Funktion zum Import von ARFF-Dateien. Mehr dazu hier.

Daten aus Datenbanken in R importieren

Neben MonetDB.R, rmongodb und RMySQL aus dem vorherigen Beitrag gibt es weitere Pakete für Datenbank-Verbindungen in R.

Du hast außerdem mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.

Tutorials zu diesen Paketen findest du hier:

• Für den Einstieg in mongolite hilft dir dieses Tutorial;
• Für RMongo schau in diesen Blogpost;
• Das Paket RODBC wird ausführlich in diesem Tutorial behandelt. Eine kürzere Beschreibung findest du hier;
• Für ROracle hilft diese Präsentation;
• Mehr zu RPostgreSQL findest du hier oder hier;
• Ein sehr informatives Tutorial zu RSQLite gibt es hier;
• Für Verbindungen zu SQL Server mit RJDBC lies diesen Blogpost oder diese Seite für Oracle. Hinweis: Letztere listet weitere Optionen für Oracle-Verbindungen.

Hinweis: Es gibt zudem das Datenbank-Interface-Paket DBI, das Kommunikation zwischen R und relationalen Datenbanksystemen ermöglicht. Mehr Infos hier.

Ein How-to zur Arbeit mit dem Paket findest du hier.

Binärdateien in R einlesen

Binärdateien speichern Informationen in Gruppen von Binärziffern (0 oder 1). Acht Binärziffern bilden ein Byte. Binärdaten liest du mit readBin() ein:

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

Ein ausführlicheres Beispiel findest du hier. Mehr zur Funktion readBin() gibt es hier.

Binäre Datenformate in R lesen

Die Pakete hdf5, h5r, rhdf5, RNetCDF, ncdf und ncdf4 bieten Schnittstellen zu NASA’s HDF5 und UCAR’s netCDF-Dateien.

Für alle, die Tutorials zu HDF5 oder netCDF in R suchen, hier zwei Ressourcen:

• Ein hervorragendes Tutorial zur Arbeit mit HDF-Dateien (inkl. pathfinder) gibt es hier;
• Einsteigerfreundlich zu netCDF in R ist diese Seite.

DBF-Dateien in R laden

DBF (DataBase File) ist das zugrunde liegende Format von dBase. Mit dem Paket foreign und der Funktion read.dbf() liest du DBF-Dateien ein:

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

Hinweis: Unter Windows kannst du mit dem Paket RODBC und odbcConnectDbase() DBF-Dateien auch über den Microsoft dBase ODBC-Treiber lesen.

Flache Kontingenztafeln in R importieren

Mit dem Paket foreign kannst du verschiedene Formate lesen – auch „flache“ Kontingenztafeln. Verwende dazu read.ftable():

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

Merke: „Flache“ Kontingenztafeln sind „normalen“ sehr ähnlich: Sie enthalten die Häufigkeiten für jede Kombination der Ausprägungen der beteiligten Variablen (Faktoren). Diese Information wird jedoch als Matrix angeordnet, deren Zeilen und Spalten den eindeutigen Kombinationen der Zeilen- und Spaltenvariablen entsprechen. Für höherdimensionale Tafeln sind „flache“ Darstellungen daher oft übersichtlicher.

Geodaten (GIS) in R einlesen

Mit den Paketen rgdal und raster (u. a.) bekommst du GIS-Dateien in R.

Wenn du nicht weißt, wie du mit rgdal startest, lies diesen schönen Blogpost als Einführung in räumliche Daten in R.

Auch dieses Tutorial ist hilfreich – mit rgdal und raster.

ITIS-Tabellen (Integrated Taxonomical Information) in R importieren

ITIS-Tabellen importierst du mit read.table():

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

Mehr zu ITIS findest du hier.

Große Datensätze in R importieren

Der Import großer Datensätze sorgt unter R-Anwendern oft für Diskussionen. Neben Datenbankpaketen gibt es weitere Werkzeuge, die sich bei Big Data bewähren.

Große Datensätze mit dem Paket data.table importieren

Als „fast and friendly file finagler“ beschrieben, ist das beliebte Paket data.table äußerst nützlich und einfach zu bedienen. Seine Funktion fread() importiert Daten aus regulären durch Trennzeichen strukturierten Dateien direkt in R – ohne Umwege.

Hinweis: „Regulär“ bedeutet hier: Jede Zeile hat dieselbe Anzahl an Spalten. Beispiel:

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

Stark ist u. a., dass Parameter wie sep, colClasses und nrows automatisch erkannt werden. Auch bit64::integer64 wird automatisch erkannt und direkt als solcher Typ gelesen – ohne den Umweg über „character“ und anschließende Konvertierung.

Merke: bit64::integer64 sind 64‑Bit-Ganzzahlen. Standardmäßig sind Ganzzahlen 32‑Bit. Durch die Erkennung liest das System Zahlen korrekt ein, statt sie als Zeichen zu importieren und erst danach umzuwandeln.

Ein Beispiel für fread():

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

Hinweis: fread() liefert eine Data Table zurück:

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>

Das unterscheidet sich von read.table(), das einen Data Frame erzeugt.

Mehr zu Unterschieden zwischen Data Frames und Data Tables findest du hier. Kurz gesagt: Jede data.table ist auch ein data.frame und kann überall dort verwendet werden, wo ein data.frame erwartet wird. Mehr FAQs zu 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
              )

Hinweis: Als Input kann auch eine lokale Datei dienen – es muss nicht immer eine URL sein. Viele Argumente entsprechen jenen von read.table().

Tipp: Du willst mehr zu data.table? Unser Kurs Data Analysis In R, The data.table Way könnte dich interessieren! Mit Matt Dowle und Arun Srinivasan wirst du im Handumdrehen zum data.table‑Profi.

Große Datensätze mit dem Paket ff einlesen

Das Paket ff ermöglicht „speichereffiziente Ablage großer Daten auf der Festplatte und schnelle Zugriffe“. Es taucht häufig in Diskussionen zum Einlesen großer Daten als Data Frames auf, z. B. hier.

Um getrennte Flachdateien in ff-Data-Frames zu importieren, nutzt du read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() oder read.delim2.ffdf() – analog zu read.table() und seinen Varianten bzw. Wrappern (siehe auch unseren früheren Beitrag):

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

Hinweis: Das erste Argument kann NULL sein (wie hier) oder ein optionales ffdf-Objekt bezeichnen, an das die gelesenen Records angehängt werden. Mehr Infos hier. Danach folgt der Dateiname (file). Mit nrows begrenzt du optional die maximale Zeilenanzahl (ähnlich wie bei read.table()!).

Du kannst weitergehen und Kodierung, Faktorstufen oder die Funktion zum chunkweisen Lesen angeben:

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

Tipp: Weitere Argumente zu read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() oder read.delim2.ffdf() findest du hier.

Große Datensätze mit bigmemory importieren

Ein weiteres häufig genanntes Paket für sehr große Daten ist bigmemory. Es erlaubt, „gewaltige Matrizen mit Shared Memory und Memory-Mapped Files“ zu verwalten.

Hinweis: Unter Windows ist das Paket nicht nutzbar: Es gibt keine Windows-Binaries.

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

Wie üblich gibst du den Dateinamen an und kannst dann Separator, Header und Anzahl zu überspringender Zeilen über sep, header und skip setzen.

Hinweis: Das sind nur wenige Beispiele! read.big.matrix() akzeptiert viele weitere Argumente. Lies die Dokumentation, wenn du mehr wissen willst.

Große Datensätze mit dem Paket sqldf lesen

Das Paket sqldf ist ebenfalls eine Option für große Daten. Es erlaubt dir, „SQL-Selects in R auszuführen“. Besonders praktisch: read.csv.sql(), um Dateien per SQL-Statement gefiltert zu importieren. So verarbeitet R nur einen Teil der Daten:

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

Hinweis: Das Beispiel ähnelt anderen Importfunktionen für große Daten – mit dem Unterschied, dass du als zweites Argument ein SQL-Statement übergibst. Die im SQL referenzierten Tabellen gehören zur Datei, die du im Argument file von read.csv.sql() angibst.

Tipp: Mehr zu sqldf findest du in diesem Video-Tutorial oder in dieser schriftlichen Übersicht zu den Basics.

Große Datensätze mit der Funktion read.table() importieren

Du kannst auch die „Standard“-Funktion read.table() verwenden, was jedoch meist länger dauert als speziell optimierte Pakete. Wie read.table() funktioniert, erfährst du im ersten Beitrag.

Um die Funktion zu beschleunigen, kannst du sie durch zusätzliche Argumente optimieren, z. B. so:

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
                 )

Hinweis:

• Zuerst übergibst du die (Pfad‑)Angabe zur Datei – abhängig davon, ob dein Arbeitsverzeichnis gesetzt ist.
• Mit header gibst du an, ob die erste Zeile Spaltennamen enthält. Im Beispiel: nein.
• Mit sep setzt du das Trennzeichen, hier /; Werte einer Zeile sind durch dieses Zeichen getrennt.
• Mit quote="" deaktivierst du das Quoting.
• Der String „EMPTY“ soll als NA interpretiert werden.
• Mit colClasses definierst du die Spaltentypen: erstens Zeichen, zweitens numerisch, drittens Faktor.
• strip.white entfernt führende/folgende Leerzeichen in unquoted Zeichenfeldern; nur relevant, wenn sep gesetzt ist!
• Mit comment.char="" schaltest du die Kommentarinterpretation aus.
• Zeichen sollen nicht automatisch zu Faktoren werden – daher stringsAsFactors=FALSE und die explizite Angabe in colClasses.
  Tipp: Dieses Argument ist – zusammen mit colClasses und comment.char – oft entscheidend für einen reibungslosen Import!
• Zum Schluss begrenzt du die maximale Zahl einzulesender Zeilen.

Tipp: Wenn du mehr zu allen Argumenten von read.table() wissen willst, lies unseren Beitrag zum Lesen von Excel-Dateien in R.

Große Datensätze mit dem Paket readr importieren

Ein schnelles Paket für den Import großer Datensätze ist readr. Es liest tabellarische Textdaten wie read.table, bietet jedoch „Ersatzfunktionen mit Zusatzfunktionalität und deutlich höherer Geschwindigkeit“ (siehe hier).

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

Hinweis: Das Paket readr bietet außerdem read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() und viele weitere, schnellere Alternativen! Details hier.

Tipp: Mehr Infos zum Paket findest du auf dieser GitHub-Seite.

Hinweise zum Umgang mit Big Data in R

Weitere Tipps findest du in dieser StackOverflow-Diskussion – neben Paketempfehlungen auch Hinweise wie Binärformate, saveRDS/readRDS oder das rhdf5-Paket für das HDF5-Format.

Hinweis: HDF5 wurde oben bereits behandelt – und es gibt noch viele weitere Pakete. Datenbankpakete wie RODBC und MonetDB.R eignen sich ebenfalls gut für große Datensätze. Auch das Paket dplyr glänzt, wenn du direkt mit Daten in verschiedenen Datenbanken arbeiten willst.

Tipp: Du willst Daten in R transformieren? Dann ist unser interaktiver Kurs zu dplyr etwas für dich! Mit Garrett Grolemund lernst du, anspruchsvolle Datenmanipulationen mit dplyr umzusetzen.

Sieh dir auch diesen interessanten Post an, der die Ladeperformance einiger der oben genannten Pakete testet!

Datenimport in R mit dem Paket rio

Dieses „Schweizer Taschenmesser für Data I/O“ vereinfacht dir Ein- und Ausgabe von Daten in R! Du kannst Daten aus fast jedem Dateiformat in‑ oder exportieren: Mit der Installation von rio holst du dir viele spezialisierte Lese‑Pakete unter eine Haube. Für Ein- und Ausgabe musst du dir nur zwei Funktionen merken: import() und export(). rio nutzt die jeweiligen Pakete im Hintergrund, erkennt den Datentyp anhand der Dateiendung, liest Webquellen nativ und setzt sinnvolle Defaults für Import und Export.

Kurz gesagt: rio unterstützt eine breite Palette gängiger Dateiformate für Import und Export.

So importierst du deine Dateien mit rio:

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

Welche Formate rio genau unterstützt, siehst du hier.

Zum Schluss

Wenn du mehr über Big Data in R lernen möchtest, schau dir die Kurse How To Work With Quandl in R und „Big Data Analysis With Revolution R Enterprise“ auf DataCamp an!