⏱ ≈ 2 min
Seguimos con el mapa de estructuras. Ya vimos los vectores; hoy damos el siguiente paso: las matrices, que son datos organizados en filas y columnas. Y ojo, porque esto nos acerca a la base matemática de muchos de los modelos que vamos a ver más adelante.
En R, toda la información se almacena en objetos. Dependiendo de cómo estén organizados los datos, estos objetos pueden adoptar distintas estructuras. Existen cuatro estructuras principales en R:
Continuamos con nuestro estudio de las matrices.
⏱ ≈ 24 min (creación, cbind() y rbind(), e
índices)
Piensen en una matriz como un vector al que le dimos forma: son los mismos datos, pero ahora con filas y columnas. Y como el vector, solo guarda un tipo de dato.
Una matriz en R es una estructura de datos bidimensional para almacenar objetos del mismo tipo.
Para crear una matriz se utiliza la función matrix()
cuyos argumentos son:
A <- matrix(1:10, nrow= 5)
A
## [,1] [,2]
## [1,] 1 6
## [2,] 2 7
## [3,] 3 8
## [4,] 4 9
## [5,] 5 10
B <- matrix(21:40, nrow=2)
length(21:40)
## [1] 20
B
## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
## [1,] 21 23 25 27 29 31 33 35 37 39
## [2,] 22 24 26 28 30 32 34 36 38 40
C <- matrix(14:25, nrow= 5)
## Warning in matrix(14:25, nrow = 5): data length [12] is not a sub-multiple or
## multiple of the number of rows [5]
C
## [,1] [,2] [,3]
## [1,] 14 19 24
## [2,] 15 20 25
## [3,] 16 21 14
## [4,] 17 22 15
## [5,] 18 23 16
nrow(A)
## [1] 5
nrow(B)
## [1] 2
nrow(C)
## [1] 5
ncol(A)
## [1] 2
ncol(B)
## [1] 10
ncol(C)
## [1] 3
dim(A)
## [1] 5 2
dim(B)
## [1] 2 10
dim(C)
## [1] 5 3
is.vector(dim(C))
## [1] TRUE
Fíjense en el warning de la matriz C: los datos no alcanzan para
completar la matriz y R recicla, es el mismo reciclaje que vimos con los
vectores. Y noten que, por defecto, R llena por columnas; por eso existe
el argumento byrow.
secuencia <- seq(1,12,2)
secuencia
## [1] 1 3 5 7 9 11
length(secuencia)
## [1] 6
matriz1 <- matrix(secuencia, ncol= 2)
matriz1
## [,1] [,2]
## [1,] 1 7
## [2,] 3 9
## [3,] 5 11
matriz2 <- matrix(secuencia, ncol = 3)
matriz1; matriz2
## [,1] [,2]
## [1,] 1 7
## [2,] 3 9
## [3,] 5 11
## [,1] [,2] [,3]
## [1,] 1 5 9
## [2,] 3 7 11
matriz3 <- matrix(secuencia, ncol = 3, byrow = TRUE)
matriz2; matriz3
## [,1] [,2] [,3]
## [1,] 1 5 9
## [2,] 3 7 11
## [,1] [,2] [,3]
## [1,] 1 3 5
## [2,] 7 9 11
matriz4 <- matrix(secuencia,
ncol = 3,
byrow = T,
dimnames = list(c("F1","F2"),c("C1","C2","C3"))
)
matriz4
## C1 C2 C3
## F1 1 3 5
## F2 7 9 11
cbind() y rbind()Cuando ya tenemos los datos en vectores, podemos armar una matriz
pegándolos: cbind() los une como columnas
y rbind() los une como filas.
v1 <- c(1, 2, 3)
v2 <- c(4, 5, 6)
cbind(v1, v2) # une los vectores como columnas
## v1 v2
## [1,] 1 4
## [2,] 2 5
## [3,] 3 6
rbind(v1, v2) # une los vectores como filas
## [,1] [,2] [,3]
## v1 1 2 3
## v2 4 5 6
También podemos ponerles nombre directamente a las filas o columnas:
rbind("Producto A" = c(10, 20, 30),
"Producto B" = c(15, 25, 35))
## [,1] [,2] [,3]
## Producto A 10 20 30
## Producto B 15 25 35
cbind y rbind son la forma más natural de
armar una matriz cuando los datos ya viven en vectores. Los nombres que
les damos a los vectores se convierten en los nombres de las columnas o
de las filas. Esto lo vamos a usar en la primera actividad.
Esto es lo mismo que hicimos con los vectores, pero ahora con dos
índices: primero la fila y luego la columna, separados por una coma.
Antes de correr el chunk, piensen: ¿qué creen que devuelve
M2[2, ], con la columna vacía?
M2 <- matrix(1:12, nrow = 3,
dimnames = list(c("F1","F2","F3"), c("C1","C2","C3","C4")))
M2
## C1 C2 C3 C4
## F1 1 4 7 10
## F2 2 5 8 11
## F3 3 6 9 12
M2[2, 3] # fila 2, columna 3
## [1] 8
M2[2, ] # toda la fila 2
## C1 C2 C3 C4
## 2 5 8 11
M2[, 3] # toda la columna 3
## F1 F2 F3
## 7 8 9
M2[1:2, c(1,4)] # varias filas y varias columnas
## C1 C4
## F1 1 10
## F2 2 11
M2[-1, ] # todo menos la fila 1
## C1 C2 C3 C4
## F2 2 5 8 11
## F3 3 6 9 12
M2["F2", "C3"] # también por nombres
## [1] 8
M2[M2 > 6] # índices lógicos (devuelve un vector)
## [1] 7 8 9 10 11 12
Para saber en qué fila y columna está un valor, usamos
which() con arr.ind = TRUE:
min(M2)
## [1] 1
which(M2 == min(M2), arr.ind = TRUE)
## row col
## F1 1 1
⏱ ≈ 34 min (tabla, operaciones básicas, sistemas de ecuaciones y funciones por filas y columnas)
No tienen que memorizar esta tabla; es una referencia para consultar.
Hoy vamos a usar varias de estas funciones, y otras las retomamos más
adelante: crossprod() en regresión lineal y
eigen() en componentes principales.
| Operación | Código en R |
|---|---|
| Sumar dos matrices | matriz_a + matriz_b |
| Restar dos matrices | matriz_a - matriz_b |
| Multiplicar una matriz por un escalar | matriz_a * 2 |
| Multiplicar dos matrices | matriz_a %*% matriz_b |
| Transponer una matriz | t(matriz_a) |
| Determinante de una matriz cuadrada | det(matriz_a) |
| Inversa de una matriz | solve(matriz_a) |
Resolver el sistema matriz_a %*% x = b |
solve(matriz_a, b) |
| Diagonal principal de una matriz | diag(matriz_a) |
Operación t(matriz_a) %*% matriz_b |
crossprod(matriz_a, matriz_b) |
| Media de filas o columnas | rowMeans(matriz_a) /
colMeans(matriz_a) |
| Extraer fila o columna | matriz_a[1, ] / matriz_a[, 2] |
| Calcular los eigenvalores de una matriz simétrica | eigen(matriz_a) |
Nota: Los eigenvalores indican cuánto escala la matriz en determinadas direcciones privilegiadas (sus eigenvectores). Por ejemplo, en PCA, los eigenvalores de la matriz de covarianzas representan la cantidad de varianza explicada por cada componente principal.
matrizA <- matrix(1:4, 2, 2)
matrizB <- matrix(5:8, 2, 2)
matrizA; matrizB
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
## [,1] [,2]
## [1,] 5 7
## [2,] 6 8
# Suma de matrices
matriz_suma <- matrizA + matrizB
matriz_suma
## [,1] [,2]
## [1,] 6 10
## [2,] 8 12
# Resta de matrices
matriz_resta <- matrizB - matrizA
matriz_resta
## [,1] [,2]
## [1,] 4 4
## [2,] 4 4
Diferencia entre multiplicación elemento a elemento y multiplicación matricial.
matrizA; matrizB
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
## [,1] [,2]
## [1,] 5 7
## [2,] 6 8
multiplicacion_elemento <- matrizA * matrizB
multiplicacion_elemento
## [,1] [,2]
## [1,] 5 21
## [2,] 12 32
multiplicacion_matricial <- matrizA %*% matrizB
multiplicacion_matricial
## [,1] [,2]
## [1,] 23 31
## [2,] 34 46
Esta es la diferencia que más se confunde: * multiplica
elemento a elemento, posición por posición, igual que con los vectores.
%*% es el producto matricial, filas por columnas. Si las
dimensiones no son compatibles, R nos lo hace saber con un error.
matrizA
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
# Transpuesta
# La transpuesta de una matriz se obtiene intercambiando sus filas por columnas.
matriz_transpuesta <- t(matrizA)
matriz_transpuesta
## [,1] [,2]
## [1,] 1 2
## [2,] 3 4
# Determinante de la matriz
# Solo para matrices cuadradas (mismo num de rows y col)
# Indica si una matriz tiene inversa
# Más adelante, servirá para medir la dispersión conjunta de variables aleatorias.
det_A <- det(matrizA)
det_A
## [1] -2
# Inversa de la matriz
# Si det(A) ≠ 0, la inversa es la matriz que, al multiplicarse
# por la matriz original resulta en la identidad
inversa_A <- solve(matrizA)
inversa_A
## [,1] [,2]
## [1,] -2 1.5
## [2,] 1 -0.5
El determinante nos avisa si la matriz tiene inversa: si es cero, no
hay inversa y solve() nos marcaría un error. Vean que la
inversa multiplicada por la matriz original nos regresa la
identidad.
Una de las aplicaciones más útiles de las matrices es resolver sistemas de ecuaciones.
Una aseguradora vende dos tipos de póliza, A y B. Un paquete con 2 pólizas A y 1 póliza B cuesta 10 mil, y un paquete con 1 póliza A y 3 pólizas B cuesta 15 mil. ¿Cuánto cuesta cada póliza?
\[2x + y = 10\] \[x + 3y = 15\]
M <- matrix(c(2, 1,
1, 3), nrow = 2, byrow = TRUE)
b <- c(10, 15)
solve(M, b) # resuelve M %*% x = b
## [1] 3 4
solve(M) %*% b # equivalente: x = inversa de M por b
## [,1]
## [1,] 3
## [2,] 4
M %*% solve(M, b) # verificación: debe regresar b
## [,1]
## [1,] 10
## [2,] 15
Aquí es donde las matrices dejan de ser algo abstracto: resolver un sistema de ecuaciones es una sola línea. Y esta misma idea la vamos a usar cuando lleguemos a regresión lineal: los coeficientes del modelo salen de resolver un sistema parecido, (X’X)β = X’y. Por eso insisto en que las matrices son la base de muchos modelos.
Uso de las funciones rowSums(), colSums(), rowMeans() y colMeans() para obtener estadísticas de filas y columnas.
matrizA
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
suma_filas <- rowSums(matrizA)
matrizA; suma_filas
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
## [1] 4 6
suma_columnas <- colSums(matrizA)
suma_columnas
## [1] 3 7
promedio_filas <- rowMeans(matrizA)
promedio_filas
## [1] 2 3
promedio_columnas <- colMeans(matrizA)
promedio_columnas
## [1] 1.5 3.5
⏱ ≈ 12 min
Ahora a aplicarlo. Antes de escribir código, piensen: ¿qué forma debe
tener la matriz de tasas? Yo propongo una fila por plazo y una columna
por producto, y la armamos con cbind().
Eres un analista en una compañía de seguros y debes evaluar la rentabilidad de dos productos de inversión.
Productos:
Plazos de Inversión:
Objetivo:
# Tasas de interés anual (%) para los años 1, 3 y 5
tasa_A <- c(1.5, 2, 2.5)
tasa_B <- c(3, 3.5, 4)
# cbind(): una columna por producto y una fila por plazo
tasas_interes <- cbind("Producto A" = tasa_A, "Producto B" = tasa_B)
rownames(tasas_interes) <- c("1 año", "3 años", "5 años")
tasas_interes
## Producto A Producto B
## 1 año 1.5 3.0
## 3 años 2.0 3.5
## 5 años 2.5 4.0
capital_inicial <- 10000
plazos <- c(1, 3, 5)
# El vector de plazos se recicla por columnas: cada fila se eleva a su plazo
valor_futuro <- capital_inicial * (1 + tasas_interes/100)^plazos
tasas_interes; valor_futuro
## Producto A Producto B
## 1 año 1.5 3.0
## 3 años 2.0 3.5
## 5 años 2.5 4.0
## Producto A Producto B
## 1 año 10150.00 10300.00
## 3 años 10612.08 11087.18
## 5 años 11314.08 12166.53
Fíjense en el truco: el vector de plazos tiene tres elementos y la matriz tiene tres filas, así que R lo recicla hacia abajo en cada columna. Cada fila se eleva a su propio plazo, sin ciclos y en una sola línea.
⏱ ≈ 33 min (datos, pagos y los dos gráficos)
Eres un analista financiero de una concesionaria de autos y te han solicitado realizar un análisis detallado de los pagos mensuales de diferentes modelos de autos bajo diversos planes de financiamiento. La concesionaria ofrece financiamientos a plazos de 36, 48, 60 y 72 meses, con tasas de interés anuales que varían según el modelo de auto.
Se tiene tres modelos con los siguientes precios:
Tasas de interés anual nominal (capitalizables mensualmente) por modelo:
Plazos de financiamiento:
Objetivos:
| Modelo A | Modelo B | Modelo C | |
|---|---|---|---|
| 36 m | |||
| 48 m | |||
| 60 m | |||
| 72 m |
tasas_nom <- c(19.5,6.5,5.5)
precios <- c(270000,350000,450000)
plazos <- c(36,48,60,72)
# Con names() podemos ponerle nombre a cada elemento de un vector
names(precios) <- c("Modelo A","Modelo B","Modelo C")
precios
## Modelo A Modelo B Modelo C
## 270000 350000 450000
tasas_mensuales <- tasas_nom/100/12
tasas_matriz <- matrix(rep(tasas_mensuales,4),nrow = 4, byrow = T)
tasas_matriz
## [,1] [,2] [,3]
## [1,] 0.01625 0.005416667 0.004583333
## [2,] 0.01625 0.005416667 0.004583333
## [3,] 0.01625 0.005416667 0.004583333
## [4,] 0.01625 0.005416667 0.004583333
dim(tasas_matriz)
## [1] 4 3
precios_matriz <- matrix(rep(precios,4), nrow = 4, byrow = T)
precios_matriz
## [,1] [,2] [,3]
## [1,] 270000 350000 450000
## [2,] 270000 350000 450000
## [3,] 270000 350000 450000
## [4,] 270000 350000 450000
dim(precios_matriz)
## [1] 4 3
plazos_matriz <- matrix(rep(plazos,3), nrow = 4, byrow = F)
plazos_matriz
## [,1] [,2] [,3]
## [1,] 36 36 36
## [2,] 48 48 48
## [3,] 60 60 60
## [4,] 72 72 72
dim(plazos_matriz)
## [1] 4 3
Para operar elemento a elemento necesitamos matrices de la misma forma. Por eso repetimos las tasas, los precios y los plazos hasta completar una matriz de 4 filas por 3 columnas: cada posición corresponde a un modelo y a un plazo.
Nota: La fórmula del valor presente de una anualidad vencida es:
\[ VP = R \cdot \frac{1 - (1+i)^{-n}}{i} \]
donde:
- \(VP\) : valor presente de la anualidad
- \(R\) : pago periódico
- \(i\) : tasa de interés por periodo
- \(n\) : número de periodosEn una anualidad vencida, los pagos se realizan al final de cada periodo.
pagos_mensuales <- precios_matriz * tasas_matriz / (1-(1+tasas_matriz)^(-plazos_matriz))
pagos_mensuales
## [,1] [,2] [,3]
## [1,] 9965.514 10727.151 13588.156
## [2,] 8144.443 8300.234 10465.414
## [3,] 7078.440 6848.152 8595.523
## [4,] 6389.249 5883.475 7352.049
rownames(pagos_mensuales) <- c("36 m","48 m","60 m","72 m")
colnames(pagos_mensuales) <- c("Modelo A","Modelo B","Modelo C")
pagos_mensuales
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
dimnames(pagos_mensuales) <- list(1:4,1:3)
pagos_mensuales
## 1 2 3
## 1 9965.514 10727.151 13588.156
## 2 8144.443 8300.234 10465.414
## 3 7078.440 6848.152 8595.523
## 4 6389.249 5883.475 7352.049
dimnames(pagos_mensuales) <- list(c("36 m","48 m","60 m","72 m"),
c("Modelo A","Modelo B","Modelo C"))
pagos_mensuales; t(pagos_mensuales)
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
## 36 m 48 m 60 m 72 m
## Modelo A 9965.514 8144.443 7078.440 6389.249
## Modelo B 10727.151 8300.234 6848.152 5883.475
## Modelo C 13588.156 10465.414 8595.523 7352.049
Aprovechamos esta actividad para presentar un par de gráficos interesantes:
matplot()No se aprendan todos los argumentos de memoria. Lo importante es la
lógica: en matplot() cada columna de la matriz es una
curva.
Emplearemos matplot(), función diseñada para graficar
todas las columnas de una matriz al mismo tiempo.
Al tratarse de un gráfico base, se construye por capas
superpuestas. matplot() abre el lienzo;
axis() y legend() escriben encima. Por eso el
orden importa y por eso hay que apagar el eje antes de poder
redibujarlo.
Cuando le pasamos una matriz (o un dataframe) a
matplot() cada columna se convierte en una curva distinta.
Usando la matriz pagos_mensuales, que tiene una fila por
plazo y una columna por modelo de préstamo, surgen tres curvas
superpuestas.
Respecto a los argumentos, podemos configurar:
type = "b" significa both: dibuja la línea
y los puntos.pch (plot character) es la forma del punto:
círculo, triángulo, cruz.lty (line type) es el estilo de la línea:
continua, punteada, rayada.col es el color.Para estos argumentos: pch, lty,
col usamos vectores para que R reparta los tipos entre las
columnas. Es decir, la primera serie se dibuja con el símbolo 1, la
línea tipo 1 y el color 1, la segunda con el 2, y así. Eso es lo que
hace que cada modelo se distinga visualmente.
Para los ejes, matplot() hace que el eje X use
automáticamente los índices de fila: 1, 2, 3, 4. El eje Y usa los
valores numéricos.
xaxt = "n" le dice a R que no dibuje
el eje X automático.Añadimos una capa para reconfigurar los ejes.
El 1 inicial indica el lado: 1 = abajo, 2 =
izquierda, 3 = arriba, 4 = derecha.
at = 1:4 son las posiciones donde van las marcas, y
labels = rownames(pagos_mensuales) toma los nombres de las
filas de la matriz como etiquetas. Así, donde antes decía “1” ahora dice
el plazo que corresponde. Es importante que at y
labels tengan la misma longitud.
Por último, añadimos una capa más para las referencias, esta será
legend.
"topright" ubica el recuadro en la esquina superior
derecha. legend = colnames(...) usa los nombres de las
columnas como etiquetas de cada serie.
Repetimos col, lty y pch
con los mismos valores que en matplot()
para garantizar que el cuadradito de la leyenda coincida con la curva
del gráfico. Si cambiamos los colores de arriba la leyenda no
coincide.
# El gráfico se arma en tres pasos: primero se dibujan las curvas, después se personaliza el eje X y por último se agrega la leyenda.
matplot(pagos_mensuales,
type = "b", # líneas y puntos
pch = 1:3, # símbolo de los puntos para cada serie
lty = 1:3, # tipo de línea para cada serie
col = 1:3, # color de cada serie
xaxt = "n", # oculta el eje X por defecto
xlab = "Plazo",# etiqueta del eje X
ylab = "Monto de pago", # etiqueta del eje Y
main = "Comparación de pagos por modelo" # título del gráfico
)
axis(1,
at = 1:4, # posiciones de las marcas en el eje X
labels = rownames(pagos_mensuales)) # etiquetas personalizadas
legend("topright", # ubicación de la leyenda
legend = colnames(pagos_mensuales), # nombres de las series
col = 1:3, # colores de la leyenda
lty = 1:3, # tipos de línea de la leyenda
pch = 1:3) # símbolos de puntos de la leyenda
La gráfica de líneas resulta más adecuada cuando se desea analizar la tendencia de los pagos en función del plazo, ya que permite observar con mayor claridad la evolución entre 36, 48, 60 y 72 meses.
barplot()La diferencia clave con el gráfico anterior: en
matplot() las columnas son series, en
barplot() las columnas son grupos. Por eso aquí trasponemos
la matriz con t().
Emplearemos barplot(), función que también acepta una
matriz, pero la interpreta de otra manera: cada columna
se convierte en un grupo sobre el eje X y cada fila se
convierte en una barra dentro de ese grupo.
Nuestra matriz tiene los plazos en las filas y los modelos en las
columnas; si la pasáramos tal cual, cada modelo sería un grupo y cada
plazo una barra dentro. Como queremos lo contrario —un grupo por plazo,
comparando los tres modelos dentro de cada uno— la trasponemos con
t().
En
matplot()las columnas son series, enbarplot()las columnas son grupos.
Respecto a los argumentos, podemos configurar:
beside = TRUE coloca las barras del grupo una al
lado de la otra. Si lo omitimos, R apila las barras y el gráfico pasa a
leerse como una suma acumulada, que no es lo que buscamos: aquí los
pagos de distintos modelos son alternativas, no componentes que se
sumen.
col recibe un vector con un color por barra dentro
del grupo, es decir, uno por modelo. R lo recicla en todos los grupos,
así que el Modelo A queda del mismo color en los cuatro plazos.
legend = colnames(pagos_mensuales) arma la
referencia. A diferencia de matplot(), aquí no necesitamos
una capa aparte: barplot() puede dibujar la leyenda por su
cuenta. Si el recuadro tapa alguna barra, se reubica con
args.legend = list(x = "topleft").
Para los ejes, barplot() etiqueta el eje X solo, usando
los nombres de las columnas de la matriz que recibió, que en este caso
son los plazos. Por eso no hace falta apagar el eje ni redibujarlo como
hicimos antes.
Si quisiéramos superponer una línea sobre las barras, necesitamos
saber en qué posición horizontal quedó cada una. barplot()
devuelve esas posiciones de forma invisible, así que hay que guardarlas
asignando el resultado a un objeto:
bp <- barplot(t(pagos_mensuales),
beside = TRUE,
col = c("skyblue", "salmon", "lightgreen"),
#legend = colnames(pagos_mensuales),
main = "Pagos por modelo y plazo",
xlab = "Plazos",
ylab = "Monto de pago")
# bp es una matriz con las coordenadas X de cada barra:
# una fila por modelo y una columna por plazo.
# bp[1,] son las posiciones en X de las barras del Modelo A en cada plazo.
# lines(bp[1,], pagos_mensuales[,"Modelo A"], col = "darkblue", lwd = 2, type = "b", pch = 19)
La gráfica de barras facilita la comparación directa de los montos específicos entre los distintos modelos en cada plazo, permitiendo identificar diferencias puntuales de manera más visual.
El financiamiento del Modelo A resulta conveniente solo en plazos cortos, gracias a su menor precio. Sin embargo, su tasa de interés considerablemente más alta (19.5% vs 6.5%) hace que, a partir de aproximadamente el año 4-5 de financiamiento, el costo mensual supere al del Modelo B, más caro en precio de lista pero con una tasa mucho más favorable. Esto demuestra que la decisión de financiamiento no debe basarse solo en el precio del vehículo, sino en el costo total del crédito a lo largo del plazo elegido.
⏱ ≈ 2 min
Y bueno, con esto cerramos la parte de matrices: ya saben crearlas, sacar justo los datos que necesitan, operar con ellas, resolver un sistema de ecuaciones y aplicarlas a un caso real de financiamiento. Si algo no les quedó claro, no se preocupen, lo vamos a retomar cuando lleguemos a regresión lineal. Tomemos un descanso de 10 minutos y, al regresar, pasamos al mundo real: los data frames, las tablas con las que de verdad vamos a trabajar.
⏱ ≈ 5 min
Usemos la matriz de pagos que construimos para cerrar el caso de
financiamiento: la gerencia quiere responder algunas preguntas
específicas, y vamos a usar justo lo que aprendimos de índices en
matrices, la notación [fila, columna].
Usamos la matriz pagos_mensuales que construimos antes
del descanso:
pagos_mensuales
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
Imaginemos que después de calcular los pagos mensuales, la gerencia quiere responder algunas preguntas específicas:
pagos_mensuales
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
pagos_mensuales[2,2]
## [1] 8300.234
pagos_mensuales["48 m","Modelo B"]
## [1] 8300.234
pagos_mensuales[c(3,4),]
## Modelo A Modelo B Modelo C
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
pagos_mensuales[c("60 m","72 m"),]
## Modelo A Modelo B Modelo C
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
pagos_mensuales
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
minimo <- min(pagos_mensuales)
posicion <- which(pagos_mensuales == minimo, arr.ind = TRUE)
posicion[1] # renglón
## [1] 4
posicion[2] # columna
## [1] 2
plazo <- rownames(pagos_mensuales)[posicion[1]]
modelo <- colnames(pagos_mensuales)[posicion[2]]
pagos_mensuales
## Modelo A Modelo B Modelo C
## 36 m 9965.514 10727.151 13588.156
## 48 m 8144.443 8300.234 10465.414
## 60 m 7078.440 6848.152 8595.523
## 72 m 6389.249 5883.475 7352.049
modelo
## [1] "Modelo B"
plazo
## [1] "72 m"
cat("El menor pago mensual es de $",
round(minimo,2),
"correspondiente al",
modelo,
"en un plazo de",
plazo,
".")
## El menor pago mensual es de $ 5883.48 correspondiente al Modelo B en un plazo de 72 m .
Fíjense que las dos primeras preguntas se responden de dos formas: por posición y por nombre. Con nombres el código se lee solo, y no dependemos de recordar en qué fila quedó cada plazo.
⏱ ≈ 10 min ☕ Descanso de 10 min
⏱ ≈ 6 min
Hasta aquí vimos vectores y matrices; ahora llegamos a la estructura que más vamos a usar en la práctica: los data frames. Antes de crear el primero, una pregunta: ¿qué tipo de datos puede guardar? Casi todo lo que hacemos en este curso es con datos estructurados, porque es lo que entienden los modelos. Pero la mayor parte de la información que existe en el mundo no viene así: un correo, una reclamación escrita a mano, la foto de un siniestro. Parte del trabajo de un analista es convertir eso en una tabla.
Y en el medio están los semiestructurados, como los archivos JSON, que ya tienen cierta forma. En R los vamos a poder guardar en listas, que vemos más adelante.
| Tipo de datos | ¿Cómo se organizan? | Ejemplos | ¿Cómo los trabajamos en R? |
|---|---|---|---|
| Estructurados | En filas y columnas, con campos definidos | Una tabla de pólizas, una hoja de Excel, una base de datos SQL | Matrices y data frames |
| Semiestructurados | Tienen cierta organización (etiquetas o jerarquías), pero no forman una tabla | Archivos JSON o XML, respuestas de una API | Listas |
| No estructurados | No tienen un formato predefinido | Texto libre, correos, imágenes, audio | Se transforman a datos estructurados antes de analizarlos |
⏱ ≈ 35 min (creación, columnas, operaciones y filtrado con índices)
Los dataframes son estructuras de datos bidimensionales en R, similares a una tabla de base de datos o una hoja de cálculo. La gran ventaja de los dataframes es que permiten almacenar columnas con diferentes tipos de datos (números, caracteres, factores, etc.), siempre y cuando cada columna contenga un único tipo de dato.
Algunas características clave de los data frames son:
Dimensiones: Los dataframes tienen filas y columnas, donde las columnas representan variables y las filas representan observaciones.
Tipos de datos: Cada columna debe contener un solo tipo de dato (numérico, texto, lógico, etc.), pero diferentes columnas pueden tener distintos tipos de datos.
Manipulación: Los dataframes permiten acceder, modificar, y operar sobre sus elementos de manera eficiente usando diversas funciones de R.
En esta etapa empezamos a trabajar con datos sintéticos, es decir, datos generados artificialmente que reproducen la estructura de datos reales sin contener información sensible.
Este tipo de datos es especialmente útil en el aprendizaje de R
porque permite practicar la construcción y manipulación de objetos sin
depender de bases de datos externas. Además, facilita la
reproducibilidad de los resultados mediante set.seed(), que
fija la semilla del generador aleatorio, y el uso de
sample(), que permite seleccionar observaciones o construir
subconjuntos de forma aleatoria a partir de un conjunto de datos.
En R, este enfoque es particularmente útil cuando se exploran estructuras como los dataframes, ya que permite simular variables y observaciones de manera controlada antes de trabajar con datos reales.
Para crear un dataframe se utiliza la función
data.frame().
A continuación se muestra un ejemplo de cómo crear un dataframe con datos aleatorios de estudiantes, incluyendo nombre, sexo, edad, estado de procedencia e ingresos.
# install.packages("babynames") # solo si aún no está instalada
# Cargamos la biblioteca de nombres
library(babynames)
# View(babynames)
is.vector(babynames)
## [1] FALSE
is.matrix(babynames)
## [1] FALSE
is.data.frame(babynames)
## [1] TRUE
# Fijamos una semilla para controlar nuestra generación de núms aleatorios
set.seed(123)
# Generamos 20 índices de observaciones
sample(1:100, 20)
## [1] 31 79 51 14 67 42 50 43 97 25 90 69 57 9 72 26 7 95 87 36
dim(babynames)[1]
## [1] 1924665
indices <- sample(1:length(babynames$name),20,replace=FALSE)
indices
## [1] 883281 669543 1325900 944672 613997 402313 554826 1498011 1798453
## [10] 401205 1717472 377049 90077 268360 738879 815826 53241 1732761
## [19] 368917 917545
length(indices)
## [1] 20
Nota: Una semilla aleatoria es un número que fija el estado del generador de números aleatorios para que los resultados de ciertos procesos puedan reproducirse exactamente en ejecuciones posteriores.
nombre <- babynames$name[indices]
length(babynames$name)
## [1] 1924665
length(nombre)
## [1] 20
sexo <- babynames$sex[indices]
length(sexo)
## [1] 20
edad <- sample(18:25,20,replace=TRUE)
estado <- c("Ciudad de México", "Querétaro", "Puebla", "Veracruz", "Nuevo León")
estado_procedencia <- sample(estado, 20, replace = TRUE)
estado_procedencia
## [1] "Veracruz" "Nuevo León" "Nuevo León" "Puebla"
## [5] "Ciudad de México" "Veracruz" "Ciudad de México" "Ciudad de México"
## [9] "Puebla" "Veracruz" "Ciudad de México" "Puebla"
## [13] "Nuevo León" "Puebla" "Querétaro" "Nuevo León"
## [17] "Nuevo León" "Puebla" "Querétaro" "Querétaro"
ingreso <- rnorm(20, mean= 8000, sd= 1000)
ingreso
## [1] 8053.004 8922.267 10050.085 7508.969 5690.831 9005.739 7290.799
## [8] 7311.991 9025.571 7715.227 6779.282 8181.303 7861.109 8005.764
## [15] 8385.280 7629.340 8644.377 7779.513 8331.782 9096.839
Armamos el dataframe con estos vectores:
df_estudiantes <- data.frame(Nombre = nombre,
Sexo = sexo,
Edad = edad,
Estado = estado_procedencia,
Ingreso = ingreso)
df_estudiantes
## Nombre Sexo Edad Estado Ingreso
## 1 Angela F 24 Veracruz 8053.004
## 2 Essie M 19 Nuevo León 8922.267
## 3 Allyn M 21 Nuevo León 10050.085
## 4 Tanita F 24 Puebla 7508.969
## 5 Sherriann F 25 Ciudad de México 5690.831
## 6 Raven M 21 Veracruz 9005.739
## 7 Glenys F 23 Ciudad de México 7290.799
## 8 Li F 23 Ciudad de México 7311.991
## 9 Miana F 20 Puebla 9025.571
## 10 Sewell M 25 Veracruz 7715.227
## 11 Wayland M 23 Ciudad de México 6779.282
## 12 Nadean F 23 Puebla 8181.303
## 13 Gregoria F 24 Nuevo León 7861.109
## 14 Sumiye F 24 Puebla 8005.764
## 15 Norvell M 25 Querétaro 8385.280
## 16 Shelle F 18 Nuevo León 7629.340
## 17 Caldonia F 23 Nuevo León 8644.377
## 18 Aivy F 19 Puebla 7779.513
## 19 Ethelmae F 18 Querétaro 8331.782
## 20 Leah M 19 Querétaro 9096.839
is.data.frame(df_estudiantes)
## [1] TRUE
# View(df_estudiantes)
Fíjense en lo que hicimos: primero creamos un vector por cada
variable, y luego los juntamos con data.frame(). Cada
vector se convirtió en una columna.
Una vez creado el data frame, puedes agregar más columnas como estatura, peso, etc.:
# Generamos un vector aleatorio de estaturas
estatura <- round(rnorm(20, 1.6, .15),1)
# Generamos un vector aleatorio de pesos
peso <- round(rnorm(20, 70, 20),2)
df_estudiantes1 <- data.frame(df_estudiantes,
Estatura = estatura,
Peso = peso)
df_estudiantes1
## Nombre Sexo Edad Estado Ingreso Estatura Peso
## 1 Angela F 24 Veracruz 8053.004 1.7 36.64
## 2 Essie M 19 Nuevo León 8922.267 1.6 62.40
## 3 Allyn M 21 Nuevo León 10050.085 1.8 88.38
## 4 Tanita F 24 Puebla 7508.969 1.7 58.49
## 5 Sherriann F 25 Ciudad de México 5690.831 1.7 82.16
## 6 Raven M 21 Veracruz 9005.739 1.6 37.64
## 7 Glenys F 23 Ciudad de México 7290.799 1.5 68.89
## 8 Li F 23 Ciudad de México 7311.991 1.8 80.39
## 9 Miana F 20 Puebla 9025.571 1.5 76.02
## 10 Sewell M 25 Veracruz 7715.227 1.9 72.11
## 11 Wayland M 23 Ciudad de México 6779.282 1.8 57.19
## 12 Nadean F 23 Puebla 8181.303 1.6 53.01
## 13 Gregoria F 24 Nuevo León 7861.109 1.4 49.52
## 14 Sumiye F 24 Puebla 8005.764 1.5 72.35
## 15 Norvell M 25 Querétaro 8385.280 1.6 51.05
## 16 Shelle F 18 Nuevo León 7629.340 1.6 60.19
## 17 Caldonia F 23 Nuevo León 8644.377 1.5 64.88
## 18 Aivy F 19 Puebla 7779.513 1.5 106.88
## 19 Ethelmae F 18 Querétaro 8331.782 1.6 56.96
## 20 Leah M 19 Querétaro 9096.839 1.5 74.71
carrera <- c("Actuaría", "Economía", "Matemáticas", "Administración", "Ingeniería Mecatrónica")
carrera_estudiantes <- sample(carrera, 20, replace = T, prob = c(.40,.15,.15,.20,.10))
carrera_estudiantes
## [1] "Administración" "Economía" "Actuaría"
## [4] "Administración" "Administración" "Economía"
## [7] "Ingeniería Mecatrónica" "Economía" "Matemáticas"
## [10] "Ingeniería Mecatrónica" "Administración" "Administración"
## [13] "Actuaría" "Actuaría" "Actuaría"
## [16] "Administración" "Economía" "Actuaría"
## [19] "Actuaría" "Actuaría"
df_estudiantes1$Carrera <- carrera_estudiantes
# Solo para añadir nuevas columnas en dataframes existentes
df_estudiantes1
## Nombre Sexo Edad Estado Ingreso Estatura Peso
## 1 Angela F 24 Veracruz 8053.004 1.7 36.64
## 2 Essie M 19 Nuevo León 8922.267 1.6 62.40
## 3 Allyn M 21 Nuevo León 10050.085 1.8 88.38
## 4 Tanita F 24 Puebla 7508.969 1.7 58.49
## 5 Sherriann F 25 Ciudad de México 5690.831 1.7 82.16
## 6 Raven M 21 Veracruz 9005.739 1.6 37.64
## 7 Glenys F 23 Ciudad de México 7290.799 1.5 68.89
## 8 Li F 23 Ciudad de México 7311.991 1.8 80.39
## 9 Miana F 20 Puebla 9025.571 1.5 76.02
## 10 Sewell M 25 Veracruz 7715.227 1.9 72.11
## 11 Wayland M 23 Ciudad de México 6779.282 1.8 57.19
## 12 Nadean F 23 Puebla 8181.303 1.6 53.01
## 13 Gregoria F 24 Nuevo León 7861.109 1.4 49.52
## 14 Sumiye F 24 Puebla 8005.764 1.5 72.35
## 15 Norvell M 25 Querétaro 8385.280 1.6 51.05
## 16 Shelle F 18 Nuevo León 7629.340 1.6 60.19
## 17 Caldonia F 23 Nuevo León 8644.377 1.5 64.88
## 18 Aivy F 19 Puebla 7779.513 1.5 106.88
## 19 Ethelmae F 18 Querétaro 8331.782 1.6 56.96
## 20 Leah M 19 Querétaro 9096.839 1.5 74.71
## Carrera
## 1 Administración
## 2 Economía
## 3 Actuaría
## 4 Administración
## 5 Administración
## 6 Economía
## 7 Ingeniería Mecatrónica
## 8 Economía
## 9 Matemáticas
## 10 Ingeniería Mecatrónica
## 11 Administración
## 12 Administración
## 13 Actuaría
## 14 Actuaría
## 15 Actuaría
## 16 Administración
## 17 Economía
## 18 Actuaría
## 19 Actuaría
## 20 Actuaría
La función attach() nos permite tener acceso a las
columnas del data frame para poder operar entre ellas. Mientras, que la
función detach() es útil para cerrar el data frame cuando
ya no queremos tener acceso a las columnas.
babynames$name[3]
## [1] "Emma"
# name[3]
attach(babynames)
# R agrega el dataframe al "search path" (ruta de búsqueda). Esto significa que las columnas del dataframe se vuelven accesibles como si fueran variables sueltas en el entorno de trabajo.
name[3]
## [1] "Emma"
detach(babynames)
attach(df_estudiantes1)
# Calculamos el IMC de los estudiantes
imc <- round(Peso / (Estatura ^2),2)
df_estudiantes1$IMC <- imc
# Podemos generar un histograma del IMC
hist(df_estudiantes1$IMC)
# ?hist
# Con esta exploración y a través de la inferencia estadística, podemos hacer pruebas de bondad de ajuste y determinar a qué distribución se ajustan los datos
# Cerramos el acceso al dataframe
detach(df_estudiantes1)
Lectura del histograma (con la semilla 123): una distribución unimodal, con la mayor concentración de valores entre ~20 y 35. Se observa una ligera asimetría positiva (cola hacia la derecha), debido a uno o pocos valores altos cercanos a 50 que actúan como posibles atípicos. La mayoría de los datos se sitúan en rangos compatibles con normopeso y sobrepeso, con algunos casos en obesidad.
attach() es práctico para clase, pero en proyectos más
grandes no se recomienda: las columnas se mezclan con otras variables
del entorno y puede ser difícil saber de dónde viene cada nombre. Por
eso, enseguida veremos alternativas.
Alternativamente, puedes operar directamente sobre las columnas sin usar attach() y detach():
# Generamos calificaciones para tres exámenes
set.seed(123)
calif1 <- round(runif(20, 5, 10),0)
calif2 <- round(runif(20, 5, 10),0)
calif3 <- round(runif(20, 5, 10),0)
# Añadimos las calificaciones a nuestro df
df_estudiantes1$Examen1 <- calif1
# Podemos lograr esto de una manera más rápida con índices
df_estudiantes1[ ,"Peso"]
## [1] 36.64 62.40 88.38 58.49 82.16 37.64 68.89 80.39 76.02 72.11
## [11] 57.19 53.01 49.52 72.35 51.05 60.19 64.88 106.88 56.96 74.71
df_estudiantes1[,c("Nombre","Edad")]
## Nombre Edad
## 1 Angela 24
## 2 Essie 19
## 3 Allyn 21
## 4 Tanita 24
## 5 Sherriann 25
## 6 Raven 21
## 7 Glenys 23
## 8 Li 23
## 9 Miana 20
## 10 Sewell 25
## 11 Wayland 23
## 12 Nadean 23
## 13 Gregoria 24
## 14 Sumiye 24
## 15 Norvell 25
## 16 Shelle 18
## 17 Caldonia 23
## 18 Aivy 19
## 19 Ethelmae 18
## 20 Leah 19
df_estudiantes1[,c("Examen2","Examen3")] <- cbind(calif2,calif3)
# View(df_estudiantes1)
# Otra alternativa
# df_estudiantes1 <- cbind(df_estudiantes1,
# "Examen1" = calif1,
# "Examen2" = calif2,
# "Examen3" = calif3)
promedio <- round((df_estudiantes1$Examen1 + df_estudiantes1$Examen2 + df_estudiantes1$Examen3) / 3, 2)
promedio
## [1] 7.00 8.00 7.33 8.67 8.00 6.67 7.33 8.00 6.67 7.33 8.33 8.00 8.33 7.67 6.33
## [16] 7.33 7.00 6.67 7.67 7.67
df_estudiantes1$Promedio <- promedio
df_estudiantes1
## Nombre Sexo Edad Estado Ingreso Estatura Peso
## 1 Angela F 24 Veracruz 8053.004 1.7 36.64
## 2 Essie M 19 Nuevo León 8922.267 1.6 62.40
## 3 Allyn M 21 Nuevo León 10050.085 1.8 88.38
## 4 Tanita F 24 Puebla 7508.969 1.7 58.49
## 5 Sherriann F 25 Ciudad de México 5690.831 1.7 82.16
## 6 Raven M 21 Veracruz 9005.739 1.6 37.64
## 7 Glenys F 23 Ciudad de México 7290.799 1.5 68.89
## 8 Li F 23 Ciudad de México 7311.991 1.8 80.39
## 9 Miana F 20 Puebla 9025.571 1.5 76.02
## 10 Sewell M 25 Veracruz 7715.227 1.9 72.11
## 11 Wayland M 23 Ciudad de México 6779.282 1.8 57.19
## 12 Nadean F 23 Puebla 8181.303 1.6 53.01
## 13 Gregoria F 24 Nuevo León 7861.109 1.4 49.52
## 14 Sumiye F 24 Puebla 8005.764 1.5 72.35
## 15 Norvell M 25 Querétaro 8385.280 1.6 51.05
## 16 Shelle F 18 Nuevo León 7629.340 1.6 60.19
## 17 Caldonia F 23 Nuevo León 8644.377 1.5 64.88
## 18 Aivy F 19 Puebla 7779.513 1.5 106.88
## 19 Ethelmae F 18 Querétaro 8331.782 1.6 56.96
## 20 Leah M 19 Querétaro 9096.839 1.5 74.71
## Carrera IMC Examen1 Examen2 Examen3 Promedio
## 1 Administración 12.68 6 9 6 7.00
## 2 Economía 24.37 9 8 7 8.00
## 3 Actuaría 27.28 7 8 7 7.33
## 4 Administración 20.24 9 10 7 8.67
## 5 Administración 28.43 10 8 6 8.00
## 6 Economía 14.70 5 9 6 6.67
## 7 Ingeniería Mecatrónica 30.62 8 8 6 7.33
## 8 Economía 24.81 9 8 7 8.00
## 9 Matemáticas 33.79 8 6 6 6.67
## 10 Ingeniería Mecatrónica 19.98 7 6 9 7.33
## 11 Administración 17.65 10 10 5 8.33
## 12 Administración 20.71 7 10 7 8.00
## 13 Actuaría 25.27 8 8 9 8.33
## 14 Actuaría 32.16 8 9 6 7.67
## 15 Actuaría 19.94 6 5 8 6.33
## 16 Administración 23.51 9 7 6 7.33
## 17 Economía 28.84 6 9 6 7.00
## 18 Actuaría 47.50 5 6 9 6.67
## 19 Actuaría 22.25 7 7 9 7.67
## 20 Actuaría 33.20 10 6 7 7.67
Igual que en los vectores y las matrices, podemos usar una condición lógica como índice. En un data frame, la condición va en la posición de las filas, antes de la coma:
# Estudiantes de más de 21 años (todas las columnas)
df_estudiantes1[df_estudiantes1$Edad > 21, ]
## Nombre Sexo Edad Estado Ingreso Estatura Peso
## 1 Angela F 24 Veracruz 8053.004 1.7 36.64
## 4 Tanita F 24 Puebla 7508.969 1.7 58.49
## 5 Sherriann F 25 Ciudad de México 5690.831 1.7 82.16
## 7 Glenys F 23 Ciudad de México 7290.799 1.5 68.89
## 8 Li F 23 Ciudad de México 7311.991 1.8 80.39
## 10 Sewell M 25 Veracruz 7715.227 1.9 72.11
## 11 Wayland M 23 Ciudad de México 6779.282 1.8 57.19
## 12 Nadean F 23 Puebla 8181.303 1.6 53.01
## 13 Gregoria F 24 Nuevo León 7861.109 1.4 49.52
## 14 Sumiye F 24 Puebla 8005.764 1.5 72.35
## 15 Norvell M 25 Querétaro 8385.280 1.6 51.05
## 17 Caldonia F 23 Nuevo León 8644.377 1.5 64.88
## Carrera IMC Examen1 Examen2 Examen3 Promedio
## 1 Administración 12.68 6 9 6 7.00
## 4 Administración 20.24 9 10 7 8.67
## 5 Administración 28.43 10 8 6 8.00
## 7 Ingeniería Mecatrónica 30.62 8 8 6 7.33
## 8 Economía 24.81 9 8 7 8.00
## 10 Ingeniería Mecatrónica 19.98 7 6 9 7.33
## 11 Administración 17.65 10 10 5 8.33
## 12 Administración 20.71 7 10 7 8.00
## 13 Actuaría 25.27 8 8 9 8.33
## 14 Actuaría 32.16 8 9 6 7.67
## 15 Actuaría 19.94 6 5 8 6.33
## 17 Economía 28.84 6 9 6 7.00
# Solo algunas columnas
df_estudiantes1[df_estudiantes1$Edad > 21, c("Nombre","Edad")]
## Nombre Edad
## 1 Angela 24
## 4 Tanita 24
## 5 Sherriann 25
## 7 Glenys 23
## 8 Li 23
## 10 Sewell 25
## 11 Wayland 23
## 12 Nadean 23
## 13 Gregoria 24
## 14 Sumiye 24
## 15 Norvell 25
## 17 Caldonia 23
# Solo los nombres (el resultado es un vector)
df_estudiantes1$Nombre[df_estudiantes1$Edad > 21]
## [1] "Angela" "Tanita" "Sherriann" "Glenys" "Li" "Sewell"
## [7] "Wayland" "Nadean" "Gregoria" "Sumiye" "Norvell" "Caldonia"
# ¿Cuál es el ingreso más alto y quién lo tiene?
max(df_estudiantes1$Ingreso)
## [1] 10050.08
df_estudiantes1$Nombre[df_estudiantes1$Ingreso == max(df_estudiantes1$Ingreso)]
## [1] "Allyn"
Antes de correrlo: ¿qué creen que devuelve
df_estudiantes1[df_estudiantes1$Edad > 21, ]? Piensen en
lo que aprendimos con vectores y matrices: la condición nos da un vector
de TRUE y FALSE, y los índices lógicos se quedan con las filas
verdaderas. Y no olviden la coma: sin ella, R se confunde entre filas y
columnas.
⏱ ≈ 0 min (solo si alguien pregunta)
Por si surge la pregunta: así se exportan los datos y los gráficos. Está comentado para no llenar de archivos la carpeta de todos.
Podemos exportar el dataframe a un archivo Excel usando el paquete
openxlsx, y también exportar los gráficos que generamos a
partir del dataframe.
En R es fundamental entender el concepto de directorio de trabajo, ya
que determina desde qué carpeta se leen y guardan los archivos por
defecto. getwd() devuelve el directorio de trabajo actual,
es decir, la carpeta en la que R está operando en ese momento, y
setwd() permite cambiarlo a una ubicación específica. Si
trabajamos dentro de un Proyecto de RStudio, el directorio de trabajo ya
es la carpeta del proyecto.
# install.packages("openxlsx")
# library(openxlsx) # Exporta dataframes como archivos de excel
# Exportar el dataframe a Excel (se guarda en el directorio de trabajo)
# openxlsx::write.xlsx(df_estudiantes1, "Base_estudiantes.xlsx")
# Consultar y cambiar el directorio de trabajo
# getwd()
# setwd("ruta/de/tu/carpeta")
# Exportar un gráfico como imagen
# png("graficos-promedio.png", width = 800, height = 600)
# hist(df_estudiantes1$Promedio)
# dev.off()
# dev.off() es el paso que confirma y cierra la exportación del gráfico al archivo.
# Sin dev.off(), el archivo puede quedar incompleto o no guardarse correctamente, porque R no "finaliza" la escritura del gráfico.
⏱ ≈ 57 min
Aquí empezamos a trabajar como analistas. Cada verbo de dplyr hace una sola cosa, y la potencia está en combinarlos. Si recuerdan sus nombres en inglés, ya tienen la mitad del trabajo: seleccionar, filtrar, ordenar, crear, contar, resumir y agrupar.
La biblioteca dplyr es una de las más populares y
poderosas en R para la manipulación de datos. Forma parte del
tidyverse, un conjunto de paquetes diseñados para facilitar
el análisis de datos. Proporciona una gramática coherente para trabajar
con data frames, permitiendo realizar operaciones complejas de manera
concisa y legible, facilitando su aplicación.
# install.packages(c("dplyr","readxl")) # solo si aún no están instaladas
library(dplyr)
## Warning: package 'dplyr' was built under R version 4.5.3
##
## Adjuntando el paquete: 'dplyr'
## The following objects are masked from 'package:stats':
##
## filter, lag
## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, union
library(readxl)
Importamos la base de datos de dulces M&M
getwd() # el archivo "DulcesM&M.xlsx" debe estar en esta carpeta
## [1] "C:/Users/sofip/Desktop/Curso R/NEWE-R"
DulcesM_M <- read_excel("DulcesM&M.xlsx")
is.data.frame(DulcesM_M)
## [1] TRUE
# View(DulcesM_M)
# head devuelve las primeras filas
head(DulcesM_M)
## # A tibble: 6 × 2
## Color Peso
## <chr> <dbl>
## 1 Rojo 0.751
## 2 Naranja 0.735
## 3 Amarillo 0.883
## 4 Café 0.696
## 5 Azul 0.881
## 6 Verde 0.925
Si read_excel() no encuentra el archivo, casi siempre es
porque getwd() no es la carpeta donde lo guardaron. Por eso
trabajamos dentro de un Proyecto de RStudio.
Selecciona columnas específicas de un data frame. Es útil cuando queremos trabajar con una parte específica de los datos, por ejemplo, seleccionar solo la columna de pesos de los dulces.
variable_peso <- select(DulcesM_M,2) # Genera dataframe
variable_peso
## # A tibble: 100 × 1
## Peso
## <dbl>
## 1 0.751
## 2 0.735
## 3 0.883
## 4 0.696
## 5 0.881
## 6 0.925
## 7 0.841
## 8 0.895
## 9 0.769
## 10 0.876
## # ℹ 90 more rows
variable_peso2 <- DulcesM_M$Peso # Genera vector
variable_peso2
## [1] 0.751 0.735 0.883 0.696 0.881 0.925 0.841 0.895 0.769 0.876 0.863 0.914
## [13] 0.856 0.865 0.859 0.855 0.775 0.881 0.799 0.864 0.784 0.806 0.854 0.865
## [25] 0.966 0.852 0.824 0.840 0.810 0.865 0.859 0.866 0.858 0.868 0.858 1.015
## [37] 0.857 0.859 0.848 0.859 0.818 0.876 0.942 0.838 0.851 0.982 0.868 0.809
## [49] 0.873 0.863 0.803 0.865 0.809 0.888 0.932 0.848 0.890 0.925 0.842 0.940
## [61] 0.878 0.793 0.832 0.833 0.905 0.977 0.807 0.845 0.850 0.852 0.852 0.830
## [73] 0.778 0.778 0.856 0.814 0.814 0.842 0.791 0.791 0.778 0.810 0.810 0.786
## [85] 0.881 0.881 0.853 0.818 0.864 0.864 0.873 0.825 0.880 0.855 0.882 0.942
## [97] 0.931 0.825 0.869 0.912
is.data.frame(variable_peso2)
## [1] FALSE
is.vector(variable_peso2)
## [1] TRUE
is.data.frame(variable_peso)
## [1] TRUE
También permite excluir columnas utilizando el signo -, lo cual es útil cuando queremos eliminar variables específicas sin necesidad de listar todas las columnas restantes.
Podemos excluir columnas por etiqueta o por posición.
datos_sin_peso <- select(DulcesM_M, -Peso) # Elimina la columna Peso
datos_sin_peso
## # A tibble: 100 × 1
## Color
## <chr>
## 1 Rojo
## 2 Naranja
## 3 Amarillo
## 4 Café
## 5 Azul
## 6 Verde
## 7 Rojo
## 8 Naranja
## 9 Amarillo
## 10 Café
## # ℹ 90 more rows
datos_sin_primera <- select(DulcesM_M, -1) # Elimina la primera columna
datos_sin_primera
## # A tibble: 100 × 1
## Peso
## <dbl>
## 1 0.751
## 2 0.735
## 3 0.883
## 4 0.696
## 5 0.881
## 6 0.925
## 7 0.841
## 8 0.895
## 9 0.769
## 10 0.876
## # ℹ 90 more rows
Antes de correr el siguiente chunk, piensen: ¿qué columnas creen que
van a salir con starts_with("Exam")? ¿Y con
where(is.numeric)?
Cuando el data frame tiene muchas columnas, select()
cuenta con funciones auxiliares para elegirlas. Como los dulces solo
tienen dos columnas, usaremos nuestro df_estudiantes1:
names(df_estudiantes1)
## [1] "Nombre" "Sexo" "Edad" "Estado" "Ingreso" "Estatura"
## [7] "Peso" "Carrera" "IMC" "Examen1" "Examen2" "Examen3"
## [13] "Promedio"
# Por nombre
head(select(df_estudiantes1, Nombre, Edad), 3)
## Nombre Edad
## 1 Angela 24
## 2 Essie 19
## 3 Allyn 21
# Promedio primero y luego todas las demás
head(select(df_estudiantes1, Promedio, everything()), 3)
## Promedio Nombre Sexo Edad Estado Ingreso Estatura Peso Carrera
## 1 7.00 Angela F 24 Veracruz 8053.004 1.7 36.64 Administración
## 2 8.00 Essie M 19 Nuevo León 8922.267 1.6 62.40 Economía
## 3 7.33 Allyn M 21 Nuevo León 10050.085 1.8 88.38 Actuaría
## IMC Examen1 Examen2 Examen3
## 1 12.68 6 9 6
## 2 24.37 9 8 7
## 3 27.28 7 8 7
# Columnas que empiezan con "Exam"
head(select(df_estudiantes1, starts_with("Exam")), 3)
## Examen1 Examen2 Examen3
## 1 6 9 6
## 2 9 8 7
## 3 7 8 7
# Columnas que terminan con "o"
head(select(df_estudiantes1, ends_with("o")), 3)
## Sexo Estado Ingreso Peso Promedio
## 1 F Veracruz 8053.004 36.64 7.00
## 2 M Nuevo León 8922.267 62.40 8.00
## 3 M Nuevo León 10050.085 88.38 7.33
# Columnas que contienen "re"
head(select(df_estudiantes1, contains("re")), 3)
## Nombre Ingreso Carrera
## 1 Angela 8053.004 Administración
## 2 Essie 8922.267 Economía
## 3 Allyn 10050.085 Actuaría
# Solo las columnas numéricas
head(select(df_estudiantes1, where(is.numeric)), 3)
## Edad Ingreso Estatura Peso IMC Examen1 Examen2 Examen3 Promedio
## 1 24 8053.004 1.7 36.64 12.68 6 9 6 7.00
## 2 19 8922.267 1.6 62.40 24.37 9 8 7 8.00
## 3 21 10050.085 1.8 88.38 27.28 7 8 7 7.33
Fíjense en la última: se escribe where(is.numeric), sin
paréntesis en is.numeric, porque le pasamos la función, no
su resultado.
Y un detalle para tener en cuenta: algunas bibliotecas, como MASS,
también tienen una función llamada select. Si cargamos MASS
después de dplyr, R usa la de MASS. Para evitar confusiones se puede
escribir dplyr::select(), que le dice a R exactamente de
qué biblioteca queremos la función.
Filtra filas según una condición lógica. Esta función es clave cuando queremos segmentar los datos. Por ejemplo, seleccionar solo los dulces rojos o aquellos que cumplen cierto criterio específico.
# Filtramos los dulces de color rojo
dulces_rojos <- filter(DulcesM_M, Color == "Rojo")
dulces_rojos
## # A tibble: 13 × 2
## Color Peso
## <chr> <dbl>
## 1 Rojo 0.751
## 2 Rojo 0.841
## 3 Rojo 0.856
## 4 Rojo 0.799
## 5 Rojo 0.966
## 6 Rojo 0.859
## 7 Rojo 0.857
## 8 Rojo 0.942
## 9 Rojo 0.873
## 10 Rojo 0.809
## 11 Rojo 0.89
## 12 Rojo 0.878
## 13 Rojo 0.905
# Filtramos dulces rojos con peso mayor a 0.9 gramos
dulces_rojos_pesados <- filter(DulcesM_M, Color == "Rojo",Peso > 0.9)
dulces_rojos_pesados
## # A tibble: 3 × 2
## Color Peso
## <chr> <dbl>
## 1 Rojo 0.966
## 2 Rojo 0.942
## 3 Rojo 0.905
También podemos filtrar por texto parcial con
grepl(), que devuelve TRUE cuando encuentra el
patrón dentro del texto, o por varios valores a la vez con
%in%:
# Carreras que empiezan con "A"
carreras_A <- filter(df_estudiantes1, grepl("^A", Carrera))
head(carreras_A[, c("Nombre","Carrera")])
## Nombre Carrera
## 1 Angela Administración
## 2 Allyn Actuaría
## 3 Tanita Administración
## 4 Sherriann Administración
## 5 Wayland Administración
## 6 Nadean Administración
# Carreras que sean Actuaría o Economía
actuaria_economia <- filter(df_estudiantes1, Carrera %in% c("Actuaría","Economía"))
head(actuaria_economia[, c("Nombre","Carrera")])
## Nombre Carrera
## 1 Essie Economía
## 2 Allyn Actuaría
## 3 Raven Economía
## 4 Li Economía
## 5 Gregoria Actuaría
## 6 Sumiye Actuaría
grepl() busca un patrón de texto. El símbolo
^ significa “al inicio”; si ponemos $ al
final, significa “al final”. Y ojo: distingue mayúsculas de minúsculas.
%in% nos sirve cuando queremos que el valor sea cualquiera
de una lista.
Ordena las filas del data frame. Sirve para organizar los datos de forma ascendente o descendente, lo cual es muy útil para informes o análisis.
# Ordenar por color
dulces_ord_color <- arrange(DulcesM_M, Color)
dulces_ord_color
## # A tibble: 100 × 2
## Color Peso
## <chr> <dbl>
## 1 Amarillo 0.883
## 2 Amarillo 0.769
## 3 Amarillo 0.859
## 4 Amarillo 0.784
## 5 Amarillo 0.824
## 6 Amarillo 0.858
## 7 Amarillo 0.848
## 8 Amarillo 0.851
## 9 Azul 0.881
## 10 Azul 0.863
## # ℹ 90 more rows
# Ordenar por peso de menor a mayor
dulces_ord_peso1 <- arrange(DulcesM_M, Peso)
dulces_ord_peso1
## # A tibble: 100 × 2
## Color Peso
## <chr> <dbl>
## 1 Café 0.696
## 2 Naranja 0.735
## 3 Rojo 0.751
## 4 Amarillo 0.769
## 5 Azul 0.775
## 6 Azul 0.778
## 7 Verde 0.778
## 8 Naranja 0.778
## 9 Amarillo 0.784
## 10 Naranja 0.786
## # ℹ 90 more rows
# Ordenar por peso de mayor a menor
dulces_ord_peso2 <- arrange(DulcesM_M, desc(Peso))
dulces_ord_peso2
## # A tibble: 100 × 2
## Color Peso
## <chr> <dbl>
## 1 Verde 1.01
## 2 Café 0.982
## 3 Naranja 0.977
## 4 Rojo 0.966
## 5 Rojo 0.942
## 6 Azul 0.942
## 7 Verde 0.94
## 8 Azul 0.932
## 9 Naranja 0.931
## 10 Verde 0.925
## # ℹ 90 more rows
mutate() crea nuevas columnas o transforma las ya
existentes. Permite modificar el data frame añadiendo nuevas columnas
basadas en cálculos o transformaciones.
Para crear una categoría a partir de una condición usamos
ifelse(condición, valor si es TRUE, valor si es FALSE):
dulces_modificado <- mutate(DulcesM_M,
Peso_mg = Peso * 1000,
Categoria = ifelse(Peso > 0.9, "Pesado", "Ligero"))
head(dulces_modificado)
## # A tibble: 6 × 4
## Color Peso Peso_mg Categoria
## <chr> <dbl> <dbl> <chr>
## 1 Rojo 0.751 751 Ligero
## 2 Naranja 0.735 735 Ligero
## 3 Amarillo 0.883 883 Ligero
## 4 Café 0.696 696 Ligero
## 5 Azul 0.881 881 Ligero
## 6 Verde 0.925 925 Pesado
En R base existe una función equivalente, transform(),
que hace lo mismo sin necesidad de cargar ninguna biblioteca:
dulces_transform <- transform(DulcesM_M,
Peso_mg = Peso * 1000,
Categoria = ifelse(Peso > 0.9, "Pesado", "Ligero"))
head(dulces_transform)
## Color Peso Peso_mg Categoria
## 1 Rojo 0.751 751 Ligero
## 2 Naranja 0.735 735 Ligero
## 3 Amarillo 0.883 883 Ligero
## 4 Café 0.696 696 Ligero
## 5 Azul 0.881 881 Ligero
## 6 Verde 0.925 925 Pesado
La diferencia principal: mutate() puede usar una columna
recién creada dentro de la misma instrucción, y
transform() no.
# mutate() sí puede usar Peso_mg, que acaba de crear
head(mutate(DulcesM_M,
Peso_mg = Peso * 1000,
Peso_kg = Peso_mg / 1000000))
## # A tibble: 6 × 4
## Color Peso Peso_mg Peso_kg
## <chr> <dbl> <dbl> <dbl>
## 1 Rojo 0.751 751 0.000751
## 2 Naranja 0.735 735 0.000735
## 3 Amarillo 0.883 883 0.000883
## 4 Café 0.696 696 0.000696
## 5 Azul 0.881 881 0.000881
## 6 Verde 0.925 925 0.000925
# transform() marcaría un error: no encuentra Peso_mg
# transform(DulcesM_M,
# Peso_mg = Peso * 1000,
# Peso_kg = Peso_mg / 1000000)
ifelse es lo único condicional que veremos en el curso:
una condición y dos resultados, en un solo renglón.
Entre mutate() y transform(), la regla
práctica: mutate() es más flexible, porque deja usar
columnas nuevas dentro de la misma instrucción y también funciona con
datos agrupados. transform() es útil cuando queremos algo
rápido y sin cargar bibliotecas. En este curso usaremos sobre todo
mutate().
Cambia el nombre de las columnas. El orden es nuevo = viejo.
dulces_renombrado <- rename(DulcesM_M, Gramos = Peso)
head(dulces_renombrado)
## # A tibble: 6 × 2
## Color Gramos
## <chr> <dbl>
## 1 Rojo 0.751
## 2 Naranja 0.735
## 3 Amarillo 0.883
## 4 Café 0.696
## 5 Azul 0.881
## 6 Verde 0.925
Cuenta las ocurrencias por grupo. Ideal para ver frecuencias de alguna variable categórica, como los colores en el dataset.
# Contamos la cantidad de dulces que hay de cada color
conteo_dulces <- count(DulcesM_M, Color)
conteo_dulces
## # A tibble: 6 × 2
## Color n
## <chr> <int>
## 1 Amarillo 8
## 2 Azul 27
## 3 Café 8
## 4 Naranja 25
## 5 Rojo 13
## 6 Verde 19
is.data.frame(conteo_dulces)
## [1] TRUE
table(DulcesM_M$Color)
##
## Amarillo Azul Café Naranja Rojo Verde
## 8 27 8 25 13 19
is.table(table(DulcesM_M$Color))
## [1] TRUE
# table es una estructura diseñada específicamente para almacenar frecuencias de valores categóricos y suele convertirse fácilmente a vector, matriz o dataframe
# con as.vector(), as.matrix(), as.data.frame()
as.matrix(table(DulcesM_M$Color))
## [,1]
## Amarillo 8
## Azul 27
## Café 8
## Naranja 25
## Rojo 13
## Verde 19
Genera resúmenes estadísticos. Permite calcular estadísticas como medias, varianzas o sumas, etc. facilitando el análisis de datos.
resumen <- summarise(DulcesM_M,
Promedio = mean(Peso),
Varianza = var(Peso),
Desviación = sd(Peso),
Mediana = median(Peso),
Total = n())
resumen
## # A tibble: 1 × 5
## Promedio Varianza Desviación Mediana Total
## <dbl> <dbl> <dbl> <dbl> <int>
## 1 0.853 0.00273 0.0523 0.856 100
Agrupa el data frame por una o más variables. Cuando queremos realizar análisis estadístico por grupos, como promedio de peso por color.
grupo_colores <- group_by(DulcesM_M, Color)
resumen_color <- summarise(grupo_colores,
Promedio = mean(Peso),
Varianza = var(Peso),
Desviación = sd(Peso),
Mediana = median(Peso),
Total = n())
resumen_color
## # A tibble: 6 × 6
## Color Promedio Varianza Desviación Mediana Total
## <chr> <dbl> <dbl> <dbl> <dbl> <int>
## 1 Amarillo 0.834 0.00156 0.0395 0.849 8
## 2 Azul 0.844 0.00183 0.0428 0.842 27
## 3 Café 0.848 0.00632 0.0795 0.857 8
## 4 Naranja 0.858 0.00251 0.0501 0.863 25
## 5 Rojo 0.864 0.00332 0.0576 0.859 13
## 6 Verde 0.864 0.00324 0.0570 0.865 19
%>%El operador %>% facilita la escritura fluida y clara
de código en R, permitiendo encadenar operaciones sin necesidad de crear
variables intermedias. Atajo de teclado:
Ctrl + Shift + M.
DulcesM_M %>%
group_by(Color) %>%
summarise(Promedio = mean(Peso),
Varianza = var(Peso),
Desviación = sd(Peso),
Mediana = median(Peso),
Total = n()) %>%
arrange(desc(Total)) %>%
print()
## # A tibble: 6 × 6
## Color Promedio Varianza Desviación Mediana Total
## <chr> <dbl> <dbl> <dbl> <dbl> <int>
## 1 Azul 0.844 0.00183 0.0428 0.842 27
## 2 Naranja 0.858 0.00251 0.0501 0.863 25
## 3 Verde 0.864 0.00324 0.0570 0.865 19
## 4 Rojo 0.864 0.00332 0.0576 0.859 13
## 5 Amarillo 0.834 0.00156 0.0395 0.849 8
## 6 Café 0.848 0.00632 0.0795 0.857 8
Lean el pipe como “y luego”: tomo los dulces, y luego agrupo por color, y luego resumo, y luego ordeno.
Un dato de dónde viene: %>% es del paquete magrittr,
y dplyr lo trae incluido, por eso funciona sin cargar magrittr aparte.
Desde R 4.1 existe además un pipe propio del lenguaje,
|>, que hace casi lo mismo. En
Tools > Global Options > Code pueden configurar cuál
inserta el atajo Ctrl + Shift + M. En el curso usaremos
%>%.
.groupsCuando agrupamos por más de una variable,
summarise() elimina solo el último nivel de agrupación, y
el resultado queda agrupado por las demás. R lo avisa con un
mensaje.
Antes de correr el chunk: ¿creen que resumen_a queda
agrupado o no? Fíjense también en el mensaje que aparece al
ejecutarlo.
resumen_a <- df_estudiantes1 %>%
group_by(Carrera, Sexo) %>%
summarise(Total = n())
## `summarise()` has regrouped the output.
## ℹ Summaries were computed grouped by Carrera and Sexo.
## ℹ Output is grouped by Carrera.
## ℹ Use `summarise(.groups = "drop_last")` to silence this message.
## ℹ Use `summarise(.by = c(Carrera, Sexo))` for per-operation grouping
## (`?dplyr::dplyr_by`) instead.
group_vars(resumen_a) # el resultado sigue agrupado por Carrera
## [1] "Carrera"
resumen_b <- df_estudiantes1 %>%
group_by(Carrera, Sexo) %>%
summarise(Total = n(), .groups = "drop")
group_vars(resumen_b) # character(0): sin agrupación
## character(0)
¿Por qué importa? Porque las operaciones siguientes se calculan por grupo, aunque no nos demos cuenta:
# Todavía agrupado por Carrera: la proporción se calcula dentro de cada carrera
resumen_a %>% mutate(Proporcion = Total / sum(Total))
## # A tibble: 9 × 4
## # Groups: Carrera [5]
## Carrera Sexo Total Proporcion
## <chr> <chr> <int> <dbl>
## 1 Actuaría F 4 0.571
## 2 Actuaría M 3 0.429
## 3 Administración F 5 0.833
## 4 Administración M 1 0.167
## 5 Economía F 2 0.5
## 6 Economía M 2 0.5
## 7 Ingeniería Mecatrónica F 1 0.5
## 8 Ingeniería Mecatrónica M 1 0.5
## 9 Matemáticas F 1 1
# Sin grupos: la proporción se calcula sobre el total de estudiantes
resumen_b %>% mutate(Proporcion = Total / sum(Total))
## # A tibble: 9 × 4
## Carrera Sexo Total Proporcion
## <chr> <chr> <int> <dbl>
## 1 Actuaría F 4 0.2
## 2 Actuaría M 3 0.15
## 3 Administración F 5 0.25
## 4 Administración M 1 0.05
## 5 Economía F 2 0.1
## 6 Economía M 2 0.1
## 7 Ingeniería Mecatrónica F 1 0.05
## 8 Ingeniería Mecatrónica M 1 0.05
## 9 Matemáticas F 1 0.05
Este detalle da errores muy difíciles de detectar. Con una sola
variable de agrupación no pasa nada, summarise() ya
devuelve el resultado sin agrupar. Con dos o más, lo que sigue puede
calcularse por grupo sin que nos demos cuenta.
Por eso es buena práctica escribir .groups = "drop" al
final del summarise(). La alternativa es llamar a
ungroup() después. Si quisieran conservar la agrupación,
existe .groups = "keep", pero conviene hacerlo de forma
deliberada.
⏱ ≈ 3 min
Y bueno, esta clase la empezamos con matrices y terminamos trabajando con datos de verdad. Ya saben crear matrices, operar con ellas y resolver un sistema de ecuaciones; ya saben qué es un data frame, cómo crearlo, agregarle columnas y sacar justo las filas que necesitan; y con dplyr empezamos a trabajar como analistas: seleccionar, filtrar, ordenar, crear variables, agrupar y resumir, todo encadenado con el pipe. Fue bastante, y es normal que al principio los verbos se confundan; con la práctica salen solos. En la próxima clase vamos a ponerle forma a estos datos con gráficos, vamos a ver las listas y, con todo lo que ya aprendimos de matrices, vamos a construir nuestro primer modelo: la regresión lineal.