Corso
Introduzione all'importazione dei dati in R
3 ore
210.8K
In questo tutorial di approfondimento di This R Data Import Tutorial Is Everything You Need-Part One, DataCamp prosegue con un tutorial completo ma alla portata di tutti per importare rapidamente dati in R, passando da semplici file di testo piatti ai più avanzati file SPSS e SAS.
Come molti lettori hanno giustamente notato dal primo post, alcuni ottimi pacchetti per importare dati in R non avevano ancora ricevuto attenzione, né il post copriva esplicitamente la distinzione tra il lavoro con set di dati standard e set di dati di grandi dimensioni. Per questo oggi ci concentreremo proprio su questi aspetti.
Continua a leggere per scoprire altri e nuovi modi per importare il tuo file specifico in R e sentiti libero di contattarci se hai ulteriori domande o individui un errore da correggere.
(Prova questo corso interattivo: Importing Data in R (Part 1), per lavorare con file CSV ed Excel in R.)
Portare i dati da fonti comuni in R
Per iniziare, questo post entrerà più nel dettaglio dei modi per portare in R i dati provenienti da fonti comuni, spesso dati di tipo foglio di calcolo. Come nel post precedente, ci concentreremo sulla lettura in R di dati diversi da Excel o da altri tipi di file.
Successivamente, verranno discussi i dati provenienti da altre fonti come software statistici, database, web scraping, ecc.
Se vuoi saperne di più sui passaggi che potresti dover svolgere prima di importare i tuoi dati, vai al nostro primo post, che spiega come preparare dati e ambiente di lavoro prima di portarli in R.
Leggere file piatti in R con scan()
Oltre a read.table(), citata nel primo post del tutorial sull'importazione dei dati in R, la funzione scan() può funzionare anche con dati archiviati in semplici file di testo delimitati. A differenza di read.table(), la funzione scan() restituisce una lista o un vettore, non un dataframe.
Supponiamo di avere il seguente documento .txt:
24 1991
21 1993
53 1962
Puoi leggere i dati (che puoi scaricare qui) con il seguente comando:
data <- scan("birth.txt")
Nota che il tuo file può anche essere un set di dati online. In tal caso, passa semplicemente l'URL come primo argomento della funzione scan().
In alternativa, puoi anche leggere i dati in una matrice:
data <- matrix(scan("birth.txt"),
nrow=2,
byrow=TRUE)
Suggerimento: se vuoi farlo in modo accurato, potresti dover specificare argomenti aggiuntivi per ottenere la matrice esattamente come la desideri. Vai a questa pagina per maggiori informazioni sulla funzione matrix().
Puoi anche leggere le colonne del file di input in vettori separati:
data <- scan("age.txt",
what = list(Age = 0,
Birthyear= 0),
skip=1,
quiet=TRUE)
Nota come prima passi l'argomento (percorso del) file con estensione (a seconda che tu abbia impostato o meno la directory di lavoro sulla cartella che contiene il dataset) e poi specifichi il tipo di dati da leggere, se saltare o meno la prima riga del dataset, quale carattere delimita i campi e se stampare una riga che indica quanti elementi sono stati letti.
Se i tuoi dati possono contenere anche altri tipi, dovresti ritoccare un po' la funzione scan(), come in questo esempio:
data <- scan("age.csv",
what = list(Age = 0,
Name= "",
Birthyear= 0),
skip=1,
sep=";",
quiet=TRUE)
Suggerimento: puoi provarci anche tu! Scarica il file di testo usato sopra qui.
E poi puoi anche leggere i dati in un data frame:
data <- data.frame(scan("age.csv",
what = list(Age = 0,
Name = "",
Birthyear= 0),
skip=1,
sep=";",
quiet=TRUE)
Suggerimento: molti degli argomenti che può accettare la funzione scan() sono gli stessi che puoi usare con la funzione read.table(). Per questo è sempre utile consultare la documentazione! Vai qui se vuoi approfondire gli argomenti di scan().
Ricorda che puoi ottenere e impostare la directory di lavoro con i seguenti comandi, rispettivamente:
getwd()
setwd("<path to your folder>")
Portare in R dati a colonne a larghezza fissa con read.fwf()
Per leggere in un data frame una tabella di “dati a larghezza fissa” in R, puoi usare la funzione read.fwf() del pacchetto utils.
Usi questa funzione quando il tuo file dati ha colonne contenenti spazi o colonne senza spazi a separarli.
Phys / 00 / 1: M abadda
Math / 00 / 2: F bcdccb
Lang / 00 / 3: F abcdab
Chem / 00 / 4: M cdabaa
Qui sai, ad esempio, che i valori della materia risiedono sempre nei primi 7 caratteri di ogni riga, i valori del sesso sono sempre alla posizione 22 e i punteggi iniziano dal carattere 25 al 30.
Se vuoi provare a caricare questi dati in R, puoi scaricare facilmente il file di testo qui.
Per ottenere correttamente in R i dati di cui sopra, dovresti eseguire il seguente comando:
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)
Nota che l'argomento widths fornisce le larghezze dei campi a larghezza fissa. In questo caso, i primi sette caratteri del file sono riservati ai nomi dei corsi; poi, non vuoi leggere i successivi quattordici caratteri: passi -14. Successivamente, ti serve un carattere per rappresentare il sesso, ma non vuoi i due successivi, quindi passi -2. Tutti i caratteri seguenti vanno letti in colonne separate, quindi li suddividi passando 1,1,1,1,1,1 all'argomento. Ovviamente, questi valori possono e varieranno, a seconda delle colonne che vuoi importare.
Ci sono diversi argomenti extra che puoi passare alla funzione read.fwf(). Clicca qui per approfondirli.
Nota che se vuoi caricare un file usando specifiche di formato in stile Fortran, puoi usare la funzione read.fortran():
data <- tempfile()
cat(file = data, "345678", "654321", sep = "\n")
read.fortran(data, c("F2.1","F2.0","I2"))
Come vedi dal piccolo esempio sopra, usi specifiche di formato in stile Fortran come secondo argomento della funzione read.fortran(). Gli argomenti che puoi eventualmente passare sono nello stile: “rFl.d”, “rDl.d”, “rXl”, “rAl” o “rIl”, dove “l” è il numero di colonne, “d” è il numero di decimali e “r” è il numero di ripetizioni. In questo caso, vedi elencati 2.1, 2.0 e 2 tramite la funzione c(), il che significa che hai tre colonne con due righe. Nella prima colonna hai valori con una cifra decimale, nella seconda e nella terza valori senza decimali.
Per quanto riguarda il tipo di valori contenuti nelle colonne, puoi avere:
- “F” e “D” per formati numerici;
- “A” se hai valori di tipo carattere;
- “I” per valori interi;
- E “X” per indicare colonne che possono essere saltate.
In questo caso, la prima e la seconda colonna conterranno formati numerici, mentre la terza conterrà valori interi.
Nota che il codice di ripetizione “r” e quello per i decimali “d” sono sempre opzionali. Il codice di lunghezza “l” è richiesto tranne che per i formati “X” quando “r” è presente.
Portare i tuoi fogli di calcolo (Google) in R
I fogli di calcolo possono essere importati in R in vari modi, come avrai già letto nel nostro tutorial su lettura e importazione di file Excel in R o nel nostro primo post This R Data Import Tutorial Is Everything You Need. Questa sezione approfondirà l'argomento e andrà oltre, includendo anche i fogli Google e i file DIF!
Scorri per scoprire come importare i tuoi fogli di calcolo in R.
Importare fogli di calcolo Excel in R
Oltre al pacchetto xlsx, hai anche altre opzioni per leggere fogli di calcolo in R:
1. Leggere fogli di calcolo Excel in R dagli appunti
Se hai un foglio di calcolo aperto, puoi copiarne i contenuti negli appunti e importarli rapidamente in R. Per farlo, puoi usare le funzioni readClipboard() o read.table():
readClipboard() #Only on Windows
read.table(file="clipboard")`
Come vedrai se ci provi, il primo approccio funziona bene per dati vettoriali, ma diventa piuttosto complicato se negli appunti hai dati tabellari. Se vuoi saperne di più su read.table(), vai sicuramente alla prima parte del tutorial sull'importazione dei dati in R o al nostro tutorial su lettura e importazione di file Excel in R.
2. Leggere fogli di calcolo Excel in R tramite il pacchetto RODBC
Il secondo modo per portare i tuoi fogli Excel in R è tramite il pacchetto RODBC:
- Un primo modo per usare questo pacchetto è il seguente:
library(RODBC)
connection <- odbcConnect("<DSN>")
Nota che l'argomento che passi a odbcConnect() è in realtà un DSN. Per una guida completa alla configurazione del DSN, dell'eventuale connessione, ecc., vai a questa pagina, un tutorial ampio ma facilmente accessibile!
- Una volta impostata la connessione, puoi anche usare la funzione
sqlQuery()per ottenere dati da fogli.xls:
query <- "<SQL Query>"
data <- sqlQuery(connection,
query)
str(data)
Grande suggerimento: vai a questa pagina, un tutorial ampio ma facilmente accessibile!
Alla fine di una sessione R, non dimenticare di chiudere le connessioni:
odbcCloseAll()
Suggerimento: se vuoi saperne di più sull'importazione di fogli o file Excel in R, vai sicuramente al nostro primo tutorial su importare dati in R o considera la lettura del nostro tutorial su lettura e importazione di file Excel in R, che tratta tra gli altri i pacchetti readxl e XLConnect.
Importare fogli di calcolo Google in R
Il pacchetto googlesheets con la funzione gs_read() ti permette di leggere fogli Google in R.
Inizia eseguendo la seguente riga di codice:
gs_ls()
Lascia che il browser si apra e completa l'autenticazione. Poi, se vuoi leggere o modificare i dati, devi registrarli. Puoi farlo specificando il tuo foglio per titolo o per chiave:
data <- gs_title("<your spreadsheet>")
data <- gs_key()
Successivamente, puoi leggere i dati:
gs_read(data)
Questa è solo una breve panoramica di ciò che puoi fare con il pacchetto googlesheets. Leggi assolutamente tutti i dettagli qui e dai un'occhiata anche a questa pagina.
Leggere file in formato Data Interchange (DIF) in R
Usa la funzione read.DIF() per portare i tuoi file DIF in R:
data <- read.DIF("<your spreadsheet>",
header=FALSE,
as.is = !stringsAsFactors)
Nota che puoi specificare se il tuo foglio ha un'intestazione o meno e se vuoi importare i dati “così come sono”, cioè se vuoi convertire o meno le variabili carattere in fattori. In questo caso, non lo volevi, quindi hai indicato !stringsAsFactors.
Per ulteriori informazioni su questa funzione o sui suoi argomenti, vai a questa pagina.
Portare file Excel in R
Oltre ai fogli di calcolo, potresti essere interessato a portare in R i tuoi veri e propri file Excel. Continua a leggere per scoprire come fare!
Nota che questo post approfondisce quanto descritto nel nostro tutorial su lettura e importazione di file Excel in R e nel nostro primo post This R Data Import Tutorial Is Everything You Need!
Importare file Excel in R con readxl
Anche se questo pacchetto è ancora in sviluppo attivo, vale davvero la pena provarlo, perché offre un modo abbastanza semplice per leggere file Excel:
library(readxl)
read_excel("<path to file")
Ricorda che puoi semplicemente digitare il nome del file con la sua estensione se la tua cartella è nella directory di lavoro. Ottieni e imposta la directory di lavoro con le seguenti righe di codice:
getwd()
setwd("<Path to your folder>")
Nota che puoi specificare il foglio da leggere, i nomi e i tipi delle colonne, i valori mancanti e il numero di righe da saltare prima di leggere i dati con gli argomenti sheet, col_names, col_types, na e skip, rispettivamente. Approfondisci qui.
Leggere file Excel in R con openxlsx
Il pacchetto openxlsx ti fornisce anche un modo semplice per leggere file Excel .xlsx in R:
library(openxlsx)
read.xlsx("<path to your file>")
Se vuoi ulteriori dettagli su questo pacchetto o sugli argomenti che puoi passare alla funzione read.xlsx(), clicca sicuramente qui.
Suggerimento: se vuoi saperne di più sull'importazione di file Excel in R, vai al nostro primo tutorial su “importare dati in R” o considera la lettura del nostro ampio tutorial su lettura e importazione di file Excel in R, che tratta anche il pacchetto XLConnect, tra gli altri.
Portare i fogli OpenDocument in R
Usa la funzione read.ods() del pacchetto readODS per leggere i tuoi fogli OpenDocument in R e inserirli in data frame:
library(readODS)
read.ods("<path to your file>",
sheet = 1,
formulaAsFormula = FALSE)
Nota che, oltre al file che vuoi portare in R, puoi specificare il foglio desiderato e hai la possibilità di visualizzare le formule come formule (ad esempio, “SUM(B1:B3)”) o i valori risultanti.
Importare file JSON (JavaScript Object Notation) in R
Nel nostro primo post sull'importazione dei dati in R, è stato citato il pacchetto rjson per portare file JSON in R.
Tuttavia, ci sono anche altri pacchetti che puoi usare per importare file JSON in R. Continua a leggere per saperne di più!
Importare file JSON in R con il pacchetto jsonlite
Recentemente inserito nella top 25 dei pacchetti R più scaricati con 66952 download, il pacchetto jsonlite è sicuramente tra i preferiti dagli utenti R.
Importi file JSON con la funzione fromJSON():
library(jsonlite)
data <- fromJSON("<Path to your JSON file>")
Per un rapido avvio ben spiegato con il pacchetto jsonlite, vai qui.
Importare file JSON in R con il pacchetto RJSONIO
Il terzo, noto pacchetto per portare file JSON in R è RJSONIO. Proprio come i pacchetti jsonlite e jsonlite, usi la funzione fromJSON():
library(RJSONIO)
data <- fromJSON("<Path to your JSON file")
Il miglior pacchetto per JSON?
Su questo tema c'è stata parecchia discussione. Se vuoi saperne di più, dai sicuramente un'occhiata alle seguenti pagine e post:
- questa pagina offre soprattutto illustrazioni con esempi di codice che forniscono maggiore comprensione del comportamento e delle prestazioni dei pacchetti JSON in R.
- Leggi anche questo post, che cerca di capire quale pacchetto gestisce meglio i dati JSON in R.
Portare in R dati da software statistici
Se i tuoi dati non sono propriamente di tipo foglio di calcolo e non sono file Excel o JSON, potrebbero essere stati creati con uno dei tanti software statistici.
Questa sezione ti fornirà altri modi per leggere i tuoi file SPSS, Stata o SAS, oltre a offrire una panoramica sull'importazione di file provenienti da S-plus ed Epi Info. Assicurati di tornare al nostro primo post o ai link forniti di seguito se vuoi maggiori informazioni!
Importare file SPSS in R
Invece di usare il pacchetto foreign, puoi anche ricorrere al pacchetto haven per portare i tuoi file SPSS in R.
Ricorda di assicurarti di installarlo e attivarlo nel tuo workspace prima di iniziare!
Il pacchetto haven offre la funzione read_spss() per leggere file SPSS in R:
library(haven)
data <- read_spss("<path to your SPSS file>")
Importare file Stata in R
Analogamente al pacchetto foreign, il pacchetto haven fornisce anche una funzione per leggere i file Stata in R, ovvero read_dta():
data <- read_dta("<path to your STATA file>")
Ricorda sempre di installare i pacchetti se necessario e di attivarli nel tuo workspace. Ad esempio, puoi installare e attivare il pacchetto haven nel tuo workspace con i seguenti comandi:
install.packages("haven")
library(haven)
Importare file SAS in R
Dal momento che nell'ultimo post è stato citato il pacchetto sas7bdat, questo tutorial di approfondimento si concentrerà su altri modi per leggere file SAS:
1. Come importare file SAS XPORT in R con il pacchetto foreign
Il pacchetto foreign con la funzione read.xport() ti permette anche di portare i tuoi file SAS XPORT in R:
library(foreign)
data <- read.xport("<path to your SAS file>")
2. Come importare file SAS XPORT in R con il pacchetto SASxport
Il pacchetto sasXPORT permette anche di leggere file SAS XPORT con la funzione read.xport():
library(SASxport)
data <- read.xport("<path to your SAS file>")
3. Come importare file SAS in R con il pacchetto haven
Proprio come i pacchetti foreign e sas7bdat, il pacchetto haven ti permette di leggere file b7dat in R con la funzione read_sas():
library(haven)
data <- read_sas("<path to your SAS file>")
Portare file S-plus in R
Per vecchi dataset S-plus, cioè quelli prodotti su Windows versioni 3.x, 4.x o 2000 o su Unix, versione 3.x con interi a 4 byte, puoi usare la funzione read.S() del pacchetto foreign:
library(foreign)
data <- read.S("<Path to your file>")
Leggere file Epi Info in R
Come avrai letto nel nostro tutorial precedente o in questo, il pacchetto foreign offre molte funzioni per leggere file specifici in R, ed Epi Info è uno di questi. Puoi semplicemente usare la funzione read.epiinfo() per portare i tuoi dati in R:
library(foreign)
data <- read.epiinfo("<Path to your file>")
Per maggiori informazioni su Epi Info, clicca qui.
Portare in R dati da altre fonti
Oltre alle fonti comuni e ai software statistici, esistono molte altre fonti da cui potresti avere dati da leggere in R.
Qui sotto ne trovi alcune. Continua a leggere!
Importare file MATLAB in R
Puoi usare il pacchetto R.matlab con la funzione readMat() per importare file MATLAB in R.
Puoi passare una stringa di caratteri come primo argomento a questa funzione oppure un vettore raw. Nel primo caso, il tuo input sarà interpretato come un nome file, mentre nel secondo caso sarà considerato una connessione binaria grezza:
library(R.matlab)
data <- readMat("<Path to your file>")
La funzione readMat() restituirà una lista nominata che contiene tutte le variabili del file MAT importato.
Leggere file Octave in R
Riecco il pacchetto foreign! Usa la funzione read.octave() per importare in R dati testuali di Octave:
library(foreign)
data <- read.octave("<Path to your file>")
Portare in R dati da FitbitScraper
Puoi usare il pacchetto fitbitScraper per ottenere dati da fitbit.
(Per chi non conosce l'azienda: offre prodotti come tracker di attività e altri dispositivi tecnologici che misurano dati personali come il numero di passi o la qualità del sonno.)
Vai qui per un tutorial breve e pratico su come usare il pacchetto fitbitScraper.
Importare dati Quantmod in R
Puoi usare questo pacchetto per estrarre dati finanziari da una fonte Internet con R. La funzione che usi per portare i dati in R è getSymbols(), come in questo esempio:
library(quantmod)
data <- getSymbols("YHOO", src="google")
Nota che prima specifichi un vettore di caratteri con i nomi di ciascun simbolo da caricare. In questo caso, è "YHOO". Poi definisci un metodo di sourcing. I metodi disponibili al momento sono yahoo, google, MySQL, FRED, csv, RData e oanda.
Successivamente, specifichi i parametri di lookup e li salvi per sessioni future:
setSymbolLookup(YHOO='google',GOOG='yahoo')
saveSymbolLookup(file="mysymbols.rda")
Le nuove sessioni poi richiamano
loadSymbolLookup(file="mysymbols.rda")
getSymbols(c("YHOO","GOOG"))
Se vuoi maggiori informazioni sulle applicazioni di finanza quantitativa in R, clicca qui o vai a questa pagina per un tutorial dettagliato per principianti su quantmod.
Portare file ARFF in R
I dati da file in formato Attribute-Relation File Format (ARFF) di Weka possono essere letti con la funzione read.arff():
library(foreign)
data <- read.arff("<Path to your file>")
Per ulteriori informazioni su questa funzione, vai a questa pagina.
Nota che il pacchetto RWeka offre la stessa funzione per importare file ARFF. Vai qui se vuoi saperne di più!
Importare dati da database in R
Oltre a MonetDB.R, rmongodb e RMySQL, trattati nel post precedente, hai anche altri pacchetti per connetterti ai database in R.
hai anche mongolite, RMongo, RODBC, ROracle, RPostgreSQL, RSQLite, RJDBC.
Per tutorial su questi pacchetti, consulta il seguente elenco:
- Se vuoi iniziare con
mongolite, questo tutorial può aiutarti; - Per assistenza con
RMongo, puoi andare a questo post; - Il pacchetto
RODBCè trattato ampiamente anche in questo tutorial. Per una descrizione più breve del metodo di lavoro, vai qui; - Per imparare a lavorare con
ROracle, puoi consultare questa presentazione; - Per maggiori informazioni su come lavorare con
RPostgreSQL, vai qui o qui; - Vai sicuramente a questo tutorial molto informativo se vuoi saperne di più su
RSQLite; - Infine, per connetterti a SQL Server con
RJDBC, dovresti leggere questo post o andare a questa pagina se vuoi connetterti a un database Oracle. Nota che quest'ultima pagina offre anche altre opzioni per connettersi a database Oracle.
Nota che esiste anche un pacchetto di interfaccia ai database, DBI, che consente la comunicazione tra R e i sistemi di gestione di database relazionali. Per maggiori informazioni, clicca qui.
Alcune spiegazioni su come lavorare con questo pacchetto si trovano qui.
Portare file binari in R
I file di dati binari contengono informazioni archiviate in gruppi di cifre binarie. Ogni cifra binaria è uno zero o uno. Otto cifre binarie raggruppate formano un byte. Puoi leggere dati binari con la funzione 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
Per un esempio più dettagliato, vai a questa pagina. Per maggiori informazioni sulla funzione readBin(), clicca qui.
Leggere formati di dati binari in R
I pacchetti hdf5, h5r, rhdf5, RNetCDF, ncdf e ncdf4 forniscono interfacce ai file dati HDF5 della NASA HDF5 e ai file dati netCDF di UCAR netCDF.
Per chi è interessato a tutorial su come lavorare con file HDF5 o netCDF in R, considera le seguenti risorse:
- Puoi trovare un eccellente tutorial sul lavoro con file HDF in R, usando anche il pacchetto pathfinder, qui;
- Un tutorial per principianti su netCDF in R, facilmente accessibile, si trova in questa pagina.
Portare i tuoi file DBF in R
Un file DBF (DataBase File) è il formato sottostante di dBase. Puoi leggere file DBF con l'uso del pacchetto foreign, che offre la funzione read.dbf():
library(foreign)
data <- read.dbf("<Path to your file>")
Nota che se usi Windows, puoi anche usare il pacchetto RODBC con la funzione odbcConnectDbase() per leggere file DBF tramite il driver ODBC dBase di Microsoft.
Importare tabelle di contingenza piatte in R
Il pacchetto foreign ti permette di leggere molteplici formati di file; le tabelle di contingenza “piatte” non fanno eccezione. Puoi usare la funzione read.ftable() per riuscirci:
library(foreign)
data <- read.ftable("<Path to your file>")
Ricorda che le tabelle di contingenza “piatte” sono molto simili alle tabelle di contingenza “normali”: contengono i conteggi di ogni combinazione dei livelli delle variabili (fattori) coinvolte. Tuttavia, queste informazioni sono riorganizzate come una matrice le cui righe e colonne corrispondono alle combinazioni uniche dei livelli delle variabili di riga e di colonna. Le tabelle di contingenza “piatte” sono quindi spesso preferite per rappresentare tabelle di contingenza di dimensioni superiori.
Leggere file GIS (Geographical Information System) in R
Puoi usare i pacchetti rgdal e raster, tra gli altri, per portare i tuoi file GIS in R.
Se non sai da dove iniziare con il pacchetto rgdal, valuta di leggere questo bel post, che ti introduce al lavoro con i dati geospaziali in R.
Puoi consultare anche questo tutorial, che usa sia rgdal sia raster.
Importare tabelle ITIS (Integrated Taxonomical Information) in R
Puoi importare tabelle ITIS con la funzione read.table():
data <- read.table("<Path to your file>")
Per ulteriori informazioni su ITIS, clicca qui.
Importare set di dati di grandi dimensioni in R
L'importazione di set di dati grandi spesso suscita discussioni tra gli utenti R. Oltre ai pacchetti pensati per connettersi ai database, ce ne sono anche altri che si distinguono nel lavoro con big data.
Importare grandi set di dati in R con il pacchetto data.table
Descritto come il “finagler di file veloce e amichevole”, il popolare pacchetto data.table è estremamente utile e semplice da usare. La sua funzione fread() è pensata per importare dati da file delimitati regolari direttamente in R, senza deviazioni o complicazioni.
Nota che “regolari” in questo caso significa che ogni riga dei tuoi dati deve avere lo stesso numero di colonne. Un esempio:
V1 V2 V3
1 1 6 a
2 2 7 b
3 3 8 c
4 4 9 d
5 5 10 e
Una delle grandi cose di questa funzione è che tutti i controlli, espressi in argomenti come sep, colClasses e nrows, vengono rilevati automaticamente. Inoltre, i tipi bit64::integer64 sono rilevati e letti direttamente senza bisogno di passare prima per il carattere e poi convertire.
Ricorda che i tipi bit64::integer64 sono interi a 64 bit: questi numeri sono archiviati nel computer come lunghi 64 bit. Per impostazione predefinita, sono solo 32 bit. Poiché i tipi bit64::integer64 vengono rilevati, il sistema sa che si tratta di un numero e non lo legge come carattere per poi convertirlo in intero.
Un esempio della funzione 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
Nota che leggere i dati con la funzione fread() restituisce una data table:
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>
Questo è diverso da read.table(), che crea un data frame dei tuoi dati.
Puoi trovare altre informazioni sulle differenze tra data frame e data table spiegate qui. In breve, la cosa più importante è sapere che tutte le data.table sono anche data.frame: le data.table sono anch'esse data.frame. Una data.table può essere passata a qualsiasi pacchetto che accetta solo data.frame e quel pacchetto può usare la sintassi [.data.frame sulla data.table. Leggi di più su data.table qui.
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
)
Nota che l'input può anche essere un file locale che vuoi leggere e non deve essere per forza un URL. Nota anche come molti argomenti sono gli stessi che useresti, ad esempio, in read.table().
Suggerimento: vuoi saperne di più su data.table? Forse il nostro corso Data Analysis In R, The data.table Way può interessarti! Con la guida di Matt Dowle e Arun Srinivasan, passerai da principiante a esperto di data.table in pochissimo tempo.
Portare grandi set di dati in R con il pacchetto ff
Il pacchetto ff consente la “memorizzazione efficiente in memoria di grandi dati su disco e funzioni di accesso veloci”. È una delle soluzioni che spuntano spesso quando approfondisci discussioni sul caricamento di big data come data frame, ad esempio qui.
Se vuoi importare file piatti separati in data frame ff, puoi usare le funzioni read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() o read.delim2.ffdf(), in modo simile alla funzione read.table() e alle sue varianti o wrapper di comodo, descritti in uno dei nostri precedenti post:
bigdata <- read.table.ffdf(file="<Path to file>",
nrows=n)
Nota che il tuo primo argomento può essere NULL (come in questo caso) o può indicare un oggetto ffdf opzionale a cui vengono aggiunte le righe lette. Se vuoi saperne di più, vai qui. Poi, indichi il file da cui vengono letti i dati con l'argomento file. Puoi anche specificare un numero massimo di righe da leggere con nrows (proprio come faresti con read.table()!).
Puoi anche andare oltre e specificare la codifica del file, i livelli o il nome di una funzione chiamata per leggere ciascun blocco:
library(ff)
bigdata <- read.table.ffdf(file="<Path to file>",
nrows=n,
fileEncoding="",
levels=NULL,
FUN="read.table")
Suggerimento altri argomenti che puoi aggiungere alle funzioni read.table.ffdf(), read.csv.ffdf(), read.csv2.ffdf(), read.delim.ffdf() o read.delim2.ffdf() si trovano qui.
Importare grandi set di dati in R con bigmemory
Un altro pacchetto che compare spesso nei risultati quando cerchi soluzioni per grandi set di dati in R è bigmemory. Questo pacchetto permette di “gestire matrici enormi con memoria condivisa e file mappati in memoria”.
Nota che non puoi usare questo pacchetto su Windows: non sono disponibili binari per Windows.
library(bigmemory)
bigdata <- read.big.matrix(filename="<File name>",
sep="",
header=TRUE,
skip=2)
Come al solito, prima passi il nome del file alla funzione, poi puoi iniziare a specificare altre cose, come il simbolo separatore, l'intestazione o il numero di righe da saltare prima di iniziare a leggere il file con gli argomenti sep, header e skip rispettivamente.
Nota che questi sono solo alcuni esempi! Puoi passare molti altri argomenti alla funzione read.big.matrix()! Considera di leggere la documentazione se vuoi saperne di più.
Leggere grandi set di dati in R con il pacchetto sqldf
Il pacchetto sqldf è anche uno dei pacchetti che potresti considerare quando lavori con grandi set di dati. Questo pacchetto permette di “eseguire select SQL su R” e in particolare la sua funzione read.csv.sql() è molto comoda se vuoi leggere un file in R filtrandolo con un'istruzione SQL. In tal modo, solo una parte dei dati viene elaborata da R:
library(sqldf)
bigdata <- read.csv.sql(file="<Path to your file>",
sql="select * from file where ...",
colClasses=c("character",
rep("numeric",10)))
Nota che l'esempio sopra è molto simile ad altre funzioni che permettono di importare grandi set di dati in R, con la sola eccezione che il secondo argomento che passi alla funzione read.csv.sql() è un'istruzione SQL. Le tabelle a cui fai riferimento nella query SQL fanno parte del file che menzioni nell'argomento file di read.csv.sql().
Suggerimento: per ulteriori informazioni su come lavorare con sqldf, puoi andare qui per un video tutorial o qui per una panoramica scritta delle basi.
Importare grandi set di dati in R con la funzione read.table()
Puoi usare la “classica” funzione read.table() per importare i tuoi dati, ma probabilmente richiederà più tempo rispetto ad altri pacchetti progettati per funzionare meglio con set di dati più grandi. Per vedere come funziona la funzione read.table(), torna al nostro primo post.
Per rendere questa funzione un po' più veloce, potresti ritoccarla tu stesso per ottenere una read.table() ottimizzata. Questo ritocco consiste in realtà solo nell'aggiungere argomenti alla solita funzione read.table(), proprio così:
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
)
Nota che
- per prima cosa passi il (percorso del) file, a seconda che tu abbia impostato o meno la directory di lavoro sulla cartella in cui si trova il file.
- Poi, usi l'argomento
headerper indicare se il file contiene i nomi delle variabili nella prima riga. Nell'esempio sopra non è così. - Il carattere separatore dei campi è impostato come
/con l'argomentosep; significa che i valori su ogni riga del file sono separati da questo carattere. - Successivamente, puoi anche scegliere se disattivare o abilitare le virgolette. In questo caso, poiché
quote="", disattivi le virgolette. - Definisci anche che la stringa “EMPTY” nel tuo dataset va interpretata come un valore NA.
- Poi definisci le classi delle colonne: in questo caso, indichi che la prima colonna è di tipo carattere, la seconda numerica e l'ultima un fattore.
- Con
strip.whitepermetti la rimozione degli spazi bianchi iniziali e finali dai campi carattere non quotati; Questo è applicabile solo quando hai usato l'argomentosep! - Quando
comment.charè impostato su"", disattivi l'interpretazione dei commenti. - Non vuoi che i caratteri vengano convertiti in fattori! Ecco perché hai definito anche
colClasses. Lo confermi impostandostringsAsFactorssuFALSE.
Suggerimento: questo argomento è, insieme acolClassesecomment.char, probabilmente uno dei più importanti se vuoi importare i tuoi dati senza intoppi! - Infine, imposti un numero massimo di righe da leggere.
Suggerimento: se vuoi maggiori informazioni su tutti gli argomenti che puoi passare alla funzione read.table(), dovresti considerare di leggere il nostro post sulla lettura di file Excel in R.
Portare grandi set di dati in R con il pacchetto readr
Uno dei pacchetti più veloci che puoi usare per importare il tuo big data set in R è il pacchetto readr, che ti permette di leggere dati tabulari di testo, proprio come read.table. Tuttavia, il pacchetto readr offre “una serie di funzioni sostitutive che forniscono funzionalità aggiuntive e sono molto più rapide” (vedi qui).
df <- read_table("<Path to your file>",
col_names=TRUE)
Nota che il pacchetto readr offre anche le funzioni read_csv(), read_csv2(), read_delim(), read_fwf(), read_tsv() e molte altre che vanno più veloci delle originali! I dettagli si trovano qui.
Suggerimento: ulteriori informazioni su questo pacchetto sono disponibili su questa pagina GitHub.
Alcune osservazioni sulla gestione dei big data in R
Per ulteriori consigli sulla gestione dei big data in R, dovresti probabilmente dare un'occhiata a questa discussione su StackOverflow, che tratta pacchetti ma anche suggerimenti come archiviare i dati in formati binari e l'uso di saveRDS/readRDS o del pacchetto rhdf5 per il formato HDF5.
Nota che quest'ultimo formato è stato trattato sopra e che esistono molti altri pacchetti oltre a quelli menzionati. Ad esempio, i pacchetti usati per connettersi ai database, come RODBC e MonetDB.R, possono essere facilmente usati anche per gestire set di dati più grandi e il pacchetto dplyr si dimostra prezioso quando vuoi lavorare direttamente con dati archiviati in diversi tipi di database.
Suggerimento: ti interessa manipolare dati in R? Allora il nostro corso interattivo su dplyr potrebbe fare al caso tuo! Con la guida di Garrett Grolemund, imparerai a svolgere sofisticate operazioni di manipolazione dati usando dplyr.
Assicurati anche di leggere questo interessante post, che testa le prestazioni di caricamento di alcuni dei pacchetti elencati sopra!
Portare i tuoi dati in R con il pacchetto rio
Questo “coltellino svizzero per l'Input/Output di dati” rende più semplice l'input e l'output di dati in R! Puoi in- o esportare dati da quasi qualsiasi formato di file: quando installi il pacchetto rio, riunisci molti pacchetti separati di lettura dati in uno solo. Se poi vuoi importare o esportare dati, devi solo ricordare due funzioni: import() e export(): rio si affiderà ai singoli pacchetti di lettura dati per dedurre la struttura dei dati dall'estensione del file, leggere nativamente fonti web e impostare valori predefiniti ragionevoli per import ed export.
In breve, rio supporta un ampio set di formati di file comunemente usati per importazione ed esportazione.
L'importazione dei file con rio avviene così:
library(rio)
data <- import("<Path to your file>")
Se vuoi vedere esattamente quali formati di file sono supportati da rio, visita questa pagina.
In chiusura
Se ti interessa approfondire il lavoro con i big data in R, assicurati di dare un'occhiata ai corsi How To Work With Quandl in R e “Big Data Analysis With Revolution R Enterprise” su DataCamp!
Argomenti
