Vista general de R (continuación)
Material: Cuaderno original (.ipynb)
Continuación de la vista general de R. Repasa con más explicación lo visto en la segunda clase (matrices, valores especiales y texto) y agrega tres temas nuevos: funciones vectorizadas, listas y data frames. Termina con un mini taller que construye una tabla de datos paso a paso y la guarda en un archivo.
3.2 Matrices
En R, como en otros lenguajes de programación, una matriz es un arreglo de dos dimensiones, donde las entradas horizontales son las filas y las verticales las columnas. Se puede imaginar como un conjunto de vectores del mismo largo, puestos como columnas o como filas.
- ¿Qué se guarda en una matriz? Solo datos de un mismo tipo.
- ¿Cómo se declara? De varias maneras: indicando los elementos que la componen, o combinando vectores como filas o columnas.
- ¿Cómo se accede a sus elementos? Indicando la posición de la fila, seguida de la posición de la columna.
?matrix
A <- matrix(c(1, 5, 3, 2, 1, 1)
, nrow = 2
, ncol = 3
, byrow = FALSE
)
A
Se generan dos vectores. Para mostrar ambos objetos en una línea, las instrucciones se separan con ;.
c1 <- c(9, 10)
f1 <- c(7, 8, 9)
c1; f1
cbind() une vectores como columnas y rbind() los une como filas.
#?cbind
cbind(A, c1)
rbind(A, f1)
Al combinar ambas operaciones hay que tener cuidado: R recicla valores. La fila f1 tiene 3 valores y la matriz 7 columnas, así que R repite el vector para completar la fila; el último 7 no debería estar ahí.
rbind(cbind(A, c1, c1, c1, c1), f1)
u1 <- cbind(A, c1) # 2x4
u2 <- rbind(A, f1) # 3x3
u1; u2
Dos matrices solo se pueden unir por filas si tienen la misma cantidad de columnas.
rbind(u1, u2)
diag() define matrices diagonales.
#?diag
diag(c(1, 2, 3, 4, 5))
Dimensión y tipo
A
dim(A)
#?dim
dim() devuelve un vector de dos valores: primero las filas y después las columnas. Si se pide una posición que no existe, el resultado es NA.
# filas
dim(A)[1]
# columnas
dim(A)[2]
dim(A)[5] # no hay dato en esta posición
class(A)
typeof(A)
Acceso a los elementos
Se accede a los elementos de una matriz indicando la posición de la fila y de la columna de la casilla. Con un solo índice, en cambio, R recorre la matriz por columnas como si fuera un vector; funciona, pero no es la forma recomendada.
# Así no:
A[1]
A[2]
A[3]
# Así sí:
A[1, 2] # elemento de la fila 1, columna 2
A[2, 3] # elemento de la fila 2, columna 3
# Una fila completa
A[2, ]
# Una columna completa
A[, 3]
Para actualizar un dato se le asigna un valor nuevo.
A
A[2, 3] <- 9
A
# Dos casillas a la vez
c(A[1, 1], A[2, 3])
Matrices lógicas
T y F son abreviaturas de TRUE y FALSE.
ejemplo <- matrix(c(T, F, F, F, F, T)
, nrow = 2
, ncol = 3
, byrow = TRUE)
ejemplo
typeof(ejemplo); class(ejemplo)
Las casillas de una matriz se pueden evaluar con condiciones lógicas.
mayores_4 <- A >= 5
mayores_4
Una matriz lógica sirve como filtro: devuelve los elementos que están en las casillas TRUE.
A[ejemplo]
A[mayores_4]
Álgebra de matrices
La suma, la resta y la ponderación por un escalar usan los mismos operadores que los números y los vectores (+, -, *, /). Para multiplicar matrices se usa el operador %*%; para invertirlas, la función solve(); t() para trasponer, y det() para calcular el determinante de una matriz cuadrada.
A
B <- A + 2
B
# Suma de matrices
#A + B
M1 <- matrix(c(1, 1, 2, 3, 5, 8), ncol = 2) # 3x2
M1
El operador * no es la multiplicación matricial: multiplica casilla por casilla, así que exige matrices de la misma dimensión. A es de 2×3 y M1 de 3×2.
A * M1
A * A
#A * B
dim(A); dim(M1)
%*% es la multiplicación matricial.
M2 <- A %*% M1
M2
# Trasposición
A
t(A)
# Determinante
det(M2)
# Inversa
M2_inv <- solve(M2)
M2_inv
M2 %*% M2_inv
El resultado es la matriz identidad. Los valores fuera de la diagonal no salen exactamente cero porque el computador trabaja con decimales de precisión limitada: 8.326673e-17 es notación científica para un número con 16 ceros después de la coma, es decir, prácticamente cero.
4. Valores faltantes
En R existen valores especiales para representar la ausencia de un dato o un resultado indefinido: NA, NaN, Inf, -Inf y NULL.
3 > 4
3 == 3
3 == "a"
Comparar con NA (dato faltante) siempre da NA, incluso entre dos NA.
3 == NA
NA == NA
Para reconocer un dato faltante se usa is.na(). NaN (resultado indefinido) también cuenta como faltante; Inf (infinito) no.
is.na(3)
is.na(NA)
is.na(NaN)
is.na(Inf)
Inf > 1000000000
1/0
-1/0
0/NA
0/0
Inf + Inf
Inf * 0
5. Funciones (primera parte)
5.1 Funciones vectorizadas y operaciones con vectores
R es un lenguaje funcional, en el sentido de que prácticamente cada llamada a R es una función que puede recibir (o no) argumentos de entrada. Una de sus ventajas es la enorme variedad de funciones disponibles, tanto en las librerías que vienen con la instalación como en las publicadas en CRAN y en toda la comunidad de R.
Una función se dice vectorizada si, dado un vector , se tiene que : se aplica a cada elemento. Esto hace que la aritmética de vectores sea más sencilla de escribir y más rápida de calcular. Gran parte de las funciones de las librerías (packages) de R son vectorizadas.
Algunas de las más básicas, aritméticas y para trabajar con texto, son: +, -, *, /, abs(), sqrt(), cos(), sin(), tan(), nchar(), substr(), grepl() y gsub().
x <- c(4, 16, 9)
c(1, 2, 3) + c(1, 1, 4)
sqrt(x) # raíz cuadrada
Funciones para manipular texto
nchar("hola") # cantidad de caracteres
nchar(c("hola", "soy", "miguel"))
substr("Hola soy miguel", start = 2, stop = 6) # el texto tiene largo 15
numero_letra <- substr("02_miguel", 1, 2)
numero_letra
as.numeric() convierte un texto en número.
as.numeric(numero_letra)
# o bien as.numeric(substr("02_miguel", 1, 2))
grepl() evalúa si un texto está contenido en otro, como el LIKE de SQL.
#?grepl()
grepl("ab", "sabcd")
grepl("ab", c("sabcd", "csdd", "sxxabcd"))
gsub() reemplaza caracteres dentro de un texto. Aquí se quitan los guiones de dos fechas, se extraen los seis primeros caracteres (año y mes) y se convierten a número, con lo que ya se puede operar: por ejemplo, sumar 1.
fecha <- gsub("-", "", c("2019-05-15", "2019-05-29"))
fecha_char <- substr(fecha, 1, 6)
num <- as.numeric(fecha_char)
fecha
fecha_char
typeof(fecha_char)
typeof(num)
Un solo tipo de dato por vector o matriz
No se pueden mezclar tipos de datos en un mismo vector: si hay un texto, R convierte todo a texto.
c("1", 2, 3)
M <- matrix(c(1, 2, 3, 4), ncol = 2)
M
Lo mismo ocurre en una matriz: al asignar un texto en una casilla, todas las demás pasan a ser texto.
M[1, 1] <- "a"
M
6. Listas y data frames
6.1 Listas
Hasta aquí hay dos tipos de objetos para guardar datos: vectores y matrices. Ambos tienen la limitación de que no permiten combinar distintos tipos de datos. Un objeto más flexible es la lista: un arreglo de una dimensión donde cada entrada puede guardar un objeto distinto, que a su vez puede contener cualquier tipo de dato u otros objetos.
- ¿Qué son? Arreglos de una dimensión que guardan distintos tipos de datos u objetos.
- ¿Cómo se declaran? Con
list(), o combinando listas existentes. - ¿Cómo se accede a sus elementos? Con
[], que devuelve una lista, o con[[]], que devuelve el objeto. En ambos casos se indica la posición o el nombre. Otra manera es con el signo$seguido del nombre.
Los objetos se pueden guardar en casillas con nombre.
l <- list(num = 1
, pepito = "hola"
, logy = TRUE
, vecstop = c(1, 2, 3)
, matifer = M)
l
M1
l2 <- list(matifer2 = M1)
l2
Las listas se combinan con c(), igual que los vectores.
l3 <- c(l, l2)
l3
Acceso por posición
l3[1] # devuelve una lista con la casilla 1
class(l3[1])
l3[[1]] # devuelve el objeto de la casilla 1
class(l3[[1]])
Acceso por nombre
l3["num"]
l3[["num"]]
# o bien, más fácil:
l3$num
Crear casillas nuevas
Se crea una casilla nueva indicando su nombre entre [[]] y asignándole un valor.
l3[["new_slot"]] <- c("gracias", "armin")
l3
O indicando el nombre después de $.
l3$new_slot2 <- "cualquier cosa vera"
l3
Largo y nombres
length() entrega el largo de una lista o de un vector, y names() sus nombres.
length(l3)
nchar(l3)
names(l3)
nchar() sobre una lista no cuenta sus elementos: cuenta los caracteres del texto con que R escribe cada uno. Por eso vecstop da 10, que es el largo de c(1, 2, 3). Rara vez es útil; para saber cuántos elementos hay se usa length().
Para renombrar las casillas se asigna un vector de nombres.
names(l3) <- c("n1", "n2", "n3", "n4", "n5", "n6", "n7", "n8")
names(l3)
l3
6.2 Data frames
Un data frame es un caso particular de lista, donde cada entrada es un vector de datos y todos tienen el mismo largo. Cada vector es una columna, y la cantidad de filas es el largo común. El resultado es una tabla cuyas columnas pueden tener distintos tipos de datos entre sí.
- ¿Cómo se declara? Con la función
data.frame(), indicando los vectores que formarán las columnas. - ¿Cómo se accede a los datos? Al ser una lista, de la misma manera que a una lista. También se puede acceder como a los elementos de una matriz.
# 1:5 es lo mismo que c(1, 2, 3, 4, 5)
df <- data.frame(id = 1:5,
nombre = c("armin", "alfredo", "paula", "alejandro", "claudio"))
df
names(df)
dim(df)
class(df)
Con $ se obtiene una columna, que es un vector.
df$nombre
6.3 Mini taller
Los data frames son uno de los objetos más usados en R para analizar datos en forma de tabla. Por eso es frecuente tener que consultarlos: filtrar, cruzar tablas, crear columnas. Por ahora se verá una de las formas más básicas de manipularlos, con el siguiente ejercicio.
Paso 1
Con la función rnorm(), generar una muestra aleatoria de 100 datos con media 21 y desviación estándar 8, y guardarla en una variable llamada temp.
temp <- rnorm(100, mean = 21, sd = 8)
temp
mean(temp)
median(temp)
Paso 2
Generar un vector llamado dia, del mismo largo que temp, que contenga los días consecutivos de la semana partiendo del lunes, usando la función rep().
length(temp)
Con length.out, rep() repite el vector hasta completar el largo pedido.
dia <- rep(c("L", "M", "W", "J", "V", "S", "D")
, length.out = length(temp)
)
dia
?rep
Paso 3
Generar un vector llamado est, del mismo largo que temp, que contenga el valor "E1" en el primer tercio, "E2" en el segundo y "E3" en el tercero. Por ejemplo, si temp tuviese 10 datos, est sería (E1, E1, E1, E2, E2, E2, E3, E3, E3, E3).
veces <- round(length(temp) / 3) + 1
veces
Con each, rep() repite cada elemento esa cantidad de veces antes de pasar al siguiente.
est <- rep(c("E1", "E2", "E3")
, each = veces
, length.out = length(temp)
)
est
Paso 4
Generar un vector llamado lluvia, del mismo largo que temp, que sea TRUE en las posiciones en que temp sea menor que 20 y FALSE en caso contrario. Se puede usar la función which().
Opción 1. La comparación ya devuelve el vector lógico que se busca.
lluvia <- temp < 20
lluvia
Opción 2 (la vuelta larga). which() devuelve las posiciones donde se cumple la condición.
posic <- which(temp < 20)
posic
Después se crea un vector con 100 valores FALSE y se cambian a TRUE solo esas posiciones. El resultado es el mismo.
lluvia <- rep(FALSE, 100)
lluvia[posic] <- TRUE
lluvia
Paso 5
Finalmente, crear un data frame llamado precipitaciones con las siguientes columnas:
Dia_semana, con los valores del vectordia.Temperatura, con los valores del vectortemp.Llueve, con los valores del vectorlluvia.Estacion, con los valores del vectorest.
precipitaciones <- data.frame(Dia_semana = dia,
Temperatura = temp,
Llueve = lluvia,
Estacion = est)
precipitaciones
dim(precipitaciones)
names(precipitaciones)
summary() resume cada columna según su tipo: para los números entrega mínimo, cuartiles, media y máximo; para los valores lógicos, cuántos TRUE y FALSE hay.
summary(precipitaciones)
Texto como factores
class(precipitaciones$Estacion)
precipitaciones$Estacion <- as.character(precipitaciones$Estacion)
class(precipitaciones$Estacion)
summary(precipitaciones)
El resumen es el mismo de antes, porque la columna ya era texto.
Un factor es una variable categórica: una columna que solo toma un conjunto limitado de valores, como el día de la semana o la estación. Cuando una variable se declara como factor, R trata cada categoría como una columna de ceros y unos: un 1 si la fila pertenece a esa categoría y un 0 si no. Para Dia y Estacion, esa codificación (la matriz de diseño) se vería así:
| Dia | Estacion | Dia.L | Dia.M | Dia.W | Dia.J | Dia.V | Dia.S | Dia.D | Est.1 | Est.2 | Est.3 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| L | E1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| M | E1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| J | E3 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |
| S | E3 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
Cuando se quiere resumir una variable categórica, o incluirla en el entrenamiento de un modelo, es necesario declararla como factor. Con una columna declarada así, summary() cuenta cuántas filas hay en cada categoría en vez de mostrar solo el largo.
Un poco de exploración
Tres preguntas sobre la tabla:
- ¿Cuál es la temperatura promedio cuando llovió?
- ¿Qué día era cuando se alcanzó la temperatura mínima? ¿Y la máxima?
- Se sabe que la estación E3 falla todos los domingos, por lo que hay que eliminar esos registros de la tabla.
Solución de la exploración
1. Se filtra la columna de temperatura con la columna lógica Llueve y se promedia.
mean(precipitaciones$Temperatura[precipitaciones$Llueve])
Con la muestra de este taller hay 45 días de lluvia y su temperatura promedio es de unos 14,3.
2. which.min() y which.max() entregan la fila donde está el mínimo y el máximo; con esa fila se consulta el día.
precipitaciones$Dia_semana[which.min(precipitaciones$Temperatura)]
precipitaciones$Dia_semana[which.max(precipitaciones$Temperatura)]
La mínima (−1,14) está en la fila 4, un jueves ("J"), y la máxima (40,92) en la fila 13, un sábado ("S").
3. Un data frame se filtra como una matriz: entre corchetes van primero las filas y después las columnas. Se conservan las filas que no cumplen ambas condiciones a la vez.
falla <- precipitaciones$Estacion == "E3" & precipitaciones$Dia_semana == "D"
precipitaciones <- precipitaciones[!falla, ]
dim(precipitaciones)
Se eliminan 5 filas (las 70, 77, 84, 91 y 98) y la tabla queda con 95.
Si la pregunta 3 se resuelve antes de guardar, el archivo de la sección siguiente queda con 95 filas en vez de 100.
6.4 Guardar variables y el ambiente de trabajo
Directorio de trabajo
El directorio de trabajo es la carpeta del sistema de archivos desde la cual la sesión de R guarda y carga datos directamente. getwd() indica en qué directorio se está trabajando y setwd() lo cambia.
# Para saber en qué directorio se está trabajando
getwd()
# Para cambiar el directorio de trabajo
setwd("ruta/de/la/carpeta")
Formato rds
Una manera de guardar variables creadas en la sesión de R es el formato .rds. Permite guardar un objeto y leerlo rápidamente en cualquier sesión posterior. Es útil, por ejemplo, para guardar en disco modelos entrenados y usarlos después en predicciones.
saveRDS() guarda el data frame precipitaciones en el directorio actual. Este archivo es el que se carga en Condicionales y ciclos.
saveRDS(precipitaciones, "precipitaciones.rds")
Para leerlo después se usa readRDS():
precipitaciones <- readRDS("precipitaciones.rds")
Formato RData
Cuando se quiere guardar el ambiente de trabajo completo, o varios objetos a la vez, se usa la función save(). Los objetos se recuperan con load(), con los mismos nombres que tenían.
# Guarda uno o más objetos del ambiente
save(precipitaciones, temp, file = "taller.RData")
# Los carga de vuelta
load("taller.RData")