Descargar,
importar (y exportar)
datos con R

Curso de Introducción a R (SFPIE)
(Web del curso aquí)

Descargar datos con R


¿Cómo solemos descargar unos datos?


¿Y cómo se descargan datos con R?

  • Usando código

  • Al principio es un poco más complicado, pero tiene ventajas, y además estamos aprendiendo R

  • Veámoslo con un ejemplo

Tarea: descargar un fichero de datos con R



  • Intenta descargar el fichero con R.


  • En los siguientes “Tabs” tienes pistas y luego la solución

  1. Usaremos la función download.file()

  2. download.file() tiene varios argumentos. Nos centramos en los 2 primeros: url y destfile


  1. Tendrás que dar valores a esos dos argumentos:

    • el url donde está el fichero de datos

    • la ruta de tu ordenador donde quieres guardar los datos. (Lo guardaremos en la subcarpeta “pruebas”)


  1. Recuerda que estamos trabajando con proyectos, así que podemos usar rutas relativas
1my_url <- "https://raw.githubusercontent.com/perezp44/archivos_download/refs/heads/master/plazas_turisticas.csv"

2fs::dir_create("pruebas")

3download.file(my_url, "./pruebas/plazas_turisticas.csv")

4download.file(url = my_url,
              destfile = "./pruebas/plazas_turisticas.csv")
1
Almacenamos la url en el objeto my_url
2
Creamos, con código, una carpeta llamada pruebas donde guardaremos los datos
3
Usamos la función download.file() para descargar los datos que hay en my_url. Los guardamos en la carpeta pruebas de nuestro proyecto. Concretamente en el fichero plazas_turisticas.csv
4
Hace exactamente lo mismo que 3, pero esta vez, hemos especificado el nombre de los dos argumentos de la función 


my_url <- "https://raw.githubusercontent.com/perezp44/archivos_download/refs/heads/master/plazas_turisticas.csv"  

1my_ruta <- "./pruebas/plazas_turisticas.csv"


2curl::curl_download(url = my_url,
                    destfile = my_ruta)
1
Es bueno hacer el código modular (por si queremos cambiar las rutas en el futuro). Por eso, especificamos en my_ruta el sitio donde guardaremos los datos
2
Usamos curl::curl_download() para descargar el fichero. Es una función más moderna que download.file()

Importación de datos


  • La primera etapa de un análisis de datos consiste en cargar los datos en R (en la memoria de R, en el Global)

podemos usar/cargar datos de los paquetes

  • Muchos paquetes de R contienen datos que podemos usar


… intenta entender el siguiente chunk de código


#- cuando iniciamos R se cargan automáticamente 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"
find("iris")  #- [🌶] ¿donde está iris?
str(iris)     #- qué es iris?


my_iris <- iris  #- "hacemos una copia" de iris en el Global
find("my_iris")  #- ¿donde está my_iris?

iris <- c(2, 4)    #- creamos un vector llamado iris
find("iris")       #- ¿donde está ahora iris?


Tarea: usar unos datos de un paquete


  • Quiero usar el conjunto de datos flows que está en el paquete refugees


  • refugees es un paquete que no está en R-base


  • Lógicamente, para poder usar esos datos, tenemos que tener instalado el paquete. Podemos hacerlo con install.packages("refugees")


  • Después hay que cargar el paquete con library(refugees)


  • Una vez hecho esto, ya podemos ver y usar el conjunto de datos flows


1library(refugees)

2my_flows <- flows
1
Cargamos el paquete en el Global, en la memoria de R.
Lógicamente antes hay que instalar el paquete con install.packages("refugees").
2
Creamos un objeto llamado my_flows que es una “copia” de los datos en flows 


1my_flows_2 <- refugees::flows
1
Es una forma alternativa de cargar los datos de flows sin cargar todo el paquete

… seguimos importando


  • Vamos a cargar en R datos que tenemos en nuestro ordenador


  • Posiblemente, los hemos descargado previamente de la WEB

Los datos más habituales en Ciencias Sociales son los datos tabulares

  • Hay múltiples formatos tabulares: .csv, .xlsx, .sav , .dta, etc …

Cuando carguemos/importemos esos datos tabulares en R …

  • Se almacenarán internamente en R como data.frames

RStudio permite cargar datos usando menús.

  • Usando menús (File > Import Dataset) se pueden cargar datos CSV, EXCEL, SPSS, SAS y STATA.

  • Se puede hacer con menús, pero nosotros usaremos código


(La razón es que queremos que nuestros análisis sean reproducibles)

Para importar (y exportar) datos utilizaremos código

  • Usaremos funciones, concretamente funciones del paquete rio que permite importar y exportar ficheros en casi cualquier formato.


  • Para importar datos en R usaremos la función rio::import()
  • Para exportar datos en R usaremos la función rio::export()

importando datos con rio::import()

  • La función rio::import() tiene varios argumentos, pero solo usaremos el primero.


  • Su primer argumento se llama file y su descripción dice que … el valor de file ha de ser: “A character string naming a file, URL, or single-file .zip or .tar archive”.   WTF!!


  • Es decir, el valor de file ha de ser la ruta (de nuestro ordenador) donde están los datos que queremos importar


  • Bueno, … en realidad también podemos importar directamente desde un “url”


Tarea: importar a R datos que tenemos guardados en nuestro ordenador


  • ¿Te acuerdas de que antes hemos descargado unos datos en el fichero ./pruebas/plazas_turisticas.csv?


  • La tarea consiste en cargar esos datos en R (en el Global, en memoria de R)


  • Has de usar la función rio::import()


  • En su primer argumento (llamado file) has de especificar la ruta donde están los datos


  • Recuerda que hemos guardado los datos en "./pruebas/plazas_turisticas.csv"


1my_ruta <- "./pruebas/plazas_turisticas.csv"

2df <- rio::import(my_ruta)
1
Guardamos en my_ruta la ruta a los datos que quiero importar
2
Creamos un objeto llamado df con los datos que hay en my_ruta 


my_ruta <- "./pruebas/plazas_turisticas.csv"   

1df <- rio::import(file = my_ruta)
1
Esta vez ponemos tanto el nombre del argumento (file) como el valor del argumento (my_ruta)

Una vez tenemos los datos en R …

  • … podemos comenzar a trabajar en nuestros datos; por ejemplo para limpiarlos


… imagina que alguien nos pide esos datos limpios

¿Qué hacemos?


  • Tendremos que exportar/guardar los datos en un fichero de nuestro ordenador para poder enviárselos

Exportación de datos


  • Vamos a exportar/guardar en nuestro ordenador datos que tengamos en la memoria de R


Exportando datos en R con el paquete rio


  • Para exportar datos en R usaremos la función rio::export()

  • La función rio::export() tiene varios argumentos, pero solo usaremos los dos primeros.


  1. El primer argumento se llama x (su valor ha de ser un objeto/datos de R que queremos exportar)


  1. El segundo argumento se llama file (su valor ha de ser la ruta donde queremos guardar los datos)


Tarea: exportar unos datos de R a un fichero

  • Carga unos datos en R y expórtalos a un fichero en tu ordenador


  • Por ejemplo, utiliza la función rio::export() para exportar a un fichero (de tu ordenador) el conjunto de datos iris en formato .csv
  • Has de usar la función rio::export()


  • Tienes que darle valores a dos argumentos de la función: x y file


(*) el valor de x ha de ser el objeto que quieres exportar (por ejemplo iris)

(*) el valor de file ha de ser la ruta donde quieres guardar los datos


1df <- iris

2rio::export(df, "iris.csv")

3rio::export(x = df,
            file = "iris.csv")
1
Cargamos los datos de iris en R: creamos el objeto df
2
Exportamos df a un fichero llamado iris.csv
3
Hace lo mismo que 2, pero ahora especificamos los nombres de los argumentos ( x y file) de la función rio::export()
  • ¿Donde se ha guardado iris.csv?

  • La respuesta es “en el directorio de trabajo”

  • OK, pero, ¿exactamente donde?

  • Como estamos trabajando en un Rproject, el directorio de trabajo es la propia carpeta del proyecto
  • Por favor, guarda/graba iris.csv en la subcarpeta “pruebas” del Rproject


rio::export(df, "./pruebas/iris.csv") 

rio::export(x = df,                       
            file = "./pruebas/iris.csv")

Práctica: importar/exportar datos

  1. Descarga (usando código) estos datos a tu ordenador: https://raw.githubusercontent.com/perezp44/iris_data/master/data/iris.csv


  1. Importa a R esos datos que has descargado

  2. Exporta los datos a formato .xlsx y .rds


Antes de empezar limpiamos la carpeta pruebas de nuestro proyecto

fs::dir_delete("pruebas")    
fs::dir_create("pruebas")
  1. Descargando los datos
#- en esta url hay un fichero de datos en formato .csv
my_url <- "https://raw.githubusercontent.com/perezp44/iris_data/master/data/iris.csv"

curl::curl_download(url = my_url, 
                    destfile =  "./pruebas/iris.csv")
  1. Importando los datos
my_ruta <- "./pruebas/iris.csv" 

iris <- rio::import(my_ruta)
  1. Exportando los datos
rio::export(x = iris, file = "./pruebas/iris.xlsx")  

rio::export(x = iris, file = "./pruebas/iris.rds")

  • Veremos que … para gestionar/construir nuestras rutas, es conveniente usar here::here()

  • La razón es que favorecerá que nuestros análisis sean reproducibles


1here::here()
1
here::here() devuelve la ruta al directorio de trabajo
Como trabajamos con Rproject’s, entonces devuelve la ruta a la carpeta del Rproject en tú ordenador.
Esto nos será útil cuando trabajemos con ficheros .qmd


  • Lo veremos más adelante en una extensión

Formatos de datos propios de R


  • R tiene 2 formatos de datos propios: .rda y .rds

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!!!


R tiene 2 formatos de datos propios: .rda y .rds

  • Estos formatos sí guardan los metadatos

Formato .rds

  • Exportar datos a formato .rds
rio::export(x = iris, file = "./pruebas/iris.rds")

Extensión: dos formas alternativas de exportar a .rds (😱😱)

(Sí, en R se pueden hacer las cosas de muchas maneras!!! 🚨🚨)

saveRDS(iris, file = "./pruebas/iris.rds")        #- con base-R

readr::write_rds(iris, "./pruebas/iris.rds")      #- con pkg "readr"


  • Importar datos en formato .rds
df <- rio::import(file = "./pruebas/iris.rds")

Extensión: dos formas alternativas de importar .rds

(Sí, en R se pueden hacer las cosas de muchas maneras!!! 🚨🚨)

my_iris_1 <- readRDS("./pruebas/iris.rds")         #- con R-base

my_iris_2 <- readr::read_rds("./pruebas/iris.rds")  #- tidyverse

Formato .RData (o .rda)

  • El formato .RData tiene la ventaja de que puedes guardar varios objetos a la vez
  • Para exportar datos a formato .rda
#- guardamos los objetos mtcars e iris en un fichero llamado "mtcars_and_iris.RData"

save(mtcars, iris,  file = "./pruebas/mtcars_and_iris.RData")


  • Para importar datos en formato .rda, tenemos que usar la función load()
load(file = "./pruebas/mtcars_and_iris.RData")


  • Extensión: Para importar .rda desde la web hay que usar load(url())
#- hay que usar load(url())
#- no funciona xq han borrado el archivo
df <- load(url("http://gedemced.uab.cat/images/POP_ENC_AMB_2014.Rdata"))

#- pero si aún así no funcionase, 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)

Acceder a datos a través de API’s


  • Hay muuuuuchas organizaciones que ofrecen datos a través de API’s y …

  • … en muchas ocasiones, hay un paquete de R para acceder fácilmente a ellos!!!

Eurostat

  • Eurostat es la oficina de estadística de la Unión Europea

  • El paquete eurostat permite acceder a las API’s de Eurostat para obtener datos


  • Por ejemplo aquí puedes ver una de las múltiples tablas de datos que ofrece Eurostat; concretamente la tabla Cultural employment by sex o con siglas “cult_emp_sex”


  • ¿Importamos esa tabla a R con el paquete eurostat?
# install.packages("eurostat")
library(eurostat)

#- importamos los datos de la tabla "cult_emp_sex": "Cultural employment by sex"
df <- eurostat::get_eurostat("cult_emp_sex")

Practica: importar datos de Eurostat

  • Podemos buscar un tema en Eurostat; por ejemplo aquí hay datos de “Employment and unemployment (LFS)”, aquí datos sobre “Population and social conditions” y aquí sobre “Crime and criminal justice”
  • Para mi es más cómodo buscar datos con el paquete eurostat. ¿Probamos?
library(eurostat)

#- podemos buscar un  "tema" con la f. search_eurostat()
my_tema <- "employment"

aa <- eurostat::search_eurostat(pattern = my_tema, type = "all") 

#- elegimos un dataset; por ejemplo "hlth_silc_17"
my_table <- "hlth_silc_17" 

#- da información sobre la Base de datos que estas buscando
eurostat::label_eurostat_tables(my_table) 

#-  importamos los datos de "my_table" con get_eurostat()
df <- eurostat::get_eurostat(my_table, time_format = "raw", keepFlags = TRUE )   

#- pedimos los descriptores/labels de las series
df_l <- eurostat::label_eurostat(df)

El paquete quantmod

  • Permite acceder a una gran variedad de datos económicos. Aquí tienes información


library(quantmod)  #- install.packages("quantmod")

#- For stocks and shares, the yahoo source is used. 
facebook  <- getSymbols(Symbols = 'F', src = 'yahoo', auto.assign = FALSE)  
barChart(facebook) 

#- For currencies and metals, the oanda source is used.
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)

Algunos BONUS de I/O


  • Con lo que hemos visto hasta ahora nos apañamos, pero conviene ver alguna cosa más …

Bonus 1 (🌶🌶 … 🌶): exportar los datos de un df a un archivo .xlsx ya existente



#- bonus: le añadimos un libro mas al archivo "./pruebas/iris.xlsx"

rio::export(iris, "./pruebas/iris.xlsx")  #- por si acaso lo hubiésemos borrado


rio::export(iris, "./pruebas/iris.xlsx", which = "iris_2")

#- lo mismo pero poniendo los nombres de los argumentos
rio::export(x = iris, 
           file ="./pruebas/iris.xlsx", 
           which = "iris_3")


  • Esta solución ya no funciona 😱 !!
  • Tendremos que usar nuevo paquete: openxlsx
#- tenemos que usar el pkg openxlsx
library(openxlsx) #- pak::pak("openxlsx")

#- tenemos que crear un "Woorkbook" con la f. loadWorkbook()
my_workbook <- openxlsx::loadWorkbook("./pruebas/iris.xlsx")

#- ahora añadimos hojas/sheets al Woorkbook
openxlsx::addWorksheet(my_workbook, "iris_2")
openxlsx::addWorksheet(my_workbook, "my_mtcars")

#- ahora escribimos datos en las nuevas hojas/sheets q hemos creado
openxlsx::writeData(my_workbook, sheet = "iris_2",    x = iris)
openxlsx::writeData(my_workbook, sheet = "my_mtcars", x = mtcars)

#- exportamos/guardamos el archivo (con las nuevas sheets)
openxlsx::saveWorkbook(my_workbook, "./pruebas/iris.xlsx", overwrite = TRUE)

Bonus 2 (🌶🌶🌶): exportar 2 df’s en un único archivo .xlsx


  • Seguimos usando el paquete rio, pero …
      … los objetos que queremos exportar se incluyen dentro de la función list()


rio::export(x = list(my_iris = iris, my_pinguinos = penguins), 
            file = "./pruebas/my_iris_pinguinos.xlsx")

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


  • Seguimos usando el paquete rio, pero …
      … tenemos que usar un nuevo argumento: sheet


iris_1 <- rio::import("./pruebas/my_iris_pinguinos.xlsx")  #- solo importa el primer libro
  

pinguinos_1 <- rio::import("./pruebas/my_iris_pinguinos.xlsx", sheet = 2)


pinguinos_2 <- rio::import(file = "./pruebas/my_iris_pinguinos.xlsx", 
                           sheet = "my_pinguinos")

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


library(readxl) #- necesitamos la función readxl::excel_sheet()

mys_sheets <- readxl::excel_sheets(here::here("pruebas", "my_iris_pinguinos.xlsx"))

#- con base::lapply()
my_dfs_list <- lapply(mys_sheets,
                      readxl::read_excel,
                      path = here::here("pruebas", "my_iris_pinguinos.xlsx"))
#- con purrr::map()
my_dfs_list <- purrr::map(mys_sheets, 
                           readxl::read_excel,
                           path = here::here("pruebas", "my_iris_pinguinos.xlsx"))


  • Ok, pero ahora tenemos los 2 data.frames dentro de una lista ¿qué hacemos?
#- Extrayendo un data.frame de una lista: con [[]]
my_iris <- my_dfs_list2[[1]]

Bonus 5: (!!!!!!) importamos todos archivos de datos de una carpeta concreta


#- importamos todos los archivos que hemos creado en "./pruebas/"
library(purrr)
my_carpeta <- here::here("pruebas")

lista_de_archivos <- fs::dir_ls(my_carpeta) 

my_dfs_list_2 <- map(lista_de_archivos, rio::import)


  • Ya veremos, con un ejemplo, cómo podemos juntar todos los df’s en un único data.frame

Extensiones



Webscrapping [🌶🌶🌶 🌶🌶]

  • Webscrapping consiste en obtener datos directamente de páginas web, de su código html.

Webscrapping (ejemplo 1)

  • Para obtener esos datos en R, podemos usar el paquete rvest
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 lista


  • Podemos arreglar un poco la tabla (!!!!!!!!)
names(Teruel) <- c("Nombre",  "Poblacion", "Superficie",
                   "Densidad", "Altitud", "Comarca", "Partido_judicial")
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))

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

Sí y no (!!!)

  • No son exactamente lo mismo, pero para nosotros son totalmente equivalentes. Podemos pensar que las tibbles son data.frame’s modernizados o tuneados
  • Las dos son estructuras de R para almacenar datos tabulares. Si quieres ver en qué se diferencian lee esto.
   Veámoslo un poco:
typeof(iris)
[1] "list"
class(iris)
[1] "data.frame"
names(attributes(iris))
[1] "names"     "class"     "row.names"
   Convertimos iris en tibble:
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"


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

seleccionando “manualmente” un archivo de datos


  • Este truco es chulo … pero no hay que hacerlo
my_data <- rio::import(file.choose())


  • No hay que hacerlo si queremos que nuestros análisis sean reproducibles

gestionando las rutas con here::here()

Problemas con las rutas “tradicionales”

  • Rutas absolutas son “frágiles”
    • C:\tu-usuario\tu-proyecto\datos\archivo.csv
    • No funcionarán en otras máquinas


  • Rutas relativas pueden ser ambiguas:
    • "./datos/archivo.csv" o "../scripts/codigo.R"
    • ¿Relativas a qué? Depende de dónde ejecutes!!


  • Consecuencias:
    • Scripts no reproducibles.
    • “Error: No se puede encontrar el archivo”


En realidad, como nosotros trabajamos con Rstudio y con Rproject’s, de momento nos basta con utilizar rutas relativas, PERO, esto cambiará cuando trabajemos con archivos .qmd

Rutas con here::here()

  • Construye rutas absolutas, PERO estas rutas absolutas no se construyen a mano, sino cuando se ejecuta el código; por lo tanto, como trabajamos con Rproject’s, esas rutas absolutas funcionarán tanto si trabajamos con ficheros .R como con ficheros .qmd


  • Como nosotros trabajamos con Rproject’s, las rutas relativas que vayamos construyendo serán rutas relativas a la carpeta raíz de tu Rproject, y here::he() las convertirá en rutas absolutas. Por ejemplo:
my_ruta <- here::here("datos", "my_archivo.csv")
    C:\Users\my_usuario\my_Rproject\datos\my_archivo.csv


  • Ventajas:

    • Reproducible: funcionará en cualquier ordenador
    • Genera rutas absolutas pero específicas para cada ordenador


  • ➡ Olvídate de setwd() al inicio!! Tu yo futuro y tus coautores te lo agradecerán!! ✨

¿cómo construir nuestra rutas con here::here()?

  • Recuerda que si queríamos exportar el fichero iris, hacíamos algo como:
rio::export(iris, file = "./pruebas/iris.xlsx" )


  • Para hacer los mismo con here::here() haremos:
rio::export(iris, file = here::here("pruebas", "iris.xlsx" ))


  • Fíjate que here::here() nos devuelve una ruta absoluta, pero diferente para cada ordenador:
here::here("pruebas", "iris.xlsx" )


C:\my_usuario\my_proyecto\pruebas\iris.xlsx


(si quieres leer sobre ello puedes hacerlo aquí y aquí)

(si quieres leer sobre gestión de rutas en R puedes hacerlo aquí, aquí y aquí)

vamos a usar un bucle for … para exportar varios archivos


  • Imagina que quiero exportar un fichero, por ejemplo iris, a varios formatos y quiero hacerlo con un “for loop”


  • Exporta iris a los formatos .csv, .xlsx y .dta usando un bucle for.

  • Esta vez no hay solución 😧 !!

  • Bueno … la solución estará en uno de los ejemplos del Rproject del curso. ¿Lo veremos?

no siempre es fácil publicar bien unos datos


  • Una guía para publicar datos en .csv. Aquí la cheatsheet

  • Un buen post sobre la misma temática

algunas referencias

Un caso más complejo


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

un caso más complejo

Para contar el nº de municipios por provincia tenemos que descargar el fichero con la relación de municipios del INE. El fichero está aquí: https://www.ine.es/daco/daco42/codmun/codmun20/20codmun.xlsx


  • Vamos a descargarlo de varias formas:

    1. con el paquete rio

    2. utilizando los menús de RStudio

    3. con el paquete readxl

    4. Finalmente lo haremos de forma más “pofesional”

rm(list = ls())  #- antes vamos a limpiar el Global env.

my_url <- "https://www.ine.es/daco/daco42/codmun/codmun20/20codmun.xlsx"

my_ruta_guardar <- here::here("pruebas", "20codmun.xlsx")

curl::curl_download(my_url, my_ruta_guardar) #- lo guardo en disco

df_1 <- rio::import(my_ruta_guardar) #- q pb tenemos?

  • Vamos a usar menús, pero que no nos vea Hadley!!!

  • Seguid la siguiente ruta de menús: File > Import Dataset > From Excel ...

  • Pegáis en la caja de texto el url y pincháis el botón update

df_2 <- readxl::read_xlsx(my_url, skip = 1)  #- no funciona. readxl solo lee del PC

my_ruta_guardar <- here::here("pruebas", "20codmun.xlsx")

df_2 <- readxl::read_xlsx(my_ruta_guardar, skip = 1)
#- 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"

#- obtengo el nombre del archivo
nombre_fichero <- stringr::str_extract(url_descarga, "([^\\/]+$)")

#- añado la fecha de descarga al nombre de archivo
extension <- stringr::str_extract(url_descarga, "([^\\.]+$)")
nombre <- stringr::str_remove(nombre_fichero, paste0(".",extension))
nombre_fichero <- paste0(nombre , "_", Sys.Date(), ".", extension)

#- lo guardo
my_ruta <- here::here("pruebas", nombre_fichero) #- ruta para guardar el fichero
curl::curl_download(url = url_descarga, destfile = my_ruta)
  • 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`

seguimos con el ejemplo

aparecen muchas cosas/funciones que veremos más adelante [🌶🌶🌶🌶]

  • 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)


  • Si quisiera exportar el archivo
readr::write_csv(df, file = here::here("pruebas", "my_relacion_muni_2021.csv"))


  • Podemos contar el nº de municipios por provincia (de muchas maneras distintas)
df_muni <- df %>% group_by(ine_prov) %>% summarise(numero_muni = n())
df_muni <- df %>% count(ine_prov)


  • Si quisiéramos saber el nombre de las provincias
#- pak::pak("perezp44/pjpv.curso.R.2022")
codigos_prov <- pjpv.curso.R.2022::ine_pob_mun_1996_2021 %>% 
                select(ine_prov, ine_prov.n) %>% 
                distinct()


  • Para fusionar los 2 ficheros
#- fusiono los 2 ficheros (lo veremos!!)
df_ok <- left_join(df_muni, codigos_prov)


  • Borro la carpeta (para dejar el Rproject limpio)
fs::dir_delete("pruebas")  #- [🌶] borro la carpeta pruebas

Más extensiones


  • funciones, paquetes, etc …

quizás 🤔 … lo más importante del curso sea entender bien cómo “funciona” una función

  • Sí, es muy importante entender qué es y cómo usar una función

  • De hecho, todo lo que ocurre, todo lo que pasa en R es porque has llamado a una función

  • Again: si algo ocurre en R es porque has hecho una llamada a una función, una “function call”

To understand computations in R, two slogans are helpful:
- Everything that exists is an object.
- Everything that happens is a function call.

— John Chambers (creador de S)


  • Usar funciones permite:

    • reutilizar código y organizar los programas de manera más eficiente
    • facilita la depuración de errores y el mantenimiento
    • mejora la legibilidad del código

¿qué es una función?

  • Una función no es más un trozo de código R, unas instrucciones de R, a las que les hemos puesto/asignado un nombre; entonces, cuando invoquemos ese nombre, esa función, se ejecutarán esas lineas de código y nos devolverá un resultado

(Como no creo que lo anterior os diga mucho, vamos a usar 5 minutos para crear nuestra primera función)

creamos nuestra primera función


Crea una función que permita sumar 2 números

  • Las funciones en R se crean con la función llamada function(). Sí, un poco trabalenguas.

  • La función que vamos a crear será un objeto de R, así que le tenemos que asignar un nombre

  • Los argumentos de la función van dentro de los paréntesis separados por comas

  • El código que queramos que se ejecute cuando llamemos a la función va entre llaves


Por lo tanto, en genérico, una función en R se crea así:


nombre_de_mi_funcion <- function(argumento_1, argumento_2, ...) {
  <codigo-q-quiero-q-se-ejecute-cuando-se-invoque-a-la-función>
}


(Sí lo conseguís sois genios o ya habéis visto esto en otro lenguaje)

  • Creamos una función llamada my_f_suma()

  • Para ello, usamos la función de R llamada function()


my_f_suma <- function(n1 , n2){
  n1 + n2
}


  • Para usar la función que hemos creado:


my_f_suma(3 , 5)
my_f_suma(n1 = 3 , n2 = 5)

aa <- my_f_suma(30 , 50)

supongo que ahora se entiende mejor qué es una función?

  • Recuerda, no es más que un trozo de instrucciones/código en R que alguien ha creado para ser usada

  • Para usarlas, solo tenemos que invocar su nombre y dar valores a sus argumentos

seguimos con las funciones

  • Vamos a profundizar en nuestro conocimiento de las funciones usando una: usando la función sqrt()

  • Resulta que alguien se ha preocupado de construir una función llamada sqrt() que sirve para calcular raíces cuadradas. Vamos a usarla!! Cómo??


ejemplo: cómo aprender a usar sqrt()

  • Para usar una función puedes buscar en internete, pedir ayuda a una IA, etc … pero creo que mejor si usas la ayuda oficial de la función

  • Sí cada función de R tiene una página de ayuda interna.

  • Para abrir la ayuda oficial hay que situar el cursor en el nombre de la función y pinchar en

  • También puedes hacer: help(sqrt)

ayuda oficial de sqrt()

  • La ayuda oficial parece muy complicada, pero hay que aprender a leer las ayudas de las funciones. Es es MUY IMPORTANTE!!!! si quieres aprender a manejarte con R.

vamos a usar sqrt() para aprender cómo usar funciones

Tarea: ejecuta estas instrucciones e intenta entender que ocurre

sqrt(9)
sqrt(9, 4)   #- no funciona ¿por qué? ¿cuantos argumentos tiene la f. sqrt()?
sqrt("9")    #- no funciona, ¿por qué? ¿Cómo, de que tipo, ha de ser el argumento?

… más detalles

  • En realidad, cuando vamos a usar una función, cada argumento de la función tiene 2 elementos: el nombre del argumento y un valor para el argumento

  • El nombre de la función sqrt() es sqrt, ok, pero ¿cuales son sus argumentos? La ayuda nos dice que sólo tiene un argumento, cuyo nombre es x ; además, el valor del argumento debe ser numérico

sqrt(9)       #- en realidad "no hace falta" poner el nombre del argumento
sqrt(x = 9)   #- 
sqrt(x = 4)


hay que diferenciar el nombre y el valor del argumento de una función

x <- 25
sqrt(x)

sqrt(x = x)          #- !!!

sqrt(x = un_valor)   #- !!!
sqrt(nn = 9)         #- !!!

seguimos con las funciones (ya casi lo tenemos!!)

  • Calcula el logaritmo de 1000 en base 10. Para ello tenéis que usar la función log()


  • Cómo no sabemos cómo se usa, no sabemos cómo es su sintaxis, no sabemos cuales son sus argumentos, nos va a tocar mirar la ayuda de la función


  • log(1000) no va a funcionar. ¿Por qué? para saberlo tendrás que mirar la ayuda de la función log()

Esto no funciona:

log(1000)  #- como no especificamos el valor del argumento "base",
           #- R lo fija a su valor x defecto; es decir, base = exp(1) 
           #- así que estamos tomando logaritmos naturales

Varias soluciones:

log(x = 1000, base = 10)    #- GOOD

log(1000, base = 10)        #- es equivalente
log(x = 1000, 10)           #- es equivalente
log(1000, 10)               #- es equivalente

log(1000, bas = 10)         #- funciona, pero ... mejor no hacerlo


    ¿Por qué no podemos usar la expresión de abajo?
log(10, 1000)

¿Funcionará?

log(base = 10, 1000)

… lo ultimísimo sobre funciones

  • ¿Qué hacen los siguientes chunks?
add1 <- function(my_number) {
  my_number + 1
}


my_suma_3a <- function(n1 , n2, n3){
   n1 + n2 + n3
}

#- vamos a usar nuestra función
my_suma_3a(2)        #- xq no funciona?


my_suma_3b <- function(n1 = 4 , n2 = 6, n3 = 3){
   n1 + n2 + n3
}

my_suma_3b(2)        #- xq ahora sí funciona?


  • Estaría bien que le pegaseis un vistazo a este apéndice sobre cómo leer las ayudas de las funciones en R