0.1 Introducción a R

R tiene sus orígenes en S, un lenguaje de programación creado en los Laboratorios Bell de Estados Unidos. Dado que S y sus estándares son propiedad de los Laboratorios Bell, lo cual restringe su uso, Ross Ihaka y Robert Gentleman, de la Universidad de Auckland en Nueva Zelanda, decidieron crear una implementación abierta y gratuita de S. Este trabajo, que culminaría en la creación de R inició en 1992, teniendo una versión inicial del lenguaje en 1995 y en el 2000 una versión final estable.

Aunque R está diseñado para análisis estadístico, con el paso del tiempo los usuarios de este lenguaje han creado extensiones a R, llamadas paquetes, que han ampliado su funcionalidad. En la actualidad es posible realizar en R minería de textos, procesamiento de imagen, visualizaciones interactivas de datos y procesamiento de Big Data, entre muchas otras cosas.

En R, todo es un objeto. Todos los datos y estructuras de datos son objetos. Además, todos los objetos tienen un nombre para identificarlos. Una función es una serie de operaciones a la que les hemos asignados un nombre. Las funciones aceptan argumentos, es decir, especificaciones sobre cómo deben funcionar –> nombre_de_la_función(). Por ejemplo: mean(), summary(), …

Para obtener la documentación de una función, escribimos el ? antes de su nombre y lo ejecutamos. También podemos usar la función help(), con el nombre de la función –> help("mean"), help(package = "stats").

El directorio o carpeta de trabajo es el lugar en nuestra computadora en el que se encuentran los archivos con los que estamos trabajando en R. Este es el lugar donde R buscara archivos para importarlos y al que serán exportados, a menos que indiquemos otra cosa.

R permite recuperar y ejecutar órdenes previas. Las flechas verticales del teclado puede utilizarse para recorrer el historial de órdenes. Puedes encontrar cuál es tu directorio de trabajo con la función getwd(). Sólo tienes que escribir la función en la consola y ejecutarla. Puedes cambiar el directorio de trabajo usando la función setwd(), dando como argumento la ruta del directorio que quieres usar, setwd("C:\otro_directorio").

R puede ser expandido con paquetes. Cada paquete es una colección de funciones diseñadas para atender una tarea específica. Podemos instalar paquetes usando la función install.packages(), dando como argumento el nombre del paquete que deseamos instalar, entre comillas.

Por ejemplo, para instalar el paquete readr, corremos lo siguiente: install.packages("readr").

Una vez concluida la instalación de un paquete, podrás usar sus funciones con la función library().

library(readr)

Cuando haces esto, R importa las funciones contenidas en el paquete al entorno de trabajo actual. Los paquetes que hemos importado en nuestra sesión actual aparecen al llamar sessionInfo().

sessionInfo()
## R version 4.1.2 (2021-11-01)
## Platform: x86_64-w64-mingw32/x64 (64-bit)
## Running under: Windows 10 x64 (build 19044)
## 
## Matrix products: default
## 
## locale:
## [1] LC_COLLATE=Spanish_Spain.1252  LC_CTYPE=Spanish_Spain.1252   
## [3] LC_MONETARY=Spanish_Spain.1252 LC_NUMERIC=C                  
## [5] LC_TIME=Spanish_Spain.1252    
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] readr_2.1.0
## 
## loaded via a namespace (and not attached):
##  [1] knitr_1.36      magrittr_2.0.1  hms_1.1.1       R6_2.5.1       
##  [5] rlang_0.4.12    fastmap_1.1.0   fansi_0.5.0     stringr_1.4.0  
##  [9] tools_4.1.2     xfun_0.30       utf8_1.2.2      jquerylib_0.1.4
## [13] htmltools_0.5.2 ellipsis_0.3.2  yaml_2.2.1      digest_0.6.28  
## [17] tibble_3.1.6    lifecycle_1.0.1 crayon_1.4.2    tzdb_0.2.0     
## [21] sass_0.4.0      vctrs_0.3.8     evaluate_0.14   rmarkdown_2.11 
## [25] stringi_1.7.5   compiler_4.1.2  bslib_0.3.1     pillar_1.6.4   
## [29] jsonlite_1.7.2  pkgconfig_2.0.3

0.2 Datos en R

Los tipos de datos de uso más común en R son los siguientes:

Entero 7 (integer), Numérico 1.3 (numeric), Cadena de texto “uno” (character), Factor uno (factor), Lógico TRUE (logical), Perdido NA (NA), Vacio NULL (null).

Como su nombre lo indica, los datos enteros representan números enteros, sin una parte decimal o fraccionaria, que pueden ser usados en operaciones matemáticas.

Por su parte, como su nombre lo indica, los datos numéricos representan números, la diferencia de estos con los datos enteros es que tiene una parte decimal o fraccionaria.

Los datos numéricos también son llamados doble o float (flotantes). Este nombre se debe a que, en realidad, son números de doble precisión, pues tienen una parte entera y una fraccionaria decimal, y son llamados float debido a que se usa un punto flotante para su representación computacional.

El tipo character representa texto y es fácil reconocerlo porque un dato siempre esta rodeado de comillas, simples o dobles. De manera convencional, nos referimos a este tipo de datos como cadenas de texto, es decir, secuencias de caracteres.

Un factor es un tipo de datos específico de R. Puede ser descrito como un dato numérico representado por una etiqueta. En R, podemos indicar que se nos muestre, en la consola y para otros análisis, los 1 como femenino y los 2 como masculino. Aunque en nuestro ordenador, femenino tiene un valor de 1, pero a nosotros se nos muestra la palabra femenino. De esta manera reducimos el espacio de almacenamiento necesario para nuestros datos.

Los datos de tipo lógico sólo tienen dos valores posibles: verdadero (TRUE) y falso (FALSE). Representan si una condición o estado se cumple, es verdadero, o no, es falso.

En R, usamos NA para representar datos perdidos, mientras que NULL representa la ausencia de datos.

En R, los datos pueden ser coercionados, es decir, forzados, para transformarlos de un tipo a otro: as.integer() (Entero), as.numeric() (Numérico), as.character() (Cadena de texto), as.factor() (Factor), as.logical() (Lógico), as.null() (NULL). La función class() recibe como argumento un dato o vector y devuelve el nombre del tipo al que pertenece, en inglés.

Operadores aritméticos

  • Suma \(5 + 3 = 8\)

  • Resta \(5 - 3 = 2\)

  • Multiplicación * \(5 * 3 = 18\)

  • División \(5 /3 = 1.666667\)

  • Potencia \(5 ^ 3 = 125\)

  • División entera %%

Operadores relacionales

  • Menor que 5 < 3 FALSE

  • Menor o igual que 5 <= 3 FALSE

  • Mayor que 5 > 3 TRUE

  • Mayor o igual que 5 >= 3 TRUE

  • Exactamente igual que 5 == 3 FALSE

  • No es igual que 5 != 3 TRUE

0.3 Estructura de datos en R

Creamos vectores usando la función c() (combinar).

Llamamos esta función y le damos como argumento los elementos que deseamos combinar en un vector, separados por comas.

v1 <- c(1, 2, 3, 5, 8, 13)
v2 <- c("arbol", "casa", "persona")
1:10
##  [1]  1  2  3  4  5  6  7  8  9 10
mi_vector <- c(2, 3, 6, 7, 8, 10, 11)
mi_vector * 2
## [1]  4  6 12 14 16 20 22
mi_vector > 7
## [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE
v1
## [1]  1  2  3  5  8 13

El comando dos puntos para la definición de vectores es un caso particular de la función seq(), que nos permite construir vectores que son sucesiones equiespaciadas. La instrucción para este comando es seq(from, to, by, length, along)

Sus argumentos principales son:

  • from Nos indica el valor inicial de la sucesión.

  • to Nos indica el valor final de la sucesión.

  • by Marca el salto entre los valores.

  • length Indica la longitud del vector resultante.

x <- 1:7   #Igual que c(1,2,3,4,5,6,7)
x
## [1] 1 2 3 4 5 6 7
x <- rep(1, 100)  #x es un vector con 100 unos.
x
##   [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
##  [38] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
##  [75] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
x <- rep(1:2, times = 5)  #repite 1,2 cinco veces.
x
##  [1] 1 2 1 2 1 2 1 2 1 2
x <- rep(1:2, each = 2) # repite cada elemento dos veces.
x
## [1] 1 1 2 2

Las matrices y arrays pueden ser descritas como vectores multidimensionales. Al igual que un vector, únicamente pueden contener datos de un sólo tipo, pero además de largo, tienen más dimensiones.

Creamos matrices en R con la función matrix(). La función matrix() acepta dos argumentos, nrow y ncol. Con ellos especificamos el número de renglones y columnas que tendrá nuestra matriz.

m1 <- matrix(1:12)
m1
##       [,1]
##  [1,]    1
##  [2,]    2
##  [3,]    3
##  [4,]    4
##  [5,]    5
##  [6,]    6
##  [7,]    7
##  [8,]    8
##  [9,]    9
## [10,]   10
## [11,]   11
## [12,]   12
m2 <- matrix(1:12, nrow = 3, ncol = 4)
m2
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
m3 <- matrix(1:12, nrow = 5, ncol = 4)
m3
##      [,1] [,2] [,3] [,4]
## [1,]    1    6   11    4
## [2,]    2    7   12    5
## [3,]    3    8    1    6
## [4,]    4    9    2    7
## [5,]    5   10    3    8

Otro procedimiento para crear matrices es la unión vectores con las siguientes funciones:

  • cbind() para unir vectores, usando cada uno como una columna.

  • rbind() para unir vectores, usando cada uno como un renglón.

De este modo podemos crear cuatro vectores y unirlos para formar una matriz. Cada vector será un renglón en esta matriz.

vector_1 <- 1:4
vector_2 <- 5:8
vector_3 <- 9:12
vector_4 <- 13:16
matriz <- rbind(vector_1, vector_2, vector_3, vector_4)
matriz
##          [,1] [,2] [,3] [,4]
## vector_1    1    2    3    4
## vector_2    5    6    7    8
## vector_3    9   10   11   12
## vector_4   13   14   15   16

Creamos cuatro vectores, cada uno de largo igual a cuatro.

Usamos t() para transponer. Algunas operaciones con las matrices son las siguientes:

Operaciones Descripción
+,-,*,/ Operaciones aritméticas elemento a elemento
%*% Producto matricial
solve() Inversa de una matriz
det() Determinante
eigen() Valores y vectores propios
%x% Producto de Kronecker

Los arrays son otro tipo similar a las matrices pero pueden tener más de dos dimensiones. Los arrays en R son objetos con n dimensiones que se definen mediante el comando array(datos, dimensiones).

0.4 Los data frames y las listas

Los data frames son estructuras de datos de dos dimensiones (rectangulares) que pueden contener datos de diferentes tipos, por lo tanto, son heterogéneas. Esta estructura de datos es la más usada para realizar análisis de datos y seguro te resultará familiar si has trabajado con otros paquetes estadísticos.

Podemos entender a los data frames como una versión más flexible de una matriz. Mientras que en una matriz todas las celdas deben contener datos del mismo tipo, los renglones de un data frame admiten datos de distintos tipos, pero sus columnas conservan la restricción de contener datos de un sólo tipo.

Para crear un data frame usamos la función data.frame(). Esta función nos pedirá un número de vectores igual al número de columnas que deseemos. Todos los vectores que proporcionemos deben tener el mismo largo. Esto es muy importante: Un data frame está compuesto por vectores. Además, podemos asignar un nombre a cada vector, que se convertirá en el nombre de la columna. Como todos los nombres, es recomendable que este sea claro, no ambiguo y descriptivo.

mi_df <- data.frame(
  "entero" = 1:4, 
  "factor" = c("a", "b", "c", "d"), 
  "numero" = c(1.2, 3.4, 4.5, 5.6),
  "cadena" = as.character(c("a", "b", "c", "d"))
)

mi_df
##   entero factor numero cadena
## 1      1      a    1.2      a
## 2      2      b    3.4      b
## 3      3      c    4.5      c
## 4      4      d    5.6      d
# Podemos usar dim() en un data frame
dim(mi_df)
## [1] 4 4
# El largo de un data frame es igual a su número de columnas
length(mi_df)
## [1] 4
# names() nos permite ver los nombres de las columnas
names(mi_df)
## [1] "entero" "factor" "numero" "cadena"
# La clase de un data frame es data.frame
class(data.frame)
## [1] "function"

Si los vectores que usamos para construir el data frame no son del mismo largo, los datos no se reciclaran. Mezclando con matrices:

matriz <- matrix(1:12, ncol = 4)
df <- as.data.frame(matriz)
class(df)
## [1] "data.frame"

Al igual que con una matriz, si aplicamos una operación aritmética a un data frame, esta se vectorizará.

Los resultados que obtendremos dependerán del tipo de datos de cada columna. R nos devolverá todas las advertencias que ocurran como resultado de las operaciones realizadas, por ejemplo, aquellas que hayan requerido una coerción.

Las listas, al igual que los vectores, son estructuras de datos unidimensionales, sólo tienen largo, pero a diferencia de los vectores cada uno de sus elementos puede ser de diferente tipo o incluso de diferente clase, por lo que son estructuras heterogéneas.

Podemos tener listas que contengan datos atómicos, vectores, matrices, arrays, data frames u otras listas. Esta última característica es la razón por la que una lista puede ser considerada un vector recursivo, pues es un objeto que puede contener objetos de su misma clase.

Para crear una lista usamos la función list(), que nos pedirá los elementos que deseamos incluir en nuestra lista. Para esta estructura, no importan las dimensiones o largo de los elementos que queramos incluir en ella. Al igual que con un data frame, tenemos la opción de poner nombre a cada elemento de una lista. Por último, no es posible vectorizar operaciones aritméticas usando una lista, se nos devuelve un error como resultado.

mi_vector <- 1:10
mi_matriz <- matrix(1:4, nrow = 2)
mi_df     <- data.frame("num" = 1:3, "let" = c("a", "b", "c"))

mi_lista <- list("un_vector" = mi_vector, "una_matriz" = mi_matriz, "un_df" = mi_df)

mi_lista
## $un_vector
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $una_matriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
## 
## $un_df
##   num let
## 1   1   a
## 2   2   b
## 3   3   c

Al igual que con los datos, cuando intentamos hacer operaciones con una estructura de datos, R intenta coercionarla al tipo apropiado para poder llevarlas a cabo con éxito.

También podemos usar alguna de las funciones de la familia as() coercionar de un tipo de estructura de datos. A continuación se presentan las más comunes.

Función Coerciona a Coerciona exitosamente a
as.vector() Vector Matrices
as.matrix() Matrices Vectores, Data frames
as.data.frame() Data frame Vectores, Matrices
as.list() Lista Vectores, Matrices, Data frames 
mi_matriz
##      [,1] [,2]
## [1,]    1    3
## [2,]    2    4
as.vector(mi_matriz)
## [1] 1 2 3 4

0.5 Subconjunto de datos

En R, podemos obtener subconjuntos de nuestras estructuras de datos. Es decir, podemos extraer partes de una estructura de datos (nuestro conjunto).

0.5.1 Subconjunto de datos mediante índices

Un índice en R representa una posición. Cuando usamos índices le pedimos a R que extraiga de una estructura los datos que se encuentran en una o varias posiciones específicas dentro de ella.

A diferencia de la mayoría de los lenguajes de programación, los índices en R empiezan en 1, no en 0. El índice del primer elemento de una estructura de datos siempre es 1, el segundo 2, y así sucesivamente.

Un aspecto muy importante de este procedimiento es que, para data frames y listas, cuando extraemos un subconjunto de un objeto usando corchetes, obtenemos como resultado un objeto de la misma clase que el objeto original. Si extraemos un subconjunto de un data frame, obtenemos un vector; y si extraemos de una lista, obtenemos una lista.

Creamos un vector y vemos varios ejemplos.

vec <- c("a","b","c","d","e","f")
vec[3]
## [1] "c"
vec[3:5]
## [1] "c" "d" "e"
vec[c(2,5)]
## [1] "b" "e"
vec[-1]
## [1] "b" "c" "d" "e" "f"
vec[-1:-5]
## [1] "f"

Para estructuras de dos dimensiones, como són matrices y data frames, el primer vector de un índice, antes de una coma, es la posición en los renglones y el segundo es la posición las columnas.

Creamos ahora un data frame:

mi_df <- data.frame("nombre" = c("Armando", "Elsa", "Ignacio", "Olga"),
                    "edad" = c(20, 24, 22, 30),
                    "sexo" = c("H", "M", "M", "H"),
                    "grupo" = c(0, 1, 1, 0))
mi_df
##    nombre edad sexo grupo
## 1 Armando   20    H     0
## 2    Elsa   24    M     1
## 3 Ignacio   22    M     1
## 4    Olga   30    H     0

Vemos algunos ejemplos.

dim(mi_df)
## [1] 4 4
mi_df[1]
##    nombre
## 1 Armando
## 2    Elsa
## 3 Ignacio
## 4    Olga
mi_df[c(1, 3)]
##    nombre sexo
## 1 Armando    H
## 2    Elsa    M
## 3 Ignacio    M
## 4    Olga    H
mi_df[3,]
##    nombre edad sexo grupo
## 3 Ignacio   22    M     1
mi_df[2:4, 3]
## [1] "M" "M" "H"
mi_df[1:2, c(2, 4)]
##   edad grupo
## 1   20     0
## 2   24     1

El procedimiento anterior para data frames funciona de la misma manera para las matrices, con una excepción. Si usamos como índice un sólo número, entonces obtendremos el valor que se encuentre en esa posición, contando celdas de arriba a abajo y de izquierda a derecha.

0.5.2 Subconjunto de datos mediante nombres

Un segundo método para extrar subconjuntos es usar los nombres de los elementos en una estructura de datos. Este forma de obtener subconjuntos es usada principalmente con data frames y listas. De manera similar a los índices, usamos corchetes cuadrados [] después del nombre de un objeto, pero en lugar de escribir un número, escribimos el nombre del elemento que deseamos extraer como una cadena de texto, es decir, entre comillas.

mi_df["nombre"]
##    nombre
## 1 Armando
## 2    Elsa
## 3 Ignacio
## 4    Olga

De igual manera que con los índices, al escribir una coma dentro de los corchetes, estamos pidiendo con ello extraer elementos en más de una dimensión. Lo que está antes escrito antes de la coma corresponde a filas, y lo que está después, a columnas.

Si ejecutamos lo siguiente, obtendremos NA en lugar de obtener las columnas edad y sexo.

mi_df["edad", "sexo"]
## [1] NA

Lo anterior ocurre porque R intenta encontrar un renglón llamado “edad” y una columna llamada “sexo”, al no encontrarlas, nos devuelve NA. Recuerda que aunque no es lo más común, los renglones de un data frame pueden tener nombres.

Al igual que con los índices, si damos el nombre de un renglón que existe, obtenemos NA. Es sólo al solicitar un nombre de columna no válido que se nos devuelve un error.

Pedimos un nombre de renglón inexistente y obtenemos NA. Pero si pedimos un nombre inválido de columna, nos es devuelto un error.

Para extraer más de una columna, escribimos un vector de texto entre los corchetes. Por ejemplo

mi_df[c("edad", "sexo")]
##   edad sexo
## 1   20    H
## 2   24    M
## 3   22    M
## 4   30    H

Para una lista, el procedimiento es prácticamente el mismo que para un data frame, pero en lugar de obtener columnas, obtenemos los elementos contenidos en ella.

La primera diferencia con los data frame es que, dado que las listas son unidimensionales, si usamos una coma dentro de los corchetes, nos será devuelto un error.

0.5.3 Subconjunto de datos mediante índices y nombres

Al extraer subconjuntos podemos combinar índices con nombres dentro del mismo corchete para objetos multidimensionales, por ejemplo, usando un índice antes de la coma y un nombre después de ella. Esto nos da una gran flexibilidad para hacer subconjuntos con data frames y matrices. En particular, es útil al definir funciones y al trabajar con conjuntos de datos de los tenemos información incompleta.

Por ejemplo, extraemos el tercer y cuarto renglón de la columna nombre en nuestro data frame mi_df.

mi_df[3:4, "nombre"]
## [1] "Ignacio" "Olga"
mi_df[c("1"), c(1, 4)]
##    nombre grupo
## 1 Armando     0

0.5.4 Subconjunto de datos mediante el símbolo dolar

Otra manera en la que podemos extraer subconjuntos usando nombres, es con el signo de dolar $.

Para usar este método, escribir el signo dolar después del nombre de un objeto de la siguiente forma: objeto$nombre.

Este método permite extraer un sólo elemento a la vez, funciona para data frames y listas, y para el caso de los data frame, el elemento extraido siempre será una columna.

Por ejemplo, extraemos la columna nombre del data frame mi_df.

mi_df$nombre
## [1] "Armando" "Elsa"    "Ignacio" "Olga"
class(mi_df$nombre)
## [1] "character"

El resultado de las operaciones anteriores no es un data frame, sino un vector. Esta es una característica distintiva de este método, al usar el signo dolar para extraer un elemento de un data frame o una lista, obtenemos un objeto de la clase que ese elemento era originalmente.

0.5.5 Subconjunto de datos mediante condicionales

Las condicionales nos permiten obtener subconjuntos que para los que una o más condiciones son verdaderas (TRUE).

Realizamos la extracción de subconjuntos mediante operaciones relacionales y lógicas dentro de corchetes. Esta operación tiene la siguiente estructura.

objeto[condicion, columnas_devueltas]

donde

  • objeto: es un data frame.

  • condicion: un subconjunto de objeto, que devuelva un columna como vector, al que se le aplica una o más operaciones lógicas o relacionales.

  • columnas_devueltas: los índices o nombres de las columnas que deseamos sean devueltas como resultado.

Por ejemplo,

mi_df[mi_df$edad > 22, 1]
## [1] "Elsa" "Olga"

nos devuelve los nombres de las personas que tienen más de 22 años (Elsa y Olga)

mi_df[mi_df$edad <= 22, c(1,3)]
##    nombre sexo
## 1 Armando    H
## 3 Ignacio    M

Podemos realizar más de una operación relacional antes de la coma, usando operadores lógicos.

mi_df[mi_df$edad <= 22 & mi_df$grupo == 0,  ]
##    nombre edad sexo grupo
## 1 Armando   20    H     0

Con esta instrucción hemos seleccionados las personas menores o iguales de 22 años que pertenecen al grupo 0.

Recuerda que puedes usar el operados ! para negaciones.

mi_df[!(mi_df$edad <= 22 & mi_df$grupo == 0),  ]
##    nombre edad sexo grupo
## 2    Elsa   24    M     1
## 3 Ignacio   22    M     1
## 4    Olga   30    H     0

Con el operador lógico ! conseguimos el resto de personas con las características dentro del paréntesis.

Una alternativa para usar condicionales, sin necesidad de corchetes, es la función subset(). Esta función tiene los siguients argumentos:

  • x: Un objeto, generalmente un data frame.

  • subset: Una condición, expresada como operaciones relacionales o condicionales, que se aplicarán a una columna de x.

  • select: Un vector con los nombres de las columnas a conservar en el resultado. Si no asignamos un valor a este argumento, se nos devuelven todas las columnas de x.

Veamos un ejemplo

subset(x = mi_df, subset = edad > 22)
##   nombre edad sexo grupo
## 2   Elsa   24    M     1
## 4   Olga   30    H     0

Con el ejmplo anterior obtenemos el subconjunto de las personas con más de 22 años. Otro ejemplo.

subset(x = mi_df, subset = edad > 22, select = c("edad", "grupo"))
##   edad grupo
## 2   24     1
## 4   30     0

También hemos podido seleccionar solo un subconjunto de columnas. Notemos que el argumento subset del interior del paréntesis no necesita ir entre comillas.

subset(x = mi_df, subset = edad > 22 & grupo == 0)
##   nombre edad sexo grupo
## 4   Olga   30    H     0

0.6 Importar y exportar datos

Antes de empezar a importar datos, vale la pena señalar que podemos descargar archivos de internet usando R con la función download.file().

La función download.file() nos pide como argumento url, la dirección de internet del archivo que queremos descargar y destfile el nombre que tendrá el archivo en nuestra computadora. Ambos argumentos como cadenas de texto, es decir, entre comillas.

Por ejemplo, para descargar una copia del set iris disponible en el UCI Machine Learning Repository usamos la siguiente dirección como argumento url:

https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data

Y asignamos “iris.data” al argumento destfile.

download.file(
  url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data", 
  destfile = "iris.data"
  )

El resultado es un archivo llamado “iris.data” en nuestro directorio de trabajo.

Este método funciona con prácticamente todo tipo de archivos, aunque en algunos casos será necesario agregar el argumento method = "wb", por asegurar que el archivo obtenido funcione correctamente.

R cuenta con la función genérica read.table(), que puede leer cualquier tipo de archivo que contenga una tabla.

La condición para que R interprete un archivo como una tabla es que tenga renglones y en cada renglon, los datos estén separados por comas, o algún otro caracter, indicando columnas. Por supuesto, en lugar de comas podemos tener puntos y coma, dos puntos, tabuladores o cualquier otro signo de puntuación como separador de columnas.

La función read.table() acepta un número considerable de argumentos. Los más importantes son los siguientes.

  • file: La ruta del archivo que importaremos, como cadena de texto. Si el archivo se encuentra en nuestro directorio de trabajo, es suficientedar el nombre del archivo, sin la ruta completa.

  • header: Si nuestro archivo tiene encabezados, para ser interpretados como nombres de columna, definimos este argumento como TRUE.

  • sep: El caracter que es usado como separador de columnas. Por defecto es “;”, aunque también se utilizan la coma o el punto.

  • col.names: Un vector opcional, de tipo caracter, con los nombres de las columnas en la tabla.

  • stringsAsFactors: Esta función convierte automáticamente los datos de texto a factores. Si este no es el comportamiento que deseamos, definimos este argumento como FALSE.

  • dec: es el argumento que indica el símbolo de los decimales. Notemos que en ficheros .csv pueden confundirse los miles con los decimales.

Archivos .csv

Un caso particular de las tablas, son los archivos separados por comas, con extensión .csv, por Comma Separated Values, sus siglas en inglés, read.csv(). Este es un tipo de archivo comunmente usado para compartir datos, pues es compatible con una amplia variedad de sistemas diferentes además de que ocupa relativamente poco espacio de almacenamiento.

El documento “R Data Import/Export” (R Core Team, 2018) contiene una guía avanzada sobre el proceso de importar y exportar todo tipo de datos. Puedes consultarlo en el siguiente enlace: https://cran.r-project.org/doc/manuals/r-release/R-data.pdf

De manera análoga a read.table(), la función write.table() nos permite exportar matrices o data frames, como archivos de texto con distintas extensiones.

Los argumentos más usados de write.table() son los siguientes.

  • x: El nombre del data frame o matriz a exportar.

  • file: El nombre, extensión y ruta del archivo creado con esta función. Si sólo escribimos el nombre del archivo, este será creado en nuestro directorio de tabajo.

  • sep: El caracter que se usará como separador de columnas.

  • row.names: Si deseamos incluir el nombre de los renglones en nuestro objeto al exportarlo, establecemos este argumento como TRUE. En general, es recomendable fijarlo como FALSE, para conservar una estructura tabular más fácil de leer.

  • col.names: Si deseamos que el archivo incluya los nombres de las columnas en nuestro objeto, establecemos este argumento como TRUE. Es recomendable fijarlo como TRUE para evitar la necesidad de almacenar los nombres de columna en documentos distintos.

Probemos exportando el objeto iris a un documento de texto llamado iris.txt a nuestro directorio de trabajo, usando como separador la coma, con nombres de columnas y sin nombre de renglones.

write.table(x = iris, file = "iris.txt", sep = ",", 
            row.names = FALSE, col.names = TRUE)

Importemos el archivo que hemos creado usando read.table().

iris_txt <- read.table(file = "iris.txt", header = TRUE, sep = ",")
head(iris_txt)
##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

Vamos a exportar iris como un documento .csv.

write.csv(x = iris, file = "iris.csv", row.names = FALSE)

R base no tiene una función para importar archivos almacenados en archivos con extensión .xsl y .xslx, creados con Excel.

Para importar datos desde este tipo de archivos, necesitamos instalar el paquete readxl, que contiene funciones específicas para realizar esta tarea. Lo cargamos mediante library(readxl).

Usaremos, principalmente dos funciones de este paquete.

  • read_excel(): Para importar archivos .xls y xlsx.

  • excel_sheets(): Para obtener los nombres de las pestañas en una hoja de cálculo de Excel.

1 Algunas librerías en R

Proponemos algunas librerías fundamentales en R para el propósito y objetivos de este curso sobre visualización.

Librería Breve Descripción
readr Proporciona una forma rápida y sencilla de leer datos rectangulares (como csv, tsv y fwf). Está diseñado para analizar de manera flexible muchos tipos de datos que se encuentran en la naturaleza, mientras sigue fallando cuando los datos cambian inesperadamente.
dplyr Proporciona una gramática de manipulación de datos, proporcionando un conjunto consistente de verbos que resuelven los desafíos más comunes de manipulación de datos.
ggplot2 Librería muy utilizada para realizar todo tipo de gráficos. No produce gráficos interactivos, aunque sí animaciones.
plotly Produce gráficos de todo tipo de tipo interactivo. Muy útil.
rbokeh Librería muy conocida en Python. Su versión en R nos permite realizar gráficos interactivos.
igraph Análisis y visualización de grafos.
leaflet Librería sofisticada para trabajo con mapas y datos geoespaciales. Visualización en todo tipo de mapas y redes espaciales.
flexdashboards Paneles interactivos sencillos para R. Puede usar flexdashboard para publicar grupos de visualizaciones de datos relacionados como un panel. Un tablero flexible puede ser estático (una página web estándar) o dinámico (un documento interactivo Shiny).
scatterplot3D Realiza gráficos en 3D.
lubridate El paquete lubridate nos facilita el tratamiento de fechas en R. Uno de los puntos fuertes de lubridate reside en formar parte de la colección de librerías tidyverse, una de las más usadas en el ámbito del Data Science. Se caracteriza por el uso de un lenguaje diseñado para humanos, integrando objetos fecha y fecha-hora.
mosaic Conjuntos de datos y utilidades del Proyecto MOSAIC (http://mosaic-web.org) utilizados para enseñar matemáticas, estadística, computación y modelado.
plyr Un conjunto de herramientas que resuelve un conjunto común de problemas: divide un problema en partes manejables, opera en cada parte y luego vuelve a unir todas las partes. Por ejemplo, es posible que desee: ajustar el mismo modelo a cada subconjunto de pacientes de un marco de datos, calcular rápidamente las estadísticas de resumen para cada grupo, realizar transformaciones grupales como escalar o estandarizar.