¿Donde están los datos?

• En muchos sitios, pero básicamente en 2:

  • en bases de datos (RDBMS, noSQL, etc ...): una base de datos es una herramienta que almacena datos de forma organizada.

  • en ficheros

Además, los datos más habituales en CC.SS son datos tabulares

• formatos tabulares: .csv, .xlsx, .sav , .dta, etc ...

• no tabulares: .json, .xml, etc ...

Cuando cargemos/importemos esos datos tabulares ....

• Habitualmente, se almacenarán internamente en R como data.frames (o tibbles)

Unas ideas generales

• Ya sabemos que generalmente usaremos datos tabulares provenientes de archivos, que se almacenaran en R como data.frames

• RStudio permite cargar datos a través de menús (File > Import Dataset). Por menús se pueden cargar datos CSV, EXCEL, SPSS, SAS y STATA. Se puede hacer, pero no lo haremos, ¿por qué?

• Para importar y exportar los datos usaremos funciones, funciones que pertenecen a algún paquete. Podríamos usar los paquetes de R-base, pero ya sabéis que el curso está orientado al tidyverse.

• Los principales paquetes del tidyverse para importar y exportar datos son: readr, haven y readxl.

  A pesar de ello ... usaremos el paquete rio

• A pesar de ello, vamos a usar un paquete que, sin que lo veamos, llama/utiliza indirectamente esos paquetes y otros, y que permite importar y exportar ficheros en casi cualquier formato.

• Utilizaremos el paquete rio. En su web pone que el paquete rio es "A Swiss-Army Knife for Data I/O".

Bueno, ya vale de "teoría", vamos a aprender a cargar/importar datos mediante una serie de ejemplos

???

• quizas ir a la web de rio para ver los disntintos formatos
  • para .csv usa data.table

Datos almacenados en los paquetes

• Sí, los paquetes suelen tener funciones y documentación, pero también datos.

• Intenta entender que hacen las siguientes instrucciones. En nada lo explico yo.

#- cuanto iniciamos R se cargan automaticamente un grupo de paquetes (R-base)
print(.packages()) #- [🌶]imprimimos los nombres de los "currently attached packages"
#- en uno de esos paquetes hay un conjunto de datos llamado "iris"
iris          #- llamamos a "iris"
str(iris)     #- qué es iris?
find("iris")  #- [🌶] ¿donde estaba iris?
my_iris <- iris  #- "hacemos una copia" de iris
find("my_iris")  #- ¿donde está my_iris?
iris <- iris     #- ???
find("iris")     #- ¿donde está ahora iris?Copy Code

Ejercicio: datos almacenados en los paquetes

#- en el pkg palmerpenguins hay 2 conjuntos de datos
library(palmerpenguins) #- install.packages("palmerpenguins")
#- ya podemos usar los datos de penguins xq hemos cargado (attach) el paquete en memoria de R
penguins
my_penguins <- penguins
#- quiero tb hablaros de la siguiente expresión 
#- es importante acostumbrarse a ella [ 🌟 ]
palmerpenguins::penguinsCopy Code

Importando datos con el paquete rio

• rio solo tiene dos funciones: import() y export(). ¿Adivinas que hace cada una de ellas?

• Empecemos con import(). La función import() tiene varios argumentos, pero generalmente solo usaremos el primero.

• Su primer argumento se llama file y su descripción es: "A character string naming a file, URL, or single-file .zip or .tar archive". WTF!!

rm(list = ls()) #- antes vamos a limpiar el Global env.
la_direccion <- "https://raw.githubusercontent.com/perezp44/iris_data/master/data/iris.csv"
rio::import(la_direccion)    #- ¿qué ha pasado???
iris <- rio::import(la_direccion)  #- y ahora ¿qué ha pasado?Copy Code

rm(list = ls()) #- antes vamos a limpiar el Global env.
la_direccion <- "https://raw.githubusercontent.com/perezp44/iris_data/master/data/iris.csv"
iris_1 <- rio::import(la_direccion)  #- como un data.frame
iris_2 <- rio::import(la_direccion, setclass = "tibble")  #- como tibble
iris_3 <- tibble::as_tibble(iris_1) #- convertimos df_1 a tibbleCopy Code

Exportando datos con el paquete rio

• Tenéis que usar la función rio::export(). Esta función también tiene varios argumentos, pero los principales son los dos primeros, llamados "x" y "file"

rm(list = ls())  #- [🌶] antes vamos a limpiar el Global env.
my_iris <- iris
rio::export(my_iris, "my_iris.csv")             #- sin los nombres de los argumentos
rio::export(x = my_iris, file = "my_iris.csv")  #- CON los nombres de los argumentos
#- IMPORTANTE: ¿Donde hemos guardado my_iris? [ 🌟 ]Copy Code

fs::dir_create("pruebas")   #- [🌶] creo el subdirectorio
rio::export(my_iris, "./pruebas/my_iris.csv")Copy Code

la_ruta <- here::here("pruebas", "my_iris.csv")
rio::export(my_iris, la_ruta)
rio::export(my_iris, here::here("pruebas", "my_iris.csv"))Copy Code

Seguimos exportando datos con el paquete rio

rio::export(iris, here::here("pruebas", "iris.csv"))
rio::export(iris, here::here("pruebas", "iris.xlsx"))
rio::export(iris, here::here("pruebas", "iris.sav"))Copy Code

rio::export(palmerpenguins::penguins, here::here("pruebas", "pinguinos.csv"))
rio::export(palmerpenguins::penguins, here::here("pruebas", "pinguinos.xlsx"))
rio::export(palmerpenguins::penguins, here::here("pruebas", "pinguinos.dta"))Copy Code

Seguimos importando datos con el paquete rio

rm(list = ls())
iris_1 <- rio::import(here::here("pruebas", "iris.csv"))
iris_2 <- rio::import(here::here("pruebas", "iris.xlsx"))Copy Code

Una última cosa: descargar ficheros con R

Es importante que diferenciéis entre descargarse un fichero y cargar el fichero en R, cargar el fichero en memoria de R

• Con download.file() descargamos el fichero y lo guardamos en un fichero en nuestro ordenador

#- en esta url hay un fichero de datos en formato .csv
my_url <- "https://raw.githubusercontent.com/perezp44/iris_data/master/data/iris.csv"
download.file(url = my_url, 
              destfile = here::here("pruebas", "iris_descargado.csv"))Copy Code

• Con rio::import() NO guardamos el fichero, sino que lo cargamos en memoria de R, en el Global Env.

aa <- rio::import(my_url)Copy Code

Bonus 1: exportar los datos de un df en un archivo .xlsx ya existente.

#- bonus: le añadimos un libro mas al archivo "./pruebas/iris.xlsx"
rio::export(x = iris, 
       file = here::here("pruebas", "iris.xlsx"), 
       which = "iris_2")Copy Code

Bonus 2: (!!) exportar 2 df's en un único archivo .xlsx

rio::export(x = list(iris = iris, pinguinos = palmerpenguins::penguins), 
            file = here::here("pruebas", "my_iris_pinguinos.xlsx"))Copy Code

Bonus 3: (!!) importar una hoja/libro especifica de un archivo .xlsx

iris_1 <- rio::import(here::here("pruebas", "my_iris_pinguinos.xlsx"))  #- solo importa el primer libro
pinguinos_1 <- rio::import(here::here("pruebas", "my_iris_pinguinos.xlsx"), 
                                      sheet = 2)
pinguinos_2 <- rio::import(here::here("pruebas", "my_iris_pinguinos.xlsx"), 
                                      sheet = "pinguinos")Copy Code

Bonus 4: (!!!!) importamos todos los libros de un archivo .xlsx

library(readxl)
my_dfs_list <- lapply(excel_sheets(here::here("pruebas", "my_iris_pinguinos.xlsx")), 
                       read_excel,
                       path = here::here("pruebas", "my_iris_pinguinos.xlsx"))Copy Code

Bonus 5: (!!!!!!) importamos todos archivos de datos de una carpeta concreta; por ejemplo vamos a cargar en memoria de R todos los ficheros de datos que tenemos en la carpeta "pruebas"

#- importamos todos los archivos que hemos creado en "./pruebas/"
library(purrr)
my_carpeta <- here::here("pruebas")
lista_de_archivos <- list.files(my_carpeta)  #- Ok con base ...
lista_de_archivos <- fs::dir_ls(my_carpeta)  #- pero mejor con el pkg "fs"
my_dfs_list_2 <- map(lista_de_archivos, rio::import)Copy Code

Vamos a dejar limpia la carpeta "./pruebas/"

#- vamos a limpiar el Rproject: vamos a borrar los archivos q hemos creado:
list.files("./pruebas")     #- listado de archivos en la carpeta "./pruebas"
file.remove("./pruebas/pinguinos.dta")   #- borramos un archivo
#- borramos todos los archivos de ./pruebas/
file.remove(file.path("./pruebas", list.files("./pruebas"))) 
#- borramos toda la carpeta con el pkg fs
fs::dir_delete("pruebas")Copy Code

Formatos de datos propios de R

• Guardar datos en formatos como .csv o .xlsx es lo más habitual si quieres abrir estos datos en otros programas, pero ...

• ... pero al grabar en estos formatos guardas los datos, PERO no guardas los metadatos; por ejemplo, si una columna la has definido como un factor o como integer, esta información se perderá. En estos casos, una solución es usar los formatos propios de R.

R tiene 2 formatos propios de datos (.rds y .rda)

• si quieres grabar un solo objeto, es preferible hacerlo como .Rds

• si quieres grabar varios objetos tienes que hacerlo como RData o abreviado como .Rda

Formato .RData

El formato .RData tienen la ventaja de que puedes guardar varios objetos a la vez.

Una “desventaja” del formato RData es que al importar un fichero .RData, los objetos que contiene se cargan siempre con el nombre con el que fueron grabados.

• Exportando datos a formato .Rda

save(mtcars, iris,  file = here::here("pruebas", "mtcars_and_iris.RData")Copy Code

• Importando datos en formato .Rda: tienes que usar la función load()

load(here::here("pruebas", "mtcars_and_iris.RData"))Copy Code

Formato .rds

• (3 formas de) Exportar datos a formato .rds

saveRDS(iris, here::here("pruebas", "iris_1.rds"))          #- con base-R
readr::write_rds(iris, here::here("pruebas", "iris_2.rds")) #- con pkg "readr"
rio::export(iris, here::here("pruebas", "iris_3.rds"))Copy Code

• (3 formas de) Importar datos en formato .rds

my_iris_1 <- readRDS(here::here("pruebas", "iris_3.rds"))  #- con R-base
my_iris_1 <-readr::read_rds(here::here("pruebas", "iris_3.rds")) #- tidyverse
my_iris_2 <- rio::import(here::here("pruebas", "iris_3.rds"))Copy Code

Eurostat

# install.packages("eurostat")
library(eurostat)
df <- get_eurostat("cult_emp_sex", time_format = 'raw', keepFlags = T)       #- bajamos los datos de la tabla "cult_emp_sex": empleo cultural por genero"Copy Code

Si quieres probar tu mismo a bajar datos de Eurostat:

# install.packages("eurostat")
library(eurostat)
#- podemos buscar un  "tema" con la f. search_eurostat()
aa <- search_eurostat("employment", type = "all") 
#- elegimos una tabla de Eurostat
my_table <- "hlth_silc_17"   #- elegimos una tabla; por ejemplo "hlth_silc_17": "Healthy life expectancy based on self-perceived health"
label_eurostat_tables(my_table) #- da informacion sobre la Base de datos q estas buscando
#-  descargamos los datos con get_eurostat()
df <- get_eurostat(my_table, time_format = "raw", keepFlags = TRUE )   #- bajamos los datos de una tabla
df_l <- label_eurostat(df)        #- pone labels: mas legible, menos fácil de programarCopy Code

El paquete quantmod

Permite acceder a una gran variedad de datos económicos. Aquí está su web.

library(quantmod)  #- install.packages("quantmod")
#- For stocks and shares, the yahoo source is used. 
facebook  <- getSymbols(Symbols = 'FB', src = 'yahoo', auto.assign = FALSE)  
#- For currencies and metals, the oanda source is used. S
tc_euro_dolar <- getSymbols(Symbols = 'EUR/USD', src = 'oanda', auto.assign = FALSE)   
#- For economics series, the FRED source is used. 
Japan_GDP <- getSymbols(Symbols = 'JPNNGDP', src = 'FRED', auto.assign = FALSE)Copy Code

Webscrapping (ejemplo 1)

• Pueblos más "altos" de Teruel: aquí puedes ver la tabla

library(rvest)
library(tidyverse)
my_url <- "https://es.wikipedia.org/wiki/Anexo:Municipios_de_la_provincia_de_Teruel"
content <- read_html(my_url)
body_table <- content %>% html_nodes('body')  %>%
                    html_nodes('table') %>%
                    html_table(dec = ",") 
#- solo hay una tabla
Teruel <- body_table[[1]]  #- estoy haciendo subsetting de una listaCopy Code

• Vamos a arreglar un poco la tabla

names(Teruel) <- c("Nombre", "Extension", "Poblacion", "Densidad", "Comarca", "Partido_judicial", "Altitud")
library(stringr)
Teruel <- Teruel %>% map(str_trim) %>% as_tibble() #- quita caracteres al final
Teruel <- Teruel %>% mutate(Altitud = str_replace_all(Altitud,"[[:punct:]]", "")) 
Teruel <- Teruel %>% mutate(Altitud = as.double(Altitud)) %>% arrange(desc(Altitud))Copy Code

Webscrapping (ejemplo 2)

• Covid: en esta página tenemos datos sobre covid.

library(rvest)
library(tidyverse)
my_url <- "https://es.wikipedia.org/wiki/Pandemia_de_enfermedad_por_coronavirus_de_2020_en_Espa%C3%B1a"
content <- read_html(my_url)
body_table <- content %>% 
              html_nodes('body')  %>%
              html_nodes('table') %>%
              html_table(dec = ",", fill = TRUE) 
#- la página web tiene 10 tablas, seleccionamos 2 
tabla_6 <- body_table[[6]]  
tabla_7 <- body_table[[7]]Copy Code

• Un artículo donde se valoran las ventajas e inconvenientes de introducir Web scrapping en el curriculum

Ejercicio:

• Resulta que quiero saber que provincia tiene más municipos, así que me voy al INE, concrétamente aquí. En esa página hay un fichero que nos permitirá contar el nº de municipios.

rm(list = ls())  #- antes vamos a limpiar el Global env.
my_url <- "https://www.ine.es/daco/daco42/codmun/codmun20/20codmun.xlsx"
download.file(my_url, here::here("pruebas", "ine_rel_muni.xlsx")) #- lo guardo en disco
df_1 <- rio::import(my_url)Copy Code

df_2 <- readxl::read_xlsx(my_url, skip = 1)  #- no funciona. solo lee del PC
df_2 <- readxl::read_xlsx(here::here("pruebas", "ine_rel_muni.xlsx"), skip = 1)Copy Code

Podemos hacerlo un poco más "profesional", por ejemplo ...

• Descargo el archivo en una carpeta temporal [🌶]

#- script para bajar la relación de municipios INE a 1 de enero de 2021 
url_descarga <- "https://www.ine.es/daco/daco42/codmun/diccionario21.xlsx"
nombre_fichero <- "diccionario21.xlsx"
fs::dir_create("tmp")   #- creo un directorio temporal
my_ruta <- here::here("tmp", nombre_fichero) #- ruta para guardar el fichero
curl::curl_download(url = url_descarga, destfile = my_ruta)Copy Code

• Importo el fichero a la memoria de R

df <- readxl::read_xlsx(path = my_ruta, skip = 1)
#- la verdad es que skip = 1 también hubiese funcionado con el paquete `rio` 
#- ya que `rio` llama a `readxl`Copy Code

... seguimos con el ejemplo

• Arreglo los datos a mi gusto [🌶]

library(tidyverse)
df <- df %>% 
      mutate(ine_muni = paste0(CPRO, CMUN)) %>% 
      mutate(year = "2021") %>%          #- !! cómo lo guardaría?
      mutate(year = as.numeric(year)) %>% 
      rename(ine_muni.n = NOMBRE) %>% 
      rename(ine_prov = CPRO) %>% 
      select(ine_muni, ine_muni.n, ine_prov, year) 
str(df)Copy Code

• Exporto el archivo (por si lo quiero guardar)

readr::write_csv(df, file = here::here("tmp", "my_relacion_muni_2021.csv"))Copy Code

Como véis no he contado el nº de municipios por provincia

• Se puede hacer de varias maneras, abajo tienes 2:

df_muni <- df %>% group_by(ine_prov) %>% summarise(numero_muni = n())
df_muni <- df %>% count(ine_prov)Copy Code

Si quisiéramos saber el nombre de las provincias ...

• tenemos que cargar un nuevo fichero con esa información:

codigos_prov <- pjpv.datos.01::pob_prov_1996_2020 %>% filter(year == 2020)
str(codigos_prov)Copy Code

• Para finalmente fusionar los 2 ficheros:

#- fusiono los 2 ficheros (lo veremos!!)
df_ok <- left_join(df_muni, codigos_prov)Copy Code

• Borro la carpeta tmp para dejar el Rproject limpio

fs::dir_delete("tmp")  #- [🌶] borro el directorio temporalCopy Code

disgresión: es lo mismo un data.frame que una tibble [🌶🌶🌶]

• Sí y no (!!!). Para nosotros serán equivalentes. Podemos pensar que las tibbles son data.frame's modernizados o tuneados.

• Las dos son estructuras de R para almacenar datos. Si quieres ver en qué se diferencian ve aquí

typeof(iris)
#> [1] "list"
class(iris)
#> [1] "data.frame"
names(attributes(iris))
#> [1] "names"     "class"     "row.names"
iris_2 <- tibble::as_tibble(iris)
typeof(iris_2)
#> [1] "list"
class(iris_2)
#> [1] "tbl_df"     "tbl"        "data.frame"
names(attributes(iris_2))
#> [1] "class"     "row.names" "names"Copy Code

• Alguna funciones antiguas puede que no funcionen con tibbles. Si te pasa esto, tienes que usar as.data.frame(). Puedes leerlo aquí

no siempre es fácil publicar bien unos datos

para descargar ficheros es mejor usar curl::curl()

• curl::curl() mejor que download.file(). Razones aquí.

curl::curl_download(
      url = "https://direccion-al-archivo.gpx", 
      destfile = "./datos/pruebas/my_archivo.gpx")Copy Code

si desde R quieres importar/exportar a Excel ...

• Si desde R quieres leer/escribir ficheros de Excel complejos, quizás ahora mismo el mejor pquete para ello es openxlsx. Además ya no depende de Java.

¿por qué usar here::here()?

• Es denso, pero el mejor post que he leído sobre el tema.

Para cargar .Rda desde la web

#- hay que usar load(url())
df <- load(url('http://gedemced.uab.cat/images/POP_ENC_AMB_2014.Rdata'))
#- pero si no funciona, usa  repmis::source_data()
my_url <- "https://github.com/perezp44/LAU2boundaries4spain/blob/master/data/Provincias.rda?raw=true"
df <- load(url(my_url)) #- no funciona
df <- repmis::source_data(my_url)Copy Code

el buscador de datos de Google

• Os puede servir para vuestros trabajos: https://datasetsearch.research.google.com/

selecciónando manualmente un archivo de datos

• Este truco es chulo ... pero no hay que hacerlo

my_data <- rio::import(file.choose())Copy Code

algunas referencias

• El capítulo de importación e datos de R4DS.

• Un buen capítulo sobre importación de datos en R.

• Muy buen tutorial

• Unas buenas transparencias de Earo Wang. Aquí están sus datos.