Objetos de datos

⏱ ≈ 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:

  • I. Vectores
  • II. Matrices
  • III. Data frames
  • IV. Listas

Continuamos con nuestro estudio de las matrices.


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.

Creación de matrices

Para crear una matriz se utiliza la función matrix() cuyos argumentos son:

  1. data: Datos a incluir en la matriz
  2. nrow: Número de filas
  3. ncol: Número de columnas
  4. byrow: Llenado por filas o columnas TRUE o FALSE respectivamente. Por defecto es FALSE.
  5. dimnames: Nombres de las filas y columnas.
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


Matrices con 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.


Acceso a elementos por índices

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



Operaciones con matrices

⏱ ≈ 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.


Suma y resta de matrices

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


Producto de matrices

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.


Transpuesta, determinante e inversa

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.


Sistemas de ecuaciones lineales

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.


Funciones aplicadas a matrices

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

Actividad 1

⏱ ≈ 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:

  • Producto A: Tasa de interés anual del 1.5%, 2% y 2.5% para los años 1, 3 y 5 respectivamente.
  • Producto B: Tasa de interés anual fija del 3%, 3.5% y 4% para los años 1, 3 y 5 respectivamente.

Plazos de Inversión:

  • 1 año, 3 años y 5 años.

Objetivo:

  1. Calcular el valor futuro de una inversión inicial de $10,000 para ambos productos en cada plazo.
# 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.



Actividad 2

⏱ ≈ 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:

  • Modelo A $270,000
  • Modelo B $350,000
  • Modelo C $450,000

Tasas de interés anual nominal (capitalizables mensualmente) por modelo:

  • Modelo A 19.5%
  • Modelo B 6.5%
  • Modelo C 5.5%

Plazos de financiamiento:

  • 36 meses
  • 48 meses
  • 60 meses
  • 72 meses

Objetivos:

  1. Utiliza la fórmula de anualidades para calcular los pagos mensuales.
  2. Crea una matriz que almacene los pagos mensuales calculados para cada modelo de auto y cada plazo.
  3. Grafica los distintos planes de financiamiento para los modelos.
Modelo A Modelo B Modelo C
36 m
48 m
60 m
72 m

Construcción de las matrices

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.


Pagos mensuales

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 periodos

En 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:

Gráfico de líneas con 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.


Gráfico de barras con 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, en barplot() 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.

Matrices en acción

⏱ ≈ 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:

  1. ¿Cuál es el pago mensual del Modelo B para un plazo de 48 meses?
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
  1. ¿Cuáles son los pagos mensuales para todos los modelos cuando el plazo es de 60 y 72 meses?
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
  1. ¿Para qué modelo y en qué plazo se registra el pago mensual más bajo?
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


Datos estructurados y no estructurados

⏱ ≈ 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

Dataframes

⏱ ≈ 35 min (creación, columnas, operaciones y filtrado con índices)

¿Qué es un dataframe?

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:

  1. Dimensiones: Los dataframes tienen filas y columnas, donde las columnas representan variables y las filas representan observaciones.

  2. 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.

  3. Manipulación: Los dataframes permiten acceder, modificar, y operar sobre sus elementos de manera eficiente usando diversas funciones de R.

Mi primer dataframe

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.


Agregar nuevas columnas

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


Operaciones entre columnas

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


Filtrar filas con índices lógicos

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.


Exportar y directorio de trabajo

⏱ ≈ 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. 



Biblioteca dplyr

⏱ ≈ 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.

Carga de bibliotecas e importación de datos

# 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.


Principales funciones de dplyr

select()

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.


filter()

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.


arrange()

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() y transform()

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().


rename()

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


count()

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


summarise()

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


group_by()

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 pipe %>%

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 %>%.


Agrupar con dos variables: .groups

Cuando 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.


Conclusiones de la clase

⏱ ≈ 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.