R Language
I / O voor buitenlandse tabellen (Excel, SAS, SPSS, Stata)

Gegevens importeren met rio

Een zeer eenvoudige manier om gegevens uit veel voorkomende bestandsindelingen te importeren, is met rio . Dit pakket biedt een functie- import() die veel veelgebruikte gegevensimport-functies verpakt, waardoor een standaardinterface wordt geboden. Het werkt eenvoudig door een bestandsnaam of URL door te geven om te import() :

import("example.csv")       # comma-separated values
import("example.tsv")       # tab-separated values
import("example.dta")       # Stata
import("example.sav")       # SPSS
import("example.sas7bdat")  # SAS
import("example.xlsx")      # Excel

import() kan ook lezen uit gecomprimeerde mappen, URL's (HTTP of HTTPS) en het klembord. Een uitgebreide lijst van alle ondersteunde bestandsindelingen is beschikbaar in de github-repository van het rio-pakket .

Het is zelfs mogelijk om enkele verdere parameters op te geven met betrekking tot het specifieke bestandsformaat dat u probeert te lezen, en deze rechtstreeks door te geven binnen de functie import() :

import("example.csv", format = ",") #for csv file where comma is used as separator
import("example.csv", format = ";") #for csv file where semicolon is used as separator

Excel-bestanden importeren

Er zijn verschillende R-pakketten om Excel-bestanden te lezen, die elk verschillende talen of bronnen gebruiken, zoals samengevat in de volgende tabel:

Voor de pakketten die Java of ODBC gebruiken, is het belangrijk om details over uw systeem te kennen, omdat u compatibiliteitsproblemen kunt hebben, afhankelijk van uw R-versie en besturingssysteem. Als u bijvoorbeeld R 64-bits gebruikt, moet u ook Java 64-bits hebben om xlsx of XLconnect .

Hieronder volgen enkele voorbeelden van het lezen van Excel-bestanden bij elk pakket. Merk op dat veel van de pakketten dezelfde of zeer vergelijkbare functienamen hebben. Daarom is het handig om het pakket expliciet te vermelden, zoals package::function . Het pakket openxlsx vereist voorafgaande installatie van RTools.

Excel-bestanden lezen met het xlsx-pakket

library(xlsx)

De index of naam van het blad is vereist om te importeren.

xlsx::read.xlsx("Book1.xlsx", sheetIndex=1)

xlsx::read.xlsx("Book1.xlsx", sheetName="Sheet1")

Excel-bestanden lezen met het XLconnect-pakket

library(XLConnect)
wb <- XLConnect::loadWorkbook("Book1.xlsx")

# Either, if Book1.xlsx has a sheet called "Sheet1":
sheet1 <- XLConnect::readWorksheet(wb, "Sheet1")
# Or, more generally, just get the first sheet in Book1.xlsx:
sheet1 <- XLConnect::readWorksheet(wb, getSheets(wb)[1])

XLConnect automatisch de vooraf gedefinieerde Excel-celstijlen die zijn ingesloten in Book1.xlsx . Dit is handig als u uw werkmapobject wilt opmaken en een perfect opgemaakt Excel-document wilt exporteren. Allereerst moet u de gewenste Book1.xlsx in Book1.xlsx en deze bijvoorbeeld opslaan als myHeader , myBody en myPcts . Na het laden van de werkmap in R (zie hierboven):

Headerstyle <- XLConnect::getCellStyle(wb, "myHeader")
Bodystyle <- XLConnect::getCellStyle(wb, "myBody")
Pctsstyle <- XLConnect::getCellStyle(wb, "myPcts")

De celstijlen worden nu opgeslagen in uw R omgeving. Om de celstijlen aan bepaalde bereiken van uw gegevens toe te wijzen, moet u het bereik definiëren en vervolgens de stijl toewijzen:

Headerrange <- expand.grid(row = 1, col = 1:8)
Bodyrange <- expand.grid(row = 2:6, col = c(1:5, 8))
Pctrange <- expand.grid(row = 2:6, col = c(6, 7))

XLConnect::setCellStyle(wb, sheet = "sheet1", row = Headerrange$row,
             col = Headerrange$col, cellstyle = Headerstyle)
XLConnect::setCellStyle(wb, sheet = "sheet1", row = Bodyrange$row,
             col = Bodyrange$col, cellstyle = Bodystyle)
XLConnect::setCellStyle(wb, sheet = "sheet1", row = Pctrange$row,
             col = Pctrange$col, cellstyle = Pctsstyle)

Merk op dat XLConnect gemakkelijk is, maar bij het formatteren extreem langzaam kan worden. Een veel snellere, maar meer omslachtige opmaakoptie wordt aangeboden door openxlsx .

Excel-bestanden lezen met het openxlsx-pakket

Excel-bestanden kunnen worden geïmporteerd met pakket openxlsx

library(openxlsx)

openxlsx::read.xlsx("spreadsheet1.xlsx", colNames=TRUE, rowNames=TRUE)

#colNames: If TRUE, the first row of data will be used as column names.
#rowNames: If TRUE, first column of data will be used as row names.

Het vel, dat moet worden gelezen in R kunnen ofwel worden gekozen door de positie in de sheet argument:

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = 1)

of door de naam te vermelden:

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1")

Bovendien kan openxlsx in een openxlsx detecteren. Om automatische detectie van datums toe te staan, moet een argument detectDates worden ingesteld op TRUE :

openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1", detectDates= TRUE)

Excel-bestanden lezen met het readxl-pakket

Excel-bestanden kunnen als een gegevensframe in R worden geïmporteerd met behulp van het readxl pakket.

library(readxl)

Het kan zowel .xls als .xlsx bestanden lezen.

readxl::read_excel("spreadsheet1.xls")
readxl::read_excel("spreadsheet2.xlsx")

Het te importeren blad kan worden opgegeven op nummer of naam.

readxl::read_excel("spreadsheet.xls", sheet = 1)
readxl::read_excel("spreadsheet.xls", sheet = "summary")

Het argument col_names = TRUE stelt de eerste rij in als de kolomnamen.

 readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE)

Het argument col_types kan worden gebruikt om de col_types in de gegevens als een vector op te geven.

readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE,
                   col_types = c("text", "date", "numeric", "numeric"))

Excel-bestanden lezen met het RODBC-pakket

Excel-bestanden kunnen worden gelezen met behulp van het ODBC Excel-stuurprogramma dat samenwerkt met de Access Database Engine (ACE) van Windows, voorheen JET. Met het RODBC-pakket kan R verbinding maken met dit stuurprogramma en rechtstreeks werkboeken opvragen. Er wordt verondersteld dat werkbladen kolomkoppen op de eerste rij behouden met gegevens in georganiseerde kolommen van vergelijkbare typen. OPMERKING: deze benadering is beperkt tot alleen Windows / pc-machines, aangezien JET / ACE dll-bestanden zijn geïnstalleerd en niet beschikbaar zijn op andere besturingssystemen.

library(RODBC)

xlconn <- odbcDriverConnect('Driver={Microsoft Excel Driver (*.xls, *.xlsx, *.xlsm, *.xlsb)};
                             DBQ=C:\\Path\\To\\Workbook.xlsx')

df <- sqlQuery(xlconn, "SELECT * FROM [SheetName$]")
close(xlconn)

Door verbinding te maken met een SQL-engine in deze benadering, kunnen Excel-werkbladen worden opgevraagd, vergelijkbaar met databasetabellen, waaronder JOIN en UNION bewerkingen. Syntaxis volgt het JET / ACE SQL-dialect. OPMERKING: Alleen gegevenstoegang DML-instructies, met name SELECT kunnen worden uitgevoerd op werkmappen, die niet als bijwerkbare query's worden beschouwd.

joindf <-  sqlQuery(xlconn, "SELECT t1.*, t2.* FROM [Sheet1$] t1
                             INNER JOIN [Sheet2$] t2
                             ON t1.[ID] = t2.[ID]")

uniondf <-  sqlQuery(xlconn, "SELECT * FROM [Sheet1$]
                              UNION  
                              SELECT * FROM [Sheet2$]")

Zelfs andere werkmappen kunnen worden opgevraagd vanuit hetzelfde ODBC-kanaal dat naar een huidige werkmap verwijst:

otherwkbkdf <- sqlQuery(xlconn, "SELECT * FROM 
                                 [Excel 12.0 Xml;HDR=Yes;
                                 Database=C:\\Path\\To\\Other\\Workbook.xlsx].[Sheet1$];")

Excel-bestanden lezen met het gdata-pakket

voorbeeld hier

Stata-, SPSS- en SAS-bestanden lezen en schrijven

De foreign pakketten en haven kunnen worden gebruikt voor het importeren en exporteren van bestanden uit verschillende andere statistische pakketten zoals Stata, SPSS en SAS en aanverwante software. Er is een read voor elk van de ondersteunde gegevenstypen om de bestanden te importeren.

# loading the packages
library(foreign)
library(haven)
library(readstata13)
library(Hmisc)

Enkele voorbeelden voor de meest voorkomende gegevenstypen:

# reading Stata files with `foreign`
read.dta("path\to\your\data")
# reading Stata files with `haven`
read_dta("path\to\your\data")

Het foreign pakket kan stata-bestanden (.dta) inlezen voor versies van Stata 7-12. Volgens de ontwikkelpagina is de read.dta min of meer bevroren en wordt deze niet bijgewerkt voor lezen in versies 13+. Voor meer recente versies van Stata kunt u het pakket readstata13 of haven . Voor readstata13 zijn de bestanden

# reading recent Stata (13+) files with `readstata13`
read.dta13("path\to\your\data")

Voor het lezen in SPSS- en SAS-bestanden

# reading SPSS files with `foreign`
read.spss("path\to\your\data.sav", to.data.frame = TRUE)
# reading SPSS files with `haven`
read_spss("path\to\your\data.sav")
read_sav("path\to\your\data.sav")
read_por("path\to\your\data.por")

# reading SAS files with `foreign`
read.ssd("path\to\your\data")
# reading SAS files with `haven`
read_sas("path\to\your\data")
# reading native SAS files with `Hmisc`
sas.get("path\to\your\data")   #requires access to saslib 
# Reading SA XPORT format ( *.XPT ) files
sasxport.get("path\to\your\data.xpt")  # does not require access to SAS executable

Het SAScii pakket biedt functies die de SAS SET-importcode accepteren en een tekstbestand samenstellen dat kan worden verwerkt met read.fwf . Het is zeer robuust gebleken voor het importeren van grote, publiek uitgegeven datasets. Ondersteuning is op https://github.com/ajdamico/SAScii

Om gegevensframes naar andere statistische pakketten te exporteren, kunt u de schrijffuncties write.foreign() . Hiermee worden 2 bestanden geschreven, één met de gegevens en één met instructies die het andere pakket nodig heeft om de gegevens te lezen.

# writing to Stata, SPSS or SAS files with `foreign`
write.foreign(dataframe, datafile, codefile,
              package = c("SPSS", "Stata", "SAS"), ...)
write.foreign(dataframe, "path\to\data\file", "path\to\instruction\file", package = "Stata")

# writing to Stata files with `foreign`
write.dta(dataframe, "file", version = 7L,
          convert.dates = TRUE, tz = "GMT",
          convert.factors = c("labels", "string", "numeric", "codes"))

# writing to Stata files with `haven`
write_dta(dataframe, "path\to\your\data")

# writing to Stata files with `readstata13`
save.dta13(dataframe, file, data.label = NULL, time.stamp = TRUE,
  convert.factors = TRUE, convert.dates = TRUE, tz = "GMT",
  add.rownames = FALSE, compress = FALSE, version = 117,
  convert.underscore = FALSE)

# writing to SPSS files with `haven`
write_sav(dataframe, "path\to\your\data")

Bestanden die zijn opgeslagen door de SPSS kunnen op deze manier ook worden gelezen met read.spss :

 foreign::read.spss('data.sav', to.data.frame=TRUE, use.value.labels=FALSE, 
                     use.missings=TRUE, reencode='UTF-8')
# to.data.frame if TRUE: return a data frame
# use.value.labels if TRUE: convert variables with value labels into R factors with those levels
# use.missings if TRUE: information on user-defined missing values will used to set the corresponding values to NA.
# reencode character strings will be re-encoded to the current locale. The default, NA, means to do so in a UTF-8 locale, only.

Veerbestand importeren of exporteren

Feather is een implementatie van Apache Arrow, ontworpen om dataframes op een taal-agnostische manier op te slaan met behoud van metadata (bijv. Datumklassen), waardoor de interoperabiliteit tussen Python en R. wordt verbeterd. Het lezen van een feather-bestand levert een tibble op, geen standaard data.frame.

library(feather)

path <- "filename.feather"
df <- mtcars

write_feather(df, path)

df2 <- read_feather(path)

head(df2)
##  A tibble: 6 x 11
##     mpg   cyl  disp    hp  drat    wt  qsec    vs    am  gear  carb
##   <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
## 1  21.0     6   160   110  3.90 2.620 16.46     0     1     4     4
## 2  21.0     6   160   110  3.90 2.875 17.02     0     1     4     4
## 3  22.8     4   108    93  3.85 2.320 18.61     1     1     4     1
## 4  21.4     6   258   110  3.08 3.215 19.44     1     0     3     1
## 5  18.7     8   360   175  3.15 3.440 17.02     0     0     3     2
## 6  18.1     6   225   105  2.76 3.460 20.22     1     0     3     1

head(df)
##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

De huidige documentatie bevat deze waarschuwing:

Opmerking voor gebruikers: Veer moet worden behandeld als alfasoftware. In het bijzonder zal het bestandsformaat het komende jaar waarschijnlijk evolueren. Gebruik Feather niet voor langdurige gegevensopslag.