R Language
We / Wy dla tabel obcych (Excel, SAS, SPSS, Stata)
Szukaj…
Importowanie danych za pomocą rio
Bardzo prosty sposób importowania danych z wielu popularnych formatów plików to rio . Ten pakiet zawiera funkcję import()
która otacza wiele często używanych funkcji importu danych, zapewniając tym samym standardowy interfejs. Działa po prostu przekazując nazwę pliku lub adres URL do 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()
może również czytać ze skompresowanych katalogów, adresów URL (HTTP lub HTTPS) i schowka. Pełna lista wszystkich obsługiwanych formatów plików jest dostępna w repozytorium github pakietu rio .
Możliwe jest nawet określenie niektórych dalszych parametrów związanych z konkretnym formatem pliku, który próbujesz odczytać, przekazując je bezpośrednio w funkcji 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
Importowanie plików Excel
Istnieje kilka pakietów R do odczytu plików programu Excel, z których każdy używa różnych języków lub zasobów, co podsumowano w poniższej tabeli:
Pakiet R. | Używa |
---|---|
xlsx | Jawa |
XLconnect | Jawa |
openxlsx | C ++ |
readxl | C ++ |
RODBC | ODBC |
gdata | Perl |
W przypadku pakietów korzystających z Java lub ODBC ważne jest, aby znać szczegółowe informacje o systemie, ponieważ mogą wystąpić problemy ze zgodnością w zależności od wersji R i systemu operacyjnego. Na przykład, jeśli używasz bitów R 64, musisz także mieć 64 bity Java, aby używać xlsx
lub XLconnect
.
Niektóre przykłady odczytu plików Excela z każdym pakietem podano poniżej. Zauważ, że wiele pakietów ma takie same lub bardzo podobne nazwy funkcji. Dlatego przydatne jest jawne określenie pakietu, np. package::function
. Pakiet openxlsx
wymaga wcześniejszej instalacji RTools.
Odczytywanie plików Excela za pomocą pakietu xlsx
library(xlsx)
Indeks lub nazwa arkusza jest wymagana do importu.
xlsx::read.xlsx("Book1.xlsx", sheetIndex=1)
xlsx::read.xlsx("Book1.xlsx", sheetName="Sheet1")
Odczytywanie plików Excel za pomocą pakietu XLconnect
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
automatycznie importuje wstępnie zdefiniowane style komórek Excela osadzone w Book1.xlsx
. Jest to przydatne, gdy chcesz sformatować obiekt skoroszytu i wyeksportować doskonale sformatowany dokument Excel. Po pierwsze, musisz utworzyć pożądane formaty komórek w Book1.xlsx
i zapisać je, na przykład jako myHeader
, myBody
i myPcts
. Następnie po załadowaniu skoroszytu do R
(patrz wyżej):
Headerstyle <- XLConnect::getCellStyle(wb, "myHeader")
Bodystyle <- XLConnect::getCellStyle(wb, "myBody")
Pctsstyle <- XLConnect::getCellStyle(wb, "myPcts")
Style komórek są teraz zapisywane w środowisku R
Aby przypisać style komórek do określonych zakresów danych, musisz zdefiniować zakres, a następnie przypisać styl:
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)
Zauważ, że XLConnect
jest łatwy, ale może stać się bardzo powolny w formatowaniu. O wiele szybsza, ale bardziej uciążliwa opcja formatowania jest oferowana przez openxlsx
.
Odczytywanie plików Excela za pomocą pakietu openxlsx
Pliki Excel można importować z pakietem 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.
Arkusz, który należy wczytać do R, można wybrać, podając jego pozycję w argumencie sheet
:
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = 1)
lub podając swoją nazwę:
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1")
Ponadto openxlsx
może wykrywać kolumny dat w czytanym arkuszu. Aby umożliwić automatyczne wykrywanie dat, argument detectDates
powinien być ustawiony na TRUE
:
openxlsx::read.xlsx("spreadsheet1.xlsx", sheet = "Sheet1", detectDates= TRUE)
Odczytywanie plików Excela za pomocą pakietu readxl
Pliki Excel można zaimportować jako ramkę danych do R
za pomocą pakietu readxl
.
library(readxl)
Może odczytywać zarówno pliki .xls
jak i .xlsx
.
readxl::read_excel("spreadsheet1.xls")
readxl::read_excel("spreadsheet2.xlsx")
Arkusz do zaimportowania można określić według numeru lub nazwy.
readxl::read_excel("spreadsheet.xls", sheet = 1)
readxl::read_excel("spreadsheet.xls", sheet = "summary")
Argument col_names = TRUE
ustawia pierwszy wiersz jako nazwy kolumn.
readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE)
Argument col_types
może być użyty do określenia typów kolumn w danych jako wektora.
readxl::read_excel("spreadsheet.xls", sheet = 1, col_names = TRUE,
col_types = c("text", "date", "numeric", "numeric"))
Odczytywanie plików Excela za pomocą pakietu RODBC
Pliki Excel można odczytać za pomocą sterownika ODBC Excel, który współpracuje z Windows Access Database Engine (ACE), wcześniej JET. Dzięki pakietowi RODBC R może połączyć się z tym sterownikiem i bezpośrednio przeszukiwać skoroszyty. Zakłada się, że arkusze robocze utrzymują nagłówki kolumn w pierwszym wierszu z danymi w zorganizowanych kolumnach podobnych typów. UWAGA: To podejście jest ograniczone tylko do komputerów z systemem Windows / PC, ponieważ JET / ACE mają zainstalowane pliki .dll i nie są dostępne w innych systemach operacyjnych.
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)
Łącząc się z silnikiem SQL w tym podejściu, arkusze programu Excel można przeszukiwać podobnie jak tabele bazy danych, w tym operacje JOIN
i UNION
. Składnia jest zgodna z dialektem SQL JET / ACE. UWAGA: Na skoroszytach można uruchamiać tylko instrukcje DML z dostępem do danych, w szczególności SELECT
, uważane za zapytania, których nie można aktualizować.
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$]")
Nawet inne skoroszyty można przeszukiwać z tego samego kanału ODBC wskazując na bieżący skoroszyt:
otherwkbkdf <- sqlQuery(xlconn, "SELECT * FROM
[Excel 12.0 Xml;HDR=Yes;
Database=C:\\Path\\To\\Other\\Workbook.xlsx].[Sheet1$];")
Odczytywanie plików Excela za pomocą pakietu gdata
przykład tutaj
Odczytywanie i zapisywanie plików Stata, SPSS i SAS
Pakiety foreign
i haven
mogą być używane do importowania i eksportowania plików z wielu innych pakietów statystycznych, takich jak Stata, SPSS i SAS i powiązane oprogramowanie. Dla każdego obsługiwanego typu danych dostępna jest funkcja read
służąca do importowania plików.
# loading the packages
library(foreign)
library(haven)
library(readstata13)
library(Hmisc)
Kilka przykładów najpopularniejszych typów danych:
# reading Stata files with `foreign`
read.dta("path\to\your\data")
# reading Stata files with `haven`
read_dta("path\to\your\data")
Pakiet foreign
może czytać w plikach stata (.dta) dla wersji Stata 7-12. Według strony programistycznej read.dta
jest mniej lub bardziej zamrożony i nie będzie aktualizowany do odczytu w wersjach 13+. Dla nowszych wersjach Stata, można użyć albo readstata13
pakiet lub haven
. W przypadku readstata13
pliki są
# reading recent Stata (13+) files with `readstata13`
read.dta13("path\to\your\data")
Do odczytu w plikach SPSS i SAS
# 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
Pakiet SAScii
udostępnia funkcje, które zaakceptują kod importu SAS SET i read.fwf
plik tekstowy, który można przetworzyć za pomocą read.fwf
. Okazało się bardzo odporne na import dużych zestawów danych opublikowanych publicznie. Wsparcie jest dostępne na https://github.com/ajdamico/SAScii
Aby wyeksportować ramki danych do innych pakietów statystycznych, możesz użyć funkcji zapisu write.foreign()
. Spowoduje to zapisanie 2 plików, jednego zawierającego dane i jednego zawierającego instrukcje, których drugi pakiet potrzebuje do odczytania danych.
# 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")
Plik przechowywany przez SPSS można również odczytać za pomocą read.spss
w następujący sposób:
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 lub eksport pliku wtapiania
Wtapianie jest implementacją Apache Arrow zaprojektowaną do przechowywania ramek danych w sposób agnostyczny w języku, przy jednoczesnym zachowaniu metadanych (np. Klas dat), zwiększając interoperacyjność między Pythonem i R. Czytanie pliku wtyczki spowoduje wygenerowanie tibble, a nie standardowej ramki danych.
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
Obecna dokumentacja zawiera to ostrzeżenie:
Uwaga dla użytkowników: Wtapianie należy traktować jako oprogramowanie alfa. W szczególności format pliku może ewoluować w nadchodzącym roku. Nie używaj wtapiania do długotrwałego przechowywania danych.