Tutorial R: Estructuras de datos

Vectores: creación y manipulación básica

Los vectores son la estructura de datos más fundamental en R. A diferencia de otros lenguajes de programación, en R prácticamente todo es un vector, incluso los valores individuales. Un vector es una colección ordenada de elementos del mismo tipo (numéricos, caracteres, lógicos, etc.).

Creación de vectores

Existen varias formas de crear vectores en R. La más común es mediante la función c() (de "combinar" o "concatenar"):

# Vector numérico
edades <- c(25, 30, 22, 28, 33)

# Vector de caracteres
nombres <- c("Ana", "Carlos", "Elena", "David", "Beatriz")

# Vector lógico
aprobados <- c(TRUE, FALSE, TRUE, TRUE, FALSE)

También podemos crear vectores con secuencias utilizando diferentes métodos:

# Secuencia con el operador :
secuencia1 <- 1:10  # Crea vector del 1 al 10

# Secuencia con la función seq()
secuencia2 <- seq(from = 0, to = 1, by = 0.1)  # De 0 a 1 en incrementos de 0.1
secuencia3 <- seq(from = 0, to = 10, length.out = 5)  # 5 valores equidistantes entre 0 y 10

Para crear vectores con valores repetidos, podemos usar la función rep():

# Repetir un valor
rep_simple <- rep(5, times = 3)  # Resultado: 5 5 5

# Repetir un vector completo
rep_vector <- rep(c(1, 2), times = 3)  # Resultado: 1 2 1 2 1 2

# Repetir cada elemento
rep_each <- rep(c(1, 2), each = 3)  # Resultado: 1 1 1 2 2 2

Verificación y propiedades de vectores

Para trabajar eficientemente con vectores, es útil conocer algunas funciones que nos permiten examinar sus propiedades:

numeros <- c(10, 20, 30, 40, 50)

# Longitud del vector
length(numeros)  # Resultado: 5

# Tipo de datos
typeof(numeros)  # Resultado: "double"
class(numeros)   # Resultado: "numeric"

# Verificar si es un vector
is.vector(numeros)  # Resultado: TRUE

Acceso a elementos

Podemos acceder a elementos individuales o subconjuntos de un vector mediante indexación. En R, los índices comienzan en 1 (a diferencia de muchos otros lenguajes que comienzan en 0):

frutas <- c("manzana", "naranja", "plátano", "fresa", "kiwi")

# Acceder a un elemento individual
frutas[3]  # Resultado: "plátano"

# Acceder a múltiples elementos
frutas[c(1, 3, 5)]  # Resultado: "manzana" "plátano" "kiwi"

# Acceder a un rango
frutas[2:4]  # Resultado: "naranja" "plátano" "fresa"

También podemos usar indexación negativa para excluir elementos:

# Excluir el segundo elemento
frutas[-2]  # Resultado: "manzana" "plátano" "fresa" "kiwi"

# Excluir varios elementos
frutas[-c(1, 3)]  # Resultado: "naranja" "fresa" "kiwi"

La indexación lógica es otra forma poderosa de seleccionar elementos:

numeros <- c(10, 25, 8, 15, 32)

# Seleccionar elementos mayores que 15
numeros[numeros > 15]  # Resultado: 25 32

# Seleccionar elementos pares
numeros[numeros %% 2 == 0]  # Resultado: 10 8 32

Modificación de vectores

Podemos modificar elementos específicos de un vector asignando nuevos valores:

colores <- c("rojo", "verde", "azul", "amarillo")

# Modificar un elemento
colores[2] <- "morado"
print(colores)  # Resultado: "rojo" "morado" "azul" "amarillo"

# Modificar múltiples elementos
colores[c(1, 3)] <- c("negro", "blanco")
print(colores)  # Resultado: "negro" "morado" "blanco" "amarillo"

También podemos añadir elementos a un vector:

numeros <- c(1, 2, 3)

# Añadir elementos al final
numeros <- c(numeros, 4, 5)
print(numeros)  # Resultado: 1 2 3 4 5

# Añadir elementos al principio
numeros <- c(0, numeros)
print(numeros)  # Resultado: 0 1 2 3 4 5

Operaciones con vectores

Una de las características más potentes de R es la vectorización, que permite realizar operaciones sobre todos los elementos de un vector sin necesidad de bucles explícitos:

# Operaciones aritméticas
x <- c(1, 2, 3, 4, 5)
y <- c(10, 20, 30, 40, 50)

suma <- x + y  # Resultado: 11 22 33 44 55
producto <- x * y  # Resultado: 10 40 90 160 250
potencia <- x^2  # Resultado: 1 4 9 16 25

# Operaciones con un escalar
doble <- x * 2  # Resultado: 2 4 6 8 10
incremento <- x + 10  # Resultado: 11 12 13 14 15

Cuando realizamos operaciones entre vectores de diferente longitud, R aplica la regla de reciclaje, repitiendo el vector más corto:

a <- c(1, 2, 3, 4)
b <- c(10, 20)

# b se recicla como c(10, 20, 10, 20)
resultado <- a * b  # Resultado: 10 40 30 80

Funciones útiles para vectores

R proporciona numerosas funciones para trabajar con vectores:

valores <- c(15, 8, 22, 4, 17, 9, 13)

# Funciones estadísticas básicas
sum(valores)  # Suma: 88
mean(valores)  # Media: 12.57...
median(valores)  # Mediana: 13
min(valores)  # Mínimo: 4
max(valores)  # Máximo: 22
range(valores)  # Rango: 4 22
sd(valores)  # Desviación estándar: 6.21...

# Ordenación
sort(valores)  # Ascendente: 4 8 9 13 15 17 22
sort(valores, decreasing = TRUE)  # Descendente: 22 17 15 13 9 8 4

# Posiciones
which.min(valores)  # Posición del mínimo: 4
which.max(valores)  # Posición del máximo: 3

Vectores con nombres

Podemos asignar nombres a los elementos de un vector, lo que facilita su acceso:

# Crear un vector con nombres
calificaciones <- c(Ana = 8.5, Carlos = 7.2, Elena = 9.3, David = 6.8)
print(calificaciones)

# Acceder por nombre
calificaciones["Elena"]  # Resultado: 9.3

# Asignar nombres a un vector existente
edades <- c(25, 30, 22, 28)
names(edades) <- c("Ana", "Carlos", "Elena", "David")
print(edades)

# Obtener los nombres
nombres_estudiantes <- names(edades)
print(nombres_estudiantes)

Valores especiales en vectores

R tiene algunos valores especiales que pueden aparecer en vectores:

# NA (Not Available) - representa datos faltantes
datos <- c(10, NA, 20, NA, 30)
is.na(datos)  # Resultado: FALSE TRUE FALSE TRUE FALSE

# Filtrar valores NA
datos_completos <- datos[!is.na(datos)]  # Resultado: 10 20 30

# NaN (Not a Number) - resultado de operaciones matemáticas indefinidas
resultado <- 0/0  # Resultado: NaN
is.nan(resultado)  # Resultado: TRUE

# Infinito
inf_positivo <- 1/0  # Resultado: Inf
inf_negativo <- -1/0  # Resultado: -Inf

Coerción de tipos

Cuando mezclamos diferentes tipos de datos en un vector, R realiza una coerción automática siguiendo esta jerarquía: lógico → entero → numérico → carácter:

# Mezcla de tipos
mixto <- c(TRUE, 10, 15.5, "hola")
print(mixto)  # Resultado: "TRUE" "10" "15.5" "hola" (todo convertido a caracteres)

# Conversión explícita
numeros_texto <- c("10", "20", "30")
numeros_reales <- as.numeric(numeros_texto)
print(numeros_reales)  # Resultado: 10 20 30

Esta característica de coerción es importante tenerla en cuenta para evitar resultados inesperados en nuestros análisis y operaciones.

Matrices y arrays multidimensionales

Las matrices son una extensión natural de los vectores en R, pero con una estructura bidimensional organizada en filas y columnas. Mientras que los arrays son estructuras que pueden tener múltiples dimensiones. Ambas estructuras mantienen la característica fundamental de R de contener elementos del mismo tipo.

Creación de matrices

Para crear una matriz en R, podemos utilizar la función matrix():

# Matriz 3x3 con valores del 1 al 9
m1 <- matrix(1:9, nrow = 3, ncol = 3)
print(m1)

Por defecto, R rellena la matriz por columnas. Si queremos rellenarla por filas, usamos el parámetro byrow:

# Matriz rellenada por filas
m2 <- matrix(1:9, nrow = 3, ncol = 3, byrow = TRUE)
print(m2)

También podemos crear matrices combinando vectores con las funciones rbind() (unir por filas) y cbind() (unir por columnas):

# Crear vectores
fila1 <- c(1, 2, 3)
fila2 <- c(4, 5, 6)
fila3 <- c(7, 8, 9)

# Unir por filas
matriz_filas <- rbind(fila1, fila2, fila3)
print(matriz_filas)

# Unir por columnas
col1 <- c(1, 4, 7)
col2 <- c(2, 5, 8)
col3 <- c(3, 6, 9)
matriz_columnas <- cbind(col1, col2, col3)
print(matriz_columnas)

Propiedades de las matrices

Podemos examinar las propiedades básicas de una matriz con varias funciones:

matriz <- matrix(1:12, nrow = 3, ncol = 4)

# Dimensiones
dim(matriz)  # Resultado: 3 4
nrow(matriz)  # Número de filas: 3
ncol(matriz)  # Número de columnas: 4

# Verificar si es una matriz
is.matrix(matriz)  # Resultado: TRUE

# Estructura interna
str(matriz)

Acceso a elementos de una matriz

Para acceder a elementos de una matriz, utilizamos la notación de corchetes con dos índices [fila, columna]:

m <- matrix(1:9, nrow = 3, ncol = 3)

# Acceder a un elemento específico (fila 2, columna 3)
m[2, 3]  # Resultado: 8

# Acceder a una fila completa
m[1, ]  # Primera fila: 1 4 7

# Acceder a una columna completa
m[, 2]  # Segunda columna: 4 5 6

# Acceder a múltiples elementos
m[c(1, 3), c(1, 2)]  # Filas 1 y 3, columnas 1 y 2

También podemos usar indexación lógica para seleccionar elementos:

# Seleccionar elementos mayores que 5
m[m > 5]  # Resultado: 6 7 8 9

# Crear una matriz booleana para filtrar
filtro <- m %% 2 == 0  # Elementos pares
m[filtro]  # Resultado: 2 4 6 8

Modificación de matrices

Podemos modificar elementos específicos o secciones completas de una matriz:

m <- matrix(1:9, nrow = 3, ncol = 3)

# Modificar un elemento
m[2, 2] <- 0
print(m)

# Modificar una fila completa
m[1, ] <- c(10, 20, 30)
print(m)

# Modificar una columna completa
m[, 3] <- c(100, 200, 300)
print(m)

Operaciones con matrices

R permite realizar operaciones aritméticas con matrices de forma vectorizada:

a <- matrix(1:4, nrow = 2)
b <- matrix(5:8, nrow = 2)

# Suma elemento a elemento
suma <- a + b
print(suma)

# Multiplicación elemento a elemento
mult_elem <- a * b
print(mult_elem)

# Multiplicación matricial
mult_matriz <- a %*% b
print(mult_matriz)

# Transpuesta de una matriz
t_a <- t(a)
print(t_a)

Otras operaciones matriciales útiles:

m <- matrix(1:9, nrow = 3)

# Determinante
det(m)

# Inversa (si es posible)
# solve(m)  # Daría error si no es invertible

# Valores propios
eigen(m)

# Diagonal de la matriz
diag(m)

# Crear matriz diagonal
matriz_diag <- diag(c(1, 2, 3))
print(matriz_diag)

Matrices con nombres

Podemos asignar nombres a las filas y columnas de una matriz para facilitar su interpretación:

ventas <- matrix(c(120, 85, 90, 110, 95, 105), nrow = 2, ncol = 3)

# Asignar nombres a filas y columnas
rownames(ventas) <- c("Tienda A", "Tienda B")
colnames(ventas) <- c("Enero", "Febrero", "Marzo")
print(ventas)

# Acceder por nombres
ventas["Tienda A", "Febrero"]  # Resultado: 85

Arrays multidimensionales

Los arrays son una generalización de las matrices a más de dos dimensiones. Se crean con la función array():

# Array de 3 dimensiones: 2x3x2
datos <- array(1:12, dim = c(2, 3, 2))
print(datos)

Para acceder a elementos de un array, usamos la misma notación de corchetes pero con tantos índices como dimensiones tenga:

# Acceder a un elemento (fila 1, columna 2, capa 2)
datos[1, 2, 2]  # Resultado: 9

# Acceder a una "rebanada" (todas las filas y columnas de la capa 1)
datos[, , 1]

Aplicación de funciones a matrices

Podemos aplicar funciones a filas o columnas completas usando apply():

m <- matrix(1:9, nrow = 3)

# Suma de cada fila (MARGIN=1 para filas)
sumas_filas <- apply(m, MARGIN = 1, FUN = sum)
print(sumas_filas)

# Media de cada columna (MARGIN=2 para columnas)
medias_columnas <- apply(m, MARGIN = 2, FUN = mean)
print(medias_columnas)

# Encontrar el valor máximo de cada fila
maximos_filas <- apply(m, 1, max)
print(maximos_filas)

Conversión entre matrices y vectores

Podemos convertir matrices a vectores y viceversa:

m <- matrix(1:6, nrow = 2)

# Convertir matriz a vector (por columnas)
v <- as.vector(m)
print(v)  # Resultado: 1 2 3 4 5 6

# Convertir vector a matriz
nuevo_m <- matrix(v, nrow = 3, byrow = TRUE)
print(nuevo_m)

Ejemplo práctico: análisis de datos tabulares

Las matrices son ideales para representar datos tabulares como temperaturas mensuales:

# Temperaturas máximas mensuales para tres ciudades
temperaturas <- matrix(c(
  28, 30, 32, 31, 29, 27,  # Ciudad A
  22, 24, 26, 25, 23, 20,  # Ciudad B
  18, 20, 23, 22, 19, 17   # Ciudad C
), nrow = 3, byrow = TRUE)

# Asignar nombres
rownames(temperaturas) <- c("Ciudad A", "Ciudad B", "Ciudad C")
colnames(temperaturas) <- c("Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio")

# Temperatura media por ciudad
medias_ciudad <- apply(temperaturas, 1, mean)
print(medias_ciudad)

# Mes más caluroso en promedio
medias_mes <- apply(temperaturas, 2, mean)
mes_mas_caluroso <- colnames(temperaturas)[which.max(medias_mes)]
print(paste("El mes más caluroso en promedio fue:", mes_mas_caluroso))

# Diferencia entre temperatura máxima y mínima por mes
amplitud_termica <- apply(temperaturas, 2, function(x) max(x) - min(x))
print(amplitud_termica)

Las matrices y arrays son estructuras fundamentales en R que permiten organizar datos en múltiples dimensiones, facilitando operaciones matemáticas y estadísticas complejas de manera eficiente.

Listas y data frames

Las listas y los data frames son estructuras de datos fundamentales en R que permiten almacenar información de manera más flexible que los vectores y matrices. Mientras que las estructuras anteriores requieren elementos del mismo tipo, estas nuevas estructuras nos ofrecen mayor versatilidad.

Listas

Una lista en R es una colección ordenada de elementos que pueden ser de diferentes tipos y tamaños. Podemos pensar en ellas como "contenedores" que pueden almacenar cualquier tipo de objeto: vectores, matrices, otras listas e incluso funciones.

Para crear una lista, utilizamos la función list():

# Lista simple con diferentes tipos de datos
mi_lista <- list(100, "R", TRUE, c(1, 2, 3))
print(mi_lista)

Podemos asignar nombres a los elementos de una lista para facilitar su acceso:

# Lista con elementos nombrados
estudiante <- list(
  nombre = "Laura",
  edad = 22,
  calificaciones = c(8.5, 9.2, 7.8),
  aprobado = TRUE
)
print(estudiante)

Acceso a elementos de una lista

Existen varias formas de acceder a los elementos de una lista:

# Usando corchetes simples - devuelve una sublista
sublista <- estudiante["nombre"]
print(sublista)  # Resultado: $nombre [1] "Laura"

# Usando corchetes dobles - extrae el elemento directamente
nombre <- estudiante[["nombre"]]
print(nombre)  # Resultado: [1] "Laura"

# Usando el operador $ - forma más común para elementos nombrados
edad <- estudiante$edad
print(edad)  # Resultado: [1] 22

Para acceder a elementos dentro de elementos de la lista:

# Acceder a la segunda calificación
segunda_nota <- estudiante$calificaciones[2]
print(segunda_nota)  # Resultado: [1] 9.2

Modificación de listas

Podemos modificar elementos existentes o añadir nuevos elementos a una lista:

# Modificar un elemento existente
estudiante$edad <- 23
print(estudiante$edad)

# Añadir un nuevo elemento
estudiante$semestre <- "Primavera 2023"
print(estudiante)

# Eliminar un elemento
estudiante$aprobado <- NULL
print(estudiante)

Listas anidadas

Una característica poderosa de las listas es que pueden contener otras listas, creando estructuras jerárquicas:

# Lista con listas anidadas
universidad <- list(
  nombre = "Universidad Central",
  departamentos = list(
    informatica = list(
      estudiantes = 120,
      profesores = 15
    ),
    matematicas = list(
      estudiantes = 85,
      profesores = 12
    )
  )
)

# Acceder a elementos anidados
num_estudiantes_info <- universidad$departamentos$informatica$estudiantes
print(num_estudiantes_info)  # Resultado: [1] 120

Operaciones con listas

Algunas funciones útiles para trabajar con listas:

mi_lista <- list(a = 1:3, b = "hola", c = TRUE, d = matrix(1:4, 2, 2))

# Longitud de la lista (número de elementos)
length(mi_lista)  # Resultado: 4

# Nombres de los elementos
names(mi_lista)  # Resultado: "a" "b" "c" "d"

# Verificar si es una lista
is.list(mi_lista)  # Resultado: TRUE

# Convertir lista a vector (si es posible)
vector_simple <- unlist(list(1, 2, 3, 4))
print(vector_simple)  # Resultado: 1 2 3 4

Data frames

Un data frame es una estructura de datos tabular similar a una hoja de cálculo. Técnicamente, es un tipo especial de lista donde cada elemento tiene la misma longitud. Los data frames son ideales para almacenar conjuntos de datos donde cada columna puede ser de un tipo diferente (numérico, carácter, lógico, etc.).

Creación de data frames

La forma más común de crear un data frame es mediante la función data.frame():

# Crear un data frame simple
estudiantes <- data.frame(
  nombre = c("Ana", "Carlos", "Elena", "David"),
  edad = c(22, 25, 21, 24),
  promedio = c(8.7, 7.9, 9.2, 8.5),
  becado = c(TRUE, FALSE, TRUE, FALSE)
)
print(estudiantes)

También podemos convertir otras estructuras en data frames:

# Convertir una matriz en data frame
matriz <- matrix(1:6, nrow = 2)
colnames(matriz) <- c("A", "B", "C")
df_matriz <- as.data.frame(matriz)
print(df_matriz)

Acceso a elementos de un data frame

Podemos acceder a los elementos de un data frame de varias maneras:

# Acceder a una columna usando $
nombres <- estudiantes$nombre
print(nombres)

# Acceder a una columna como si fuera una lista
edades <- estudiantes[["edad"]]
print(edades)

# Acceder usando índices [fila, columna]
primer_estudiante <- estudiantes[1, ]  # Primera fila
print(primer_estudiante)

tercera_columna <- estudiantes[, 3]  # Tercera columna
print(tercera_columna)

# Acceder a un valor específico
valor <- estudiantes[2, 3]  # Fila 2, columna 3
print(valor)  # Resultado: 7.9

# Acceder usando nombres de columnas
promedios <- estudiantes[, "promedio"]
print(promedios)

Añadir y modificar datos

Podemos añadir nuevas columnas o filas a un data frame:

# Añadir una nueva columna
estudiantes$carrera <- c("Informática", "Matemáticas", "Física", "Química")
print(estudiantes)

# Modificar valores existentes
estudiantes$edad[1] <- 23
print(estudiantes)

# Añadir una nueva fila
nuevo_estudiante <- data.frame(
  nombre = "Laura",
  edad = 22,
  promedio = 8.8,
  becado = TRUE,
  carrera = "Biología"
)
estudiantes_actualizado <- rbind(estudiantes, nuevo_estudiante)
print(estudiantes_actualizado)

Filtrado de datos

Una de las operaciones más comunes con data frames es filtrar filas según ciertas condiciones:

# Filtrar estudiantes con promedio mayor a 8.5
buenos_estudiantes <- estudiantes[estudiantes$promedio > 8.5, ]
print(buenos_estudiantes)

# Filtrar estudiantes becados de Informática
becados_info <- estudiantes[estudiantes$becado == TRUE & estudiantes$carrera == "Informática", ]
print(becados_info)

Funciones útiles para data frames

R proporciona muchas funciones para trabajar con data frames:

# Dimensiones del data frame
dim(estudiantes)  # Resultado: filas columnas

# Resumen estadístico
summary(estudiantes)

# Nombres de las columnas
colnames(estudiantes)

# Nombres de las filas
rownames(estudiantes)

# Estructura del data frame
str(estudiantes)

# Primeras filas
head(estudiantes, n = 2)  # Muestra las primeras 2 filas

# Últimas filas
tail(estudiantes, n = 2)  # Muestra las últimas 2 filas

Ordenamiento de datos

Podemos ordenar un data frame según los valores de una o más columnas:

# Ordenar por edad (ascendente)
estudiantes_por_edad <- estudiantes[order(estudiantes$edad), ]
print(estudiantes_por_edad)

# Ordenar por promedio (descendente)
estudiantes_por_promedio <- estudiantes[order(estudiantes$promedio, decreasing = TRUE), ]
print(estudiantes_por_promedio)

# Ordenar por múltiples columnas
estudiantes_ordenados <- estudiantes[order(estudiantes$carrera, -estudiantes$promedio), ]
print(estudiantes_ordenados)  # Primero por carrera, luego por promedio descendente

Ejemplo práctico: análisis básico de datos

Veamos un ejemplo sencillo de cómo podríamos usar un data frame para analizar datos:

# Datos de ventas mensuales por producto
ventas <- data.frame(
  producto = c("A", "B", "C", "A", "B", "C"),
  mes = c("Enero", "Enero", "Enero", "Febrero", "Febrero", "Febrero"),
  unidades = c(120, 85, 90, 140, 95, 110),
  precio = c(25, 32, 15, 25, 34, 15)
)

# Calcular ingresos por venta
ventas$ingresos <- ventas$unidades * ventas$precio
print(ventas)

# Ventas totales por producto
ventas_por_producto <- aggregate(unidades ~ producto, data = ventas, sum)
print(ventas_por_producto)

# Ingresos totales por mes
ingresos_por_mes <- aggregate(ingresos ~ mes, data = ventas, sum)
print(ingresos_por_mes)

# Producto más vendido
producto_max <- ventas_por_producto$producto[which.max(ventas_por_producto$unidades)]
print(paste("El producto más vendido fue:", producto_max))

Las listas y data frames son estructuras fundamentales en R que permiten manejar datos complejos y heterogéneos. Los data frames en particular son la base para el análisis de datos en R, ya que permiten almacenar y manipular conjuntos de datos tabulares de manera eficiente y flexible.