R Language
I / O för utländska tabeller (Excel, SAS, SPSS, Stata)
Sök…
Importerar data med rio
Ett mycket enkelt sätt att importera data från många vanliga filformat är med rio . Detta paket tillhandahåller en funktionsimport import() som innehåller många vanliga dataimportfunktioner och ger därmed ett standardgränssnitt. Det fungerar helt enkelt genom att skicka ett filnamn eller URL för att 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 också läsa från komprimerade kataloger, URL: er (HTTP eller HTTPS) och urklipp. En omfattande lista över alla filformat som stöds finns på rio-paketets github-arkiv .
Det är till och med möjligt att specificera några ytterligare parametrar relaterade till det specifika filformatet du försöker läsa och skicka dem direkt inom import() -funktionen:
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
Importerar Excel-filer
Det finns flera R-paket att läsa Excel-filer, var och en med olika språk eller resurser, som sammanfattas i följande tabell:
| R-paket | användningsområden |
|---|---|
| xlsx | Java |
| XLconnect | Java |
| openxlsx | C ++ |
| readxl | C ++ |
| RODBC | ODBC |
| gdata | Perl |
För paketen som använder Java eller ODBC är det viktigt att veta detaljer om ditt system eftersom du kan ha kompatibilitetsproblem beroende på din R-version och operativsystem. Om du till exempel använder R 64-bitar måste du också ha Java 64-bitar för att använda xlsx eller XLconnect .
Några exempel på läsning av excelfiler med varje paket finns nedan. Observera att många av paketen har samma eller mycket liknande funktionsnamn. Därför är det användbart att ange paketet uttryckligen, som package::function . Paketet openxlsx kräver tidigare installation av RTools.
Läser Excel-filer med xlsx-paketet
library(xlsx)
Arkets namn eller namn krävs för att importera.
xlsx::read.xlsx("Book1.xlsx", sheetIndex=1)
xlsx::read.xlsx("Book1.xlsx", sheetName="Sheet1")
Läsa Excel-filer med XLconnect-paketet
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 importerar automatiskt de fördefinierade Excel- Book1.xlsx inbäddade i Book1.xlsx . Detta är användbart när du vill formatera ditt arbetsbokobjekt och exportera ett perfekt formaterat Excel-dokument. Först måste du skapa önskade cellformat i Book1.xlsx och spara dem, till exempel som myHeader , myBody och myPcts . Sedan efter att ha laddat arbetsboken i R (se ovan):
Headerstyle <- XLConnect::getCellStyle(wb, "myHeader")
Bodystyle <- XLConnect::getCellStyle(wb, "myBody")
Pctsstyle <- XLConnect::getCellStyle(wb, "myPcts")
Cellstilarna sparas nu i din R miljö. För att tilldela cellstilar till vissa dataintervall måste du definiera intervallet och sedan tilldela formatmallen:
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)
Observera att XLConnect är enkelt, men kan bli extremt långsamt i formateringen. Ett mycket snabbare, men mer besvärligt formateringsalternativ erbjuds av openxlsx .
Läser Excel-filer med openxlsx-paketet
Excel-filer kan importeras med openxlsx paket
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.
Arket som bör läsas in i R kan väljas antingen genom att ange dess position i sheet :
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = 1)
eller genom att förklara sitt namn:
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1")
Dessutom kan openxlsx upptäcka openxlsx i ett läst ark. För att möjliggöra automatisk detektering av datum, ett argument detectDates bör sättas till TRUE :
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1", detectDates= TRUE)
Läsa Excel-filer med readxl-paketet
Excel-filer kan importeras som en dataram till R hjälp av readxl paketet.
library(readxl)
Den kan läsa både .xls och .xlsx filer.
readxl::read_excel("spreadsheet1.xls")
readxl::read_excel("spreadsheet2.xlsx")
Det ark som ska importeras kan anges med nummer eller namn.
readxl::read_excel("spreadsheet.xls", sheet = 1)
readxl::read_excel("spreadsheet.xls", sheet = "summary")
Argumentet col_names = TRUE anger den första raden som kolumnnamn.
readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE)
Argumentet col_types kan användas för att specificera kolumntyperna i data som en vektor.
readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE,
col_types = c("text", "date", "numeric", "numeric"))
Läser Excel-filer med RODBC-paketet
Excel-filer kan läsas med ODBC Excel-drivrutinen som gränssnitt med Windows Access Database Engine (ACE), tidigare JET. Med RODBC-paketet kan R ansluta till den här drivrutinen och direkt fråga arbetsböcker. Kalkylblad antas behålla kolumnrubriker i första raden med data i organiserade kolumner av liknande typer. OBS: Detta tillvägagångssätt är begränsat till endast Windows / PC-maskiner eftersom JET / ACE är installerade .dll-filer och inte tillgängliga på andra operativsystem.
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)
JOIN en SQL-motor i det här tillvägagångssättet kan Excel-kalkylark ifrågasättas liknande databastabeller inklusive JOIN och UNION operationer. Syntax följer JET / ACE SQL-dialekten. OBS: Endast dataåtkomst DML-uttalanden, specifikt SELECT kan köras i arbetsböcker, anses inte uppdaterbara frågor.
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$]")
Även andra arbetsböcker kan fråges från samma ODBC-kanal som pekar på en aktuell arbetsbok:
otherwkbkdf <- sqlQuery(xlconn, "SELECT * FROM
[Excel 12.0 Xml;HDR=Yes;
Database=C:\\Path\\To\\Other\\Workbook.xlsx].[Sheet1$];")
Läser Excel-filer med gdata-paketet
exempel här
Läs och skriv Stata-, SPSS- och SAS-filer
foreign paket och haven kan användas för att importera och exportera filer från en mängd andra statistiska paket som Stata, SPSS och SAS och relaterad programvara. Det finns en read funktion för var och en av de stödda datatyper för att importera filerna.
# loading the packages
library(foreign)
library(haven)
library(readstata13)
library(Hmisc)
Några exempel på de vanligaste datatyperna:
# reading Stata files with `foreign`
read.dta("path\to\your\data")
# reading Stata files with `haven`
read_dta("path\to\your\data")
Det foreign paketet kan läsa i statafiler (.dta) för versioner av Stata 7-12. Enligt utvecklingssidan är read.dta mer eller mindre fryst och kommer inte att uppdateras för läsning i version 13+. För nyare versioner av Stata kan du använda paketet readstata13 eller haven . För readstata13 är filerna
# reading recent Stata (13+) files with `readstata13`
read.dta13("path\to\your\data")
För läsning i SPSS- och SAS-filer
# 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
SAScii paketet innehåller funktioner som accepterar SAS SET-importkod och konstruerar en textfil som kan behandlas med read.fwf . Det har visat sig vara mycket robust för import av stora publicerade datasätt. Support finns på https://github.com/ajdamico/SAScii
För att exportera dataramar till andra statistiska paket kan du använda write.foreign() . Detta kommer att skriva två filer, en innehåller data och en innehåller instruktioner som det andra paketet behöver för att läsa informationen.
# 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")
Fil som lagras av SPSS kan också läsas med read.spss på detta sätt:
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.
Import eller export av fjäderfil
Feather är en implementering av Apache Arrow som är utformad för att lagra dataramar på ett språkagnostiskt sätt samtidigt som metadata upprätthålls (t.ex. datumklasser), ökar interoperabiliteten mellan Python och R. Om du läser en fjäderfil skapas en källa, inte en standard 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
Den aktuella dokumentationen innehåller denna varning:
Anmärkning till användare: Fjäder ska behandlas som alfa-programvara. I synnerhet kommer filformatet sannolikt att utvecklas under det kommande året. Använd inte Feather för långsiktig datalagring.