Come importare dati in R: guida completa

Primi passi con l'importazione dei dati in R

R è uno strumento statistico versatile. Rispetto ad altri software come Microsoft Excel, R offre caricamenti più rapidi, pulizia dei dati automatizzata e analisi statistiche e predittive approfondite. Tutto questo si ottiene con pacchetti R open-source, e vedremo come usarli per importare vari tipi di dataset. 

Useremo DataLab per eseguire gli esempi di codice. Include pacchetti preinstallati e l'ambiente R. Non devi configurare nulla: puoi iniziare a programmare in pochi secondi. È un servizio gratuito e mette a disposizione una vasta selezione di dataset. 

Se preferisci lavorare in locale, consulta la nostra guida su come installare R su Windows, Mac e Ubuntu.

Installare i pacchetti necessari

Dopo aver caricato il workbook DataLab, devi installare alcuni pacchetti meno diffusi ma necessari per caricare file SAS, SPSS, Stata e Matlab. 

Il set di pacchetti Tidyverse include vari strumenti per leggere flat file, pulire i dati, effettuare manipolazioni, visualizzazioni e molto altro.

Possiamo installare i pacchetti uno alla volta usando la funzione install.packages(). 

install.packages('tidyverse',dependency=T)

Possiamo anche installare più pacchetti insieme elencandoli nella funzione c(). Dopo l'installazione, li carichi nell'ambiente locale con library(). In questo caso ho avvolto library() in suppressPackageStartupMessages() per avere un output più conciso. 

install.packages(c('quantmod','ff','foreign','R.matlab'),dependency=T)

suppressPackageStartupMessages(library(tidyverse))

Come vedi, mi sono assicurato di installare le dipendenze usando il parametro dependency=T in install.packages().

TL;DR

• Usa readr::read_csv() per i file CSV e readxl::read_excel() per i file Excel; entrambi fanno parte del tidyverse

• rjson::fromJSON() gestisce i JSON, mentre RSQLite e DBI si connettono ai database SQL

• Il pacchetto haven legge i file SAS (.sas7bdat), SPSS (.sav) e Stata (.dta)

• xml2 e rvest analizzano XML e fanno scraping di tabelle HTML dal web

• Per file di grandi dimensioni (1 GB+), data.table::fread() è l'opzione più veloce

Importare dati in R dai formati più comuni

Questo tutorial copre i formati più usati in R: CSV, TXT, Excel, JSON, database e file XML/HTML. Vengono trattati anche formati meno comuni come SAS, SPSS, Stata, Matlab e file binari, oltre a come effettuare lo scraping di tabelle HTML e dati XML dal web.  

Riferimento rapido: funzioni di import per tipo di file

Importare dati in R da file CSV e TXT

Iniziamo con due dei formati più comuni: CSV e TXT.

Importare un file CSV in R

In questa sezione, leggeremo dati in R caricando un file CSV da Hotel Booking Demand. Questo dataset contiene dati sulle prenotazioni di un city hotel e di un resort. Per importare il file CSV, useremo la funzione read_csv() del pacchetto readr. Come in Pandas, richiede di indicare il percorso del file per elaborarlo e caricarlo come dataframe. 

Puoi anche usare le funzioni read.csv() o read.delim() dal pacchetto utils per caricare file CSV. 

data1 <- read_csv('data/hotel_bookings_clean.csv',show_col_types = FALSE)
head(data1, 5)

In modo analogo a read_csv(), puoi anche usare la funzione read.table() per caricare il file. Assicurati di aggiungere un delimitatore come la virgola e header = 1. In questo modo la prima riga verrà impostata come nomi delle colonne invece di V1, V2, ...

data2 <- read.table('data/hotel_bookings_clean.csv', sep=",", header = 1)
head(data2, 5)

Importare un file TXT in R

In questa parte useremo il dataset Drake Lyrics per caricare un file di testo. Il file contiene i testi delle canzoni del cantante Drake. Possiamo usare la funzione readLines() per caricare il file semplice, ma dovremo svolgere attività aggiuntive per convertirlo in un dataframe. 

Immagine dell'autore | File di testo

Useremo la funzione alternativa di read.table, read.delim(), per caricare il file di testo come dataframe R. Altre funzioni alternative a read.table sono read.csv, read.csv2 e read.delim2.

Nota: per impostazione predefinita separa i valori su Tab (sep = "\t")

Il file di testo contiene testi e non ha una riga di intestazione. Per visualizzare tutti i testi in una riga, dobbiamo impostare header = F. 

Puoi anche usare altri parametri per personalizzare il dataframe, ad esempio il parametro fill, che aggiunge campi vuoti alle righe di lunghezza diversa.

Leggi la documentazione per conoscere tutti i parametri delle funzioni alternative a read.table.  

data3 <- read.delim('data/drake_lyrics.txt',header = F)
head(data3, 5)

Importare dati da Excel in R

In questa sezione useremo il dataset Tesla Deaths da Kaggle per importare da Excel in R. Il dataset riguarda incidenti mortali con veicoli Tesla che hanno causato la morte di un conducente, passeggero, ciclista o pedone. 

Il dataset contiene un file CSV e useremo MS Excel per convertirlo in un file Excel, come mostrato sotto. 

Immagine dell'autore

Useremo la funzione read_excel() del pacchetto readxl per leggere un singolo foglio da un file Excel. Il pacchetto fa parte del tidyverse, ma non del core, quindi va caricato prima di usare la funzione. 

La funzione richiede il percorso dei dati e il numero del foglio. Possiamo anche modificare l'aspetto del dataframe consultando la descrizione degli altri parametri nella documentazione di read_excel.

library(readxl)
data4 <- read_excel("data/Tesla Deaths.xlsx", sheet = 1)
head(data4, 5)

Importare dati da un file JSON

In questa parte caricheremo un JSON in R usando un file dal dataset Drake Lyrics. Contiene testi, titolo del brano, titolo dell'album, URL e numero di visualizzazioni dei brani di Drake. 

Immagine dell'autore

Per caricare un file JSON, importeremo il pacchetto rjson e useremo fromJSON() per il parsing del file. 

library(rjson)
JsonData <- fromJSON(file = 'data/drake_data.json')
print(JsonData[1])

Output:

[[1]]
[[1]]$album
[1] "Certified Lover Boy"

[[1]]$lyrics_title
[1] "Certified Lover Boy* Lyrics"

[[1]]$lyrics_url
[1] "https://genius.com/Drake-certified-lover-boy-lyrics"

[[1]]$lyrics
[1] "Lyrics from CLB Merch\n\n[Verse]\nPut my feelings on ice\nAlways been a gem\nCertified lover boy, somehow still heartless\nHeart is only gettin' colder"

[[1]]$track_views
[1] "8.7K"

Per convertire i dati JSON in un dataframe R, useremo la funzione base R as.data.frame(). 

data5 = as.data.frame(JsonData[1])
data5

Importare dati da un database usando SQL in R

In questa parte useremo il dataset Mental Health in the Tech Industry da Kaggle per caricare database SQLite in R. Per estrarre i dati dai database tramite query SQL, useremo il pacchetto DBI e la funzione SQLite per creare la connessione. Puoi usare una sintassi simile per caricare dati da altri server SQL.  

Caricheremo il pacchetto RSQLite e apriremo il database con la funzione dbConnect. 

Nota: puoi usare dbConnect per caricare dati da MySQL, PostgreSQL e altri server SQL popolari.

Dopo aver caricato il database, mostreremo i nomi delle tabelle.

library(RSQLite)

conn <- dbConnect(RSQLite::SQLite(), "data/mental_health.sqlite")
dbListTables(conn) # 'Answer''Question''Survey'

Per eseguire una query e visualizzare i risultati, useremo la funzione dbGetQuery(). Basta passare un oggetto di connessione SQLite e la query SQL come stringa.  

dbGetQuery(conn, "SELECT * FROM Survey")

Usare SQL all'interno di R ti offre un maggiore controllo sull'ingestione e l'analisi dei dati.  

(data6 = dbGetQuery(conn, "SELECT * FROM Question  LIMIT 3"))

Per saperne di più sull'esecuzione di query SQL in R, segui il tutorial How to Execute SQL Queries in Python and R. Imparerai a caricare database e usare SQL con dplyr e ggplot. 

Importare dati da file XML e HTML

Vediamo ora come importare dati da due tra i linguaggi di markup più diffusi, XML e HTML.

Importare XML in R

In questa sezione caricheremo i dati XML plant_catalog da w3schools usando il pacchetto xml2. 

Nota: puoi anche usare la funzione XMLpackage xmlTreeParse() per caricare i dati.  

Proprio come con read_csv(), possiamo caricare i dati XML fornendo l'URL del sito XML. Verrà caricata la pagina e verranno analizzati i dati XML.

library(xml2)

plant_xml <- read_xml('https://www.w3schools.com/xml/plant_catalog.xml')
plant_xml_parse <- xmlParse(plant_xml)

Successivamente, puoi convertire i dati XML in un data frame R usando la funzione xmlToDataFrame(). 

1. Estrai un set di nodi dai dati XML. 

• Il primo argomento è doc, l'oggetto della classe XMLInternalDocument. 

• Il secondo argomento è path, una stringa che fornisce l'espressione XPath da valutare.

2. Aggiungi plant_node alla funzione xmlToDataFrame() e mostra le prime cinque righe del dataframe R. 

plant_nodes= getNodeSet(plant_xml_parse, "//PLANT")

data9 <- xmlToDataFrame(nodes=plant_nodes)
head(data9,5)

Importare una tabella HTML in R

Questa sezione è divertente: effettueremo lo scraping della pagina Wikipedia della Nazionale di calcio dell'Argentina per estrarre la tabella HTML e convertirla in un dataframe con poche righe di codice. 

Immagine da Wikipedia

Per caricare una tabella HTML, useremo i pacchetti XML e RCurl. Forniremo l'URL di Wikipedia alla funzione getURL() e poi passeremo l'oggetto alla funzione readHTMLTable(), come mostrato sotto. 

La funzione estrarrà tutte le tabelle HTML dal sito e non resterà che esplorarle singolarmente per selezionare quella che ci interessa. 

library(XML)
library(RCurl)

url <- getURL("https://en.wikipedia.org/wiki/Brazil_national_football_team")
tables <- readHTMLTable(url)
data7 <- tables[31]

data7$`NULL`

Inoltre, puoi usare il pacchetto rvest per leggere HTML tramite URL, estrarre tutte le tabelle e visualizzarle come dataframe. 

• read_html(URL) per estrarre dati HTML dai siti web.

• html_nodes(file, "table") per estrarre le tabelle dai dati HTML.

• html_table(tables[25]) per convertire le tabelle HTML in un dataframe. 

library(rvest)

url <- "https://en.wikipedia.org/wiki/Argentina_national_football_team"
file <- read_html(url)
tables <- html_nodes(file, "table")
data8 <- html_table(tables[25])

View(data8)

Se riscontri problemi nel seguire il tutorial, puoi sempre consultare il workbook DataLab con tutto il codice del tutorial. Fanne una copia e inizia a fare pratica. 

Importare dati in R da altri formati

Gli altri formati, meno popolari ma essenziali, provengono da software statistici, Matlab e dati binari. 

Importare dati da un file SAS

In questa sezione useremo il pacchetto haven per importare file SAS. Puoi scaricare i dati dal blog GeeksforGeeks. Il pacchetto haven consente di caricare file SAS, SPSS e Stata in R con pochissimo codice. 

Fornisci il percorso del file alla funzione read_sas() per caricare il file .sas7bdat come dataframe. Leggi la documentazione della funzione per saperne di più.

library(haven)
 
data10 <- read_sas('data/lond_small.sas7bdat')

# display data
head(data10,5)

Importare dati da un file SPSS

Come già sappiamo, possiamo usare anche il pacchetto haven per caricare file SPSS in R. Puoi scaricare i dati dal blog GeeksforGeeks e usare la funzione read_sav() per caricare il file sav di SPSS. 

Richiede il percorso del file come stringa e puoi modificare il dataframe usando argomenti aggiuntivi come encoding, col_select e compress.

library(haven)
 
data11 <- read_sav("data/airline_passengers.sav")                       
head(data11,5)

Puoi anche usare il pacchetto foreign per caricare un file .sav come dataframe usando la funzione read.spss(). La funzione richiede solo due argomenti, file e to.data.frame. Scopri gli altri argomenti leggendo la documentazione della funzione. 

Nota: il pacchetto foreign consente anche di caricare formati Minitab, S, SAS, SPSS, Stata, Systat, Weka e Octave.  

library("foreign")
 
data12 <- read.spss("data/airline_passengers.sav", to.data.frame = TRUE)
head(data12,5)

Importare file Stata in R

In questa parte useremo il pacchetto foreign per caricare il file Stata da ucla.edu. 

La funzione read.dta legge i file binari Stata dalle versioni 5 a 12 e li converte in un data frame R.

Nota: per i file Stata dalla versione 13 in poi, usa haven::read_dta(). Il pacchetto haven supporta tutte le versioni di Stata e restituisce un tibble.

library("foreign")

data13 <- read.dta("data/friendly.dta")
head(data13,5)

Importare file Matlab in R

MATLAB è molto diffuso tra studenti e ricercatori. Il pacchetto R.matlab consente di caricare file .mat per poter effettuare analisi e simulazioni in R. 

Scarica i file MATLAB da Kaggle per provarci da solo.

library(R.matlab)

data14 <- readMat("data/cross_dsads.mat")
head(data14$data.dsads)

Importare file binari in R

In questa parte creeremo prima un file binario e poi lo leggeremo con la funzione readBin().

Nota: l'esempio di codice è una versione modificata del blog Working with Binary Files in R Programming.

Per prima cosa, dobbiamo creare un dataframe con quattro colonne e quattro righe.

df = data.frame(
  "ID" = c(1, 2, 3, 4),
  "Name" = c("Abid", "Matt", "Sara", "Dean"),
  "Age" = c(34, 25, 27, 50),
  "Pin" = c(234512, 765345, 345678, 098567)
)

Dopodiché, crea un oggetto di connessione usando la funzione file(). 

con = file("data/binary_data.dat", "wb")

Scrivi i nomi delle colonne nel file con la funzione writeBin().

writeBin(colnames(df), con)

Scrivi il valore di ciascuna colonna nel file.

writeBin(c(df$ID, df$Name, df$Age, df$Pin), con)

Chiudi la connessione dopo aver scritto i dati nel file.

close(con)

Per leggere il file binario, dobbiamo creare una connessione al file e usare la funzione readBin() per visualizzare i dati come interi. 

Argomenti usati nella funzione:

• conn: un oggetto di connessione.

• what: un oggetto il cui mode definisce il tipo del vettore da leggere.

• n: il numero di record da leggere.

con = file("data/binary_data.dat", "rb")
data15_1 = readBin(con, integer(), n = 25)

print(data15_1)

Output:

[1] 1308640329    6647137    6645569    7235920    3276849    3407923
[7] 1684628033 1952533760 1632829556 1140875634    7233893  838874163
[13]  926023733    3159296  892613426  922759729  875771190  875757621
[19]  943142453  892877056

Puoi anche convertire i dati da binario a stringa sostituendo integer() con character() nell'argomento what. 

Leggi la documentazione di readBin() per saperne di più.

con = file("data/binary_data.dat", "rb")
data15_2 = readBin(con, character(), n = 25)

print(data15_2)

Output:

[1] "ID"     "Name"   "Age"    "Pin"    "1"      "2"      "3"      "4"    
[9] "Abid"   "Matt"   "Sara"   "Dean"   "34"     "25"     "27"     "50"   
[17] "234512" "765345" "345678" "98567" 

Impara a importare flat file, software statistici, database o dati direttamente dal web seguendo il nostro corso Intermediate Importing Data in R.

Importare dati in R con QuantMod

Quantmod è un framework per la modellazione finanziaria e il trading in R. Lo useremo per scaricare e caricare i dati di mercato più recenti sotto forma di dataframe. 

Useremo la funzione getSymbols() di quantmod per caricare i dati storici del titolo Google fornendo le date di “from” e “to” e la “frequency”. Per saperne di più su quantmod, leggi la documentazione.

library(quantmod)

getSymbols("GOOGL",
          from = "2022/12/1",
          to = "2023/1/15",
          periodicity = "daily")
# 'GOOGL'

I dati vengono caricati in un oggetto GOOGL e possiamo vedere le prime cinque righe con la funzione head(). 

head(GOOGL,5)

Output:

GOOGL.Open GOOGL.High GOOGL.Low GOOGL.Close GOOGL.Volume
2022-12-01     101.02     102.25    100.25      100.99     28687100
2022-12-02      99.05     100.77     98.90      100.44     21480700
2022-12-05      99.40     101.38     99.00       99.48     24405100
2022-12-06      99.30      99.78     96.42       96.98     24910700
2022-12-07      96.41      96.88     94.72       94.94     31045400
          GOOGL.Adjusted
2022-12-01         100.99
2022-12-02         100.44
2022-12-05          99.48
2022-12-06          96.98
2022-12-07          94.94

Importare dataset di grandi dimensioni in R

Importare un file grande è complicato. Devi assicurarti che la funzione sia ottimizzata per un uso efficiente della memoria e un accesso rapido. 

In questa sezione vedremo funzioni popolari per caricare file CSV oltre 1 GB. Usiamo il dataset US Accidents (2016 - 2021) da Kaggle, che pesa circa 1,15 GB e contiene 2.845.342 record. 

Importare un grande dataset in R con read.table()

Possiamo caricare direttamente lo zip nella funzione utils read.table() usando la funzione unz. Risparmierai il tempo di estrarre e poi caricare il CSV. 

1. Fornisci a unz il percorso dello zip e il file CSV all'interno dello zip.

2. Dopodiché, passa l'oggetto unz alla funzione read.table().

3. Per caricare più velocemente, limiteremo nrows a 10.000.

4. Per impostazione predefinita separa i valori con uno spazio, quindi assicurati di fornire l'argomento sep con una virgola. 

file <- unz("data/US Accidents.zip", "US_Accidents_Dec21_updated.csv")

(data16 <- read.table(file, header=T, sep=",",nrow=10000))

Importare un grande dataset in R con read.csv()

In modo analogo a read.table(), possiamo usare la funzione read_csv() di readr per caricare il file CSV. Invece di nrow, useremo n_max per leggere un numero limitato di record.  

Nel nostro caso, non stiamo limitando i dati e lasciamo che la funzione carichi tutto il dataset. 

Nota: il caricamento completo ha richiesto quasi un minuto. Puoi cambiare il numero di thread per ridurre i tempi. Scopri di più leggendo la documentazione della funzione.

(data17 <- read_csv('data/US_Accidents_Dec21_updated.csv'))

Importare un grande dataset con il pacchetto ff

Possiamo anche usare il pacchetto ff per ottimizzare tempi di caricamento e archiviazione. La funzione read.table.ffdf() carica i dati a blocchi, riducendo il tempo di caricamento.

Prima decomprimeremo il file e poi leggeremo i dati con la funzione read.table.ffdf(). 

unzip('data/US Accidents.zip',exdir='data')

library(ff)

data18 <- read.table.ffdf(file="data/US_Accidents_Dec21_updated.csv",
                          nrows=10000,
                          header = TRUE,
                          sep = ',')
data18[1:5,1:25]

Infine, esamineremo la funzione più usata, fread() del pacchetto data.table, per leggere le prime 10.000 righe. La funzione può riconoscere automaticamente il formato del file, ma in rari casi dovrai fornire l'argomento sep.

Per approfondire la sintassi e le operazioni di data.table, consulta il nostro data.table R Tutorial.

library(data.table)

(data19 <- fread("data/US_Accidents_Dec21_updated.csv",
              sep=',',
              nrows = 10000,
              na.strings = c("NA","N/A",""),
              stringsAsFactors=FALSE
              ))

Importare file Parquet con Arrow

Parquet è un formato di archiviazione colonnare sempre più usato per grandi dataset analitici. Il pacchetto arrow legge file Parquet in R con alte prestazioni e basso uso di memoria.

library(arrow)

parquet_data <- read_parquet("data/example.parquet")
head(parquet_data, 5)

Arrow supporta anche la lettura da bucket S3 e Google Cloud Storage. Per dataset troppo grandi per stare in memoria, usa open_dataset() per elaborare i file a blocchi senza caricare tutto in una volta.

Riferimenti ai dataset

Se vuoi provare in autonomia gli esempi di codice, ecco l'elenco di tutti i dataset usati nel tutorial.

1. CSV: Hotel Booking Demand
2. TXT: Drake Lyrics
3. Excel: Tesla Deaths
4. JSON: Drake Lyrics
5. DB SQL: Mental Health in the Tech Industry
6. XML: w3schools
7. HTML: Nazionale di calcio dell'Argentina
8. SAS: SAS Files - GeeksforGeeks
9. SPSS: SPSS Files - GeeksforGeeks
10. Stata: Applied Regression Analysis by Fox Data Files
11. Matlab: Cross-position activity recognition | Kaggle
12. Large Dataset: US Accidents (2016 - 2021)

Considerazioni finali

R gestisce nativamente un'ampia gamma di formati, dai CSV ed Excel ai database SQL e ai file dei software statistici. Una volta caricati i dati, puoi passare alla pulizia con il corso Cleaning Data in R, quindi all'analisi esplorativa e alla visualizzazione.

In questo tutorial abbiamo visto come caricare tutti i tipi di dataset usando i popolari pacchetti R per uno storage e prestazioni migliori. Se vuoi iniziare la tua carriera data science con R, scopri il nostro percorso Data Scientist with R. Include 24 corsi interattivi su programmazione in R, analisi statistica, gestione dei dati e analisi predittiva. Dopo aver completato il percorso, puoi anche sostenere un esame di certificazione. 

Dai un'occhiata anche al workbook Import Data Into R su DataLab, con codice sorgente, output e repository dati. Puoi farne una copia e iniziare a imparare in autonomia.