Tutorial R: tidyverse para transformación de datos

Ecosistema tidyverse y filosofía tidy

El tidyverse es una colección de paquetes de R diseñados para facilitar el análisis de datos. Más que un simple conjunto de herramientas, representa una filosofía coherente sobre cómo debería ser la manipulación de datos: intuitiva, consistente y eficiente.

¿Qué es el tidyverse?

El tidyverse es un ecosistema integrado de paquetes de R desarrollados principalmente por Hadley Wickham y su equipo en RStudio (ahora Posit). Estos paquetes comparten una visión común sobre la sintaxis, la estructura de datos y el flujo de trabajo para el análisis de datos.

Para instalar el tidyverse completo, simplemente ejecutamos:

install.packages("tidyverse")

Y para cargarlo en nuestra sesión:

library(tidyverse)

Al cargar el tidyverse, veremos un mensaje que nos indica los paquetes principales que se han cargado:

── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ dplyr     1.1.2     ✔ readr     2.1.4
✔ forcats   1.0.0     ✔ stringr   1.5.0
✔ ggplot2   3.4.2     ✔ tibble    3.2.1
✔ lubridate 1.9.2     ✔ tidyr     1.3.0
✔ purrr     1.0.1     

Paquetes principales del tidyverse

El ecosistema tidyverse incluye varios paquetes fundamentales, cada uno con un propósito específico:

• ggplot2: Para visualización de datos basada en la gramática de gráficos
• dplyr: Para manipulación de datos mediante verbos intuitivos
• tidyr: Para ordenar y estructurar datos
• readr: Para importar datos de manera eficiente
• purrr: Para programación funcional
• tibble: Una reimaginación moderna del data frame
• stringr: Para manipulación de cadenas de texto
• forcats: Para trabajar con factores (variables categóricas)

La filosofía tidy data

En el corazón del tidyverse está el concepto de datos ordenados o tidy data, introducido por Hadley Wickham. Esta filosofía establece principios claros sobre cómo deben estructurarse los datos para facilitar su análisis:

1. Cada variable forma una columna
2. Cada observación forma una fila
3. Cada tipo de unidad observacional forma una tabla

Veamos un ejemplo sencillo de datos en formato "tidy":

# Datos en formato tidy
pacientes_tidy <- tibble(
  id = c(1, 2, 3),
  edad = c(25, 34, 45),
  temperatura = c(37.1, 38.2, 36.9)
)

pacientes_tidy

# A tibble: 3 × 3
     id  edad temperatura
  <dbl> <dbl>       <dbl>
1     1    25        37.1
2     2    34        38.2
3     3    45        36.9

En contraste, los mismos datos en formato "no tidy" podrían verse así:

# Datos en formato no tidy
pacientes_no_tidy <- tibble(
  id = c(1, 2, 3),
  medida = c("edad", "edad", "edad", "temperatura", "temperatura", "temperatura"),
  valor = c(25, 34, 45, 37.1, 38.2, 36.9)
)

pacientes_no_tidy

# A tibble: 6 × 3
     id medida      valor
  <dbl> <chr>       <dbl>
1     1 edad         25  
2     2 edad         34  
3     3 edad         45  
4     1 temperatura  37.1
5     2 temperatura  38.2
6     3 temperatura  36.9

Principios de diseño del tidyverse

El tidyverse se basa en varios principios de diseño que lo hacen especialmente útil:

• Consistencia: Todos los paquetes siguen convenciones similares en cuanto a nombres, argumentos y comportamiento.
• Legibilidad: El código escrito con tidyverse es más fácil de leer y entender.
• Composición: Las funciones están diseñadas para trabajar juntas mediante el operador pipe.
• Funciones específicas: Cada función hace una sola cosa y la hace bien.

El tibble: el data frame moderno

El tibble es la estructura de datos fundamental en el tidyverse, una versión mejorada del tradicional data frame de R:

# Creando un tibble
datos <- tibble(
  x = 1:5,
  y = x * 2,
  z = letters[1:5]
)

datos

# A tibble: 5 × 3
      x     y z    
  <int> <dbl> <chr>
1     1     2 a    
2     2     4 b    
3     3     6 c    
4     4     8 d    
5     5    10 e    

Los tibbles tienen varias ventajas sobre los data frames tradicionales:

• Muestran solo las primeras filas al imprimirse
• Indican el tipo de datos de cada columna
• No convierten automáticamente strings a factores
• No cambian los nombres de las variables
• Generan mensajes de error más informativos

Ejemplo práctico: un flujo de trabajo tidyverse

Veamos un ejemplo sencillo que ilustra cómo el tidyverse facilita el análisis de datos:

# Creamos datos de ejemplo
datos_ventas <- tibble(
  producto = c("A", "B", "C", "A", "B", "C"),
  region = c("Norte", "Norte", "Norte", "Sur", "Sur", "Sur"),
  ventas = c(100, 150, 200, 120, 180, 210)
)

# Exploramos los datos
glimpse(datos_ventas)

Rows: 6
Columns: 3
$ producto <chr> "A", "B", "C", "A", "B", "C"
$ region   <chr> "Norte", "Norte", "Norte", "Sur", "Sur", "Sur"
$ ventas   <dbl> 100, 150, 200, 120, 180, 210

La función glimpse() del paquete dplyr nos da una visión rápida de nuestros datos, mostrando el tipo de cada columna y algunos valores.

Ventajas del enfoque tidyverse

El ecosistema tidyverse ofrece varias ventajas significativas:

• Curva de aprendizaje gradual: Puedes aprender los paquetes uno por uno según tus necesidades
• Código más expresivo: Las operaciones reflejan el pensamiento humano sobre los datos
• Mejor mantenimiento: El código es más fácil de revisar y modificar
• Comunidad activa: Amplia documentación, tutoriales y soporte
• Desarrollo continuo: Mejoras y actualizaciones frecuentes

Integración con el ecosistema R

Aunque el tidyverse proporciona un enfoque coherente para el análisis de datos, está diseñado para integrarse perfectamente con el resto del ecosistema R:

# Combinando tidyverse con funciones de R base
set.seed(123)  # Función de R base
datos_aleatorios <- tibble(
  x = rnorm(100),  # Función de R base
  grupo = sample(c("A", "B"), 100, replace = TRUE)  # Función de R base
)

# Usando una función de tidyverse con el resultado
summary(datos_aleatorios$x)  # Función de R base con datos de tidyverse

Esta capacidad de combinar enfoques es una de las grandes fortalezas del tidyverse, permitiéndote utilizar las herramientas más adecuadas para cada tarea.

El tidyverse no pretende reemplazar R base, sino ofrecer una alternativa más coherente y moderna para muchas tareas de análisis de datos, especialmente para usuarios nuevos o aquellos que priorizan la legibilidad y mantenibilidad del código.

Pipes %>% y |> para encadenar operaciones

Uno de los elementos más distintivos del ecosistema tidyverse es el operador pipe, que permite encadenar operaciones de manera fluida y legible. Este operador transforma radicalmente la forma en que escribimos código en R, permitiéndonos expresar secuencias de operaciones de manera más natural.

El operador pipe de magrittr: %>%

El operador pipe (%>%) fue introducido originalmente en el paquete magrittr y posteriormente adoptado como elemento central del tidyverse. Su función es simple pero poderosa: toma el resultado de la expresión de la izquierda y lo pasa como primer argumento a la función de la derecha.

Para entender su utilidad, comparemos dos formas de escribir el mismo código:

# Sin usar pipes
resultado <- round(sqrt(sum(1:10)), digits = 2)

# Usando pipes
resultado <- 1:10 %>% 
  sum() %>% 
  sqrt() %>% 
  round(digits = 2)

Ambos códigos producen el mismo resultado (7.42), pero la versión con pipes es más legible porque sigue un orden lógico de operaciones: primero sumamos los números del 1 al 10, luego calculamos la raíz cuadrada y finalmente redondeamos a dos decimales.

Ventajas del operador pipe

El uso de pipes ofrece varias ventajas importantes:

• Legibilidad: El código se lee de izquierda a derecha y de arriba a abajo, siguiendo el flujo natural de lectura.
• Modularidad: Cada paso es una operación independiente, facilitando la comprensión y depuración.
• Menos variables temporales: No necesitamos crear variables intermedias para almacenar resultados parciales.
• Menos anidamiento: Evitamos las llamadas a funciones anidadas que son difíciles de leer.

Uso básico del pipe

El operador pipe se utiliza colocándolo entre una expresión y una función:

# Estructura básica
datos %>% funcion(arg1, arg2)

Esto es equivalente a:

funcion(datos, arg1, arg2)

Veamos un ejemplo práctico con datos reales:

# Creamos un pequeño conjunto de datos
datos <- tibble(
  nombre = c("Ana", "Carlos", "Elena", "David"),
  edad = c(25, 34, 29, 42),
  ciudad = c("Madrid", "Barcelona", "Valencia", "Sevilla")
)

# Filtramos personas mayores de 30 años y seleccionamos nombre y ciudad
datos %>%
  filter(edad > 30) %>%
  select(nombre, ciudad)

# A tibble: 2 × 2
  nombre ciudad   
  <chr>  <chr>    
1 Carlos Barcelona
2 David  Sevilla  

Variaciones en el uso del pipe

El operador pipe es muy flexible y permite diferentes patrones de uso:

• Pipe con punto (.):

Cuando queremos que el valor se inserte en una posición diferente al primer argumento, usamos el punto como marcador de posición:

# El valor se inserta donde está el punto
1:5 %>% mean(., na.rm = TRUE)

# También funciona con posiciones no estándar
iris %>% lm(Sepal.Length ~ Sepal.Width, data = .)

• Pipe con funciones anónimas:

Podemos crear funciones anónimas dentro de una cadena de pipes:

1:10 %>%
  (function(x) x[x %% 2 == 0])() %>%
  sum()

El nuevo pipe nativo de R: |>

A partir de R 4.1.0, se introdujo un operador pipe nativo (|>) que forma parte del lenguaje base y no requiere cargar ningún paquete adicional:

# Usando el pipe nativo de R
1:10 |> 
  sum() |> 
  sqrt() |> 
  round(digits = 2)

Este nuevo pipe tiene algunas diferencias con respecto al pipe de magrittr:

• No requiere cargar ningún paquete
• Es ligeramente más rápido en términos de rendimiento
• Tiene una sintaxis más limitada (no admite el operador punto)
• Ofrece una sintaxis especial para funciones anónimas (desde R 4.2.0)

Comparación entre %>% y |>

Veamos las principales diferencias entre ambos operadores:

# Con el pipe de magrittr
iris %>%
  subset(Species == "setosa") %>%
  lm(Sepal.Length ~ Petal.Length, data = .)

# Con el pipe nativo de R (desde R 4.2.0)
iris |>
  subset(Species == "setosa") |>
  (\(df) lm(Sepal.Length ~ Petal.Length, data = df))()

Observa que el pipe nativo utiliza una sintaxis especial \(df) para crear una función anónima, en lugar del punto que usa magrittr.

Pipes en el flujo de trabajo de análisis de datos

Los pipes brillan especialmente cuando trabajamos con las funciones del tidyverse para manipular datos. Veamos un ejemplo completo:

# Creamos datos de ejemplo
datos_ventas <- tibble(
  fecha = as.Date('2023-01-01') + 0:29,
  ventas = sample(100:500, 30, replace = TRUE),
  categoria = sample(c("A", "B", "C"), 30, replace = TRUE)
)

# Análisis con pipes
datos_ventas %>%
  mutate(mes = format(fecha, "%m")) %>%
  group_by(mes, categoria) %>%
  summarise(
    total_ventas = sum(ventas),
    promedio = mean(ventas),
    n = n(),
    .groups = "drop"
  ) %>%
  arrange(desc(total_ventas))

Este código es claro y expresivo: primero creamos una columna para el mes, luego agrupamos por mes y categoría, calculamos estadísticas resumidas y finalmente ordenamos por total de ventas.

Cuándo usar (y no usar) pipes

Los pipes son ideales para:

• Secuencias lineales de transformaciones de datos
• Operaciones que fluyen naturalmente de una a otra
• Código que quieres que sea fácil de leer y mantener

Sin embargo, hay situaciones donde los pipes pueden no ser la mejor opción:

• Operaciones muy simples (una o dos funciones)
• Código con muchas ramificaciones o condiciones
• Cuando necesitas reutilizar resultados intermedios
• Cuando trabajas principalmente con funciones que no siguen el patrón "datos primero"

# A veces, el código tradicional es más claro
x <- c(NA, 1:10, NA)
mean(x, na.rm = TRUE)  # Más simple que: x %>% mean(na.rm = TRUE)

Consejos para usar pipes efectivamente

Para aprovechar al máximo los pipes, considera estas recomendaciones:

• Limita cada línea a una sola operación para mejorar la legibilidad
• Usa indentación consistente (generalmente 2 espacios)
• No crees cadenas demasiado largas (más de 10 operaciones puede ser excesivo)
• Añade comentarios para explicar los pasos complejos
• Considera guardar resultados intermedios si necesitas referirte a ellos más tarde

# Ejemplo de formato recomendado
resultado_final <- datos_iniciales %>%
  # Limpiamos los datos
  filter(!is.na(valor)) %>%
  # Transformamos variables
  mutate(
    valor_ajustado = valor / factor_ajuste,
    categoria = factor(categoria)
  ) %>%
  # Calculamos estadísticas por grupo
  group_by(categoria) %>%
  summarise(media = mean(valor_ajustado))

Integración con funciones no-tidyverse

Los pipes también funcionan bien con funciones de R base y otros paquetes, aunque a veces requieren ajustes:

# Combinando tidyverse con funciones estadísticas de R base
mtcars %>%
  split(.$cyl) %>%
  map(~ lm(mpg ~ wt, data = .)) %>%
  map(summary) %>%
  map_dbl(~ .$r.squared)

Este ejemplo muestra cómo podemos usar pipes para crear modelos lineales para cada grupo de cilindros y extraer los valores R-cuadrado de manera concisa.

Los operadores pipe han revolucionado la forma en que escribimos código en R, permitiendo crear flujos de trabajo más intuitivos y legibles. Ya sea que prefieras el clásico %>% del tidyverse o el nuevo |> nativo de R, incorporar pipes a tu código puede mejorar significativamente su claridad y mantenibilidad.

Flujo de trabajo tidyverse vs R base

El análisis de datos en R puede abordarse desde diferentes perspectivas. Tradicionalmente, R base ha sido la herramienta fundamental para manipular datos, pero el ecosistema tidyverse ofrece un enfoque alternativo con una filosofía distinta. Comprender las diferencias entre ambos enfoques te ayudará a elegir el más adecuado según tus necesidades.

Diferencias fundamentales en la sintaxis

R base y tidyverse difieren significativamente en cómo expresamos las operaciones de manipulación de datos:

• R base utiliza principalmente funciones que toman argumentos específicos y a menudo requiere indexación mediante corchetes.
• tidyverse emplea verbos intuitivos que operan sobre data frames y se conectan mediante pipes.

Veamos un ejemplo sencillo de cómo filtrar filas y seleccionar columnas:

# Creamos un data frame de ejemplo
datos <- data.frame(
  id = 1:5,
  nombre = c("Ana", "Carlos", "Elena", "David", "Beatriz"),
  edad = c(25, 34, 29, 42, 31),
  ciudad = c("Madrid", "Barcelona", "Valencia", "Sevilla", "Bilbao")
)

# Enfoque R base: filtrar personas mayores de 30 y seleccionar nombre y ciudad
resultado_base <- datos[datos$edad > 30, c("nombre", "ciudad")]

# Enfoque tidyverse
library(dplyr)
resultado_tidy <- datos %>%
  filter(edad > 30) %>%
  select(nombre, ciudad)

Ambos enfoques producen el mismo resultado, pero la sintaxis y el flujo de trabajo son notablemente diferentes.

Manipulación de datos: verbos vs funciones

Una de las principales diferencias está en cómo se expresan las operaciones comunes:

• R base utiliza diferentes funciones y técnicas para distintas operaciones:

# Operaciones comunes en R base
# 1. Filtrado
datos_filtrados <- datos[datos$edad > 30, ]

# 2. Selección de columnas
datos_seleccionados <- datos[, c("nombre", "edad")]

# 3. Creación de nuevas variables
datos$edad_en_meses <- datos$edad * 12

# 4. Ordenamiento
datos_ordenados <- datos[order(datos$edad, decreasing = TRUE), ]

# 5. Agrupación y resumen
medias_por_ciudad <- aggregate(edad ~ ciudad, data = datos, FUN = mean)

• tidyverse utiliza verbos consistentes que expresan claramente la intención:

# Operaciones equivalentes con tidyverse
# 1. Filtrado
datos_filtrados <- datos %>% filter(edad > 30)

# 2. Selección de columnas
datos_seleccionados <- datos %>% select(nombre, edad)

# 3. Creación de nuevas variables
datos_con_meses <- datos %>% mutate(edad_en_meses = edad * 12)

# 4. Ordenamiento
datos_ordenados <- datos %>% arrange(desc(edad))

# 5. Agrupación y resumen
medias_por_ciudad <- datos %>% 
  group_by(ciudad) %>%
  summarise(edad_media = mean(edad))

Consistencia en la interfaz

Una ventaja clave del tidyverse es la consistencia en cómo las funciones interactúan con los datos:

• En tidyverse, el primer argumento de cada función es siempre un data frame, y el resultado es siempre un data frame.
• En R base, las funciones pueden tener diferentes estructuras de argumentos y devolver diferentes tipos de objetos.

Esta consistencia hace que el código tidyverse sea más predecible y fácil de componer:

# Ejemplo de flujo de trabajo completo en tidyverse
resultado_final <- datos %>%
  filter(edad > 25) %>%
  mutate(categoria_edad = ifelse(edad > 30, "Senior", "Junior")) %>%
  group_by(categoria_edad, ciudad) %>%
  summarise(edad_promedio = mean(edad), .groups = "drop") %>%
  arrange(desc(edad_promedio))

El equivalente en R base requeriría múltiples pasos intermedios o anidamiento de funciones:

# Equivalente en R base
datos_filtrados <- datos[datos$edad > 25, ]
datos_filtrados$categoria_edad <- ifelse(datos_filtrados$edad > 30, "Senior", "Junior")
resultado_agrupado <- aggregate(
  edad ~ categoria_edad + ciudad, 
  data = datos_filtrados, 
  FUN = mean
)
colnames(resultado_agrupado)[3] <- "edad_promedio"
resultado_final <- resultado_agrupado[order(resultado_agrupado$edad_promedio, decreasing = TRUE), ]

Manejo de valores ausentes (NA)

Otra diferencia importante está en cómo se manejan los valores ausentes:

• R base a menudo requiere especificar explícitamente na.rm = TRUE en funciones como mean() o sum().
• tidyverse sigue siendo explícito, pero las funciones de resumen en summarise() tienen comportamientos más consistentes.

# Datos con valores NA
datos_con_na <- data.frame(
  grupo = c("A", "A", "B", "B", "C"),
  valor = c(10, NA, 30, 40, NA)
)

# R base: requiere especificar na.rm en cada función
medias_base <- aggregate(valor ~ grupo, data = datos_con_na, FUN = function(x) mean(x, na.rm = TRUE))

# tidyverse: también requiere na.rm, pero con sintaxis más clara
medias_tidy <- datos_con_na %>%
  group_by(grupo) %>%
  summarise(valor_medio = mean(valor, na.rm = TRUE))

Operaciones por grupos

La manipulación de datos por grupos muestra una de las mayores diferencias entre ambos enfoques:

# Datos de ejemplo
ventas <- data.frame(
  producto = rep(c("A", "B", "C"), each = 4),
  region = rep(c("Norte", "Sur"), each = 2, times = 3),
  trimestre = rep(c(1, 2), times = 6),
  unidades = sample(10:100, 12)
)

# R base: calcular total y promedio por producto
resultado_base <- aggregate(
  unidades ~ producto, 
  data = ventas, 
  FUN = function(x) c(total = sum(x), promedio = mean(x))
)
# Esto produce una matriz en cada celda, requiriendo transformación adicional

# tidyverse: más directo y legible
resultado_tidy <- ventas %>%
  group_by(producto) %>%
  summarise(
    total = sum(unidades),
    promedio = mean(unidades)
  )

Transformación de formato de datos

La transformación entre formatos "largo" y "ancho" también ilustra diferencias importantes:

# Datos en formato ancho
datos_ancho <- data.frame(
  id = 1:3,
  valor_2020 = c(10, 15, 20),
  valor_2021 = c(12, 18, 22),
  valor_2022 = c(15, 21, 25)
)

# R base: transformar a formato largo
datos_largo_base <- reshape(
  datos_ancho,
  direction = "long",
  varying = list(c("valor_2020", "valor_2021", "valor_2022")),
  v.names = "valor",
  idvar = "id",
  timevar = "año",
  times = c(2020, 2021, 2022)
)
rownames(datos_largo_base) <- NULL

# tidyverse: más intuitivo con pivot_longer
library(tidyr)
datos_largo_tidy <- datos_ancho %>%
  pivot_longer(
    cols = starts_with("valor_"),
    names_to = "año",
    names_prefix = "valor_",
    values_to = "valor"
  )

Rendimiento y eficiencia

En términos de rendimiento, hay consideraciones importantes:

• R base suele ser más eficiente para operaciones simples y conjuntos de datos pequeños.
• tidyverse puede ser más rápido para operaciones complejas gracias a optimizaciones internas, especialmente con grandes conjuntos de datos.

# Comparación de rendimiento para una operación simple
# Creamos un data frame grande
set.seed(123)
datos_grandes <- data.frame(
  x = rnorm(1000000),
  grupo = sample(letters[1:5], 1000000, replace = TRUE)
)

# Medimos tiempo con R base
system.time({
  resultado_base <- aggregate(x ~ grupo, data = datos_grandes, FUN = mean)
})

# Medimos tiempo con tidyverse
system.time({
  resultado_tidy <- datos_grandes %>%
    group_by(grupo) %>%
    summarise(media_x = mean(x))
})

Curva de aprendizaje

La curva de aprendizaje es otro factor a considerar:

• R base requiere aprender diversas funciones con diferentes interfaces, pero es parte fundamental del lenguaje.
• tidyverse tiene una filosofía coherente que puede ser más fácil de aprender para principiantes, pero requiere aprender un nuevo "dialecto" de R.

Cuándo usar cada enfoque

Ambos enfoques tienen sus fortalezas y casos de uso ideales:

• Usa R base cuando:

• Trabajas con estructuras de datos simples (vectores, matrices)

• Necesitas máxima eficiencia para operaciones elementales

• Estás desarrollando paquetes con mínimas dependencias

• Prefieres la sintaxis tradicional de R

• Usa tidyverse cuando:

• Trabajas principalmente con data frames

• Realizas análisis exploratorio de datos

• Necesitas código más legible y mantenible

• Prefieres un flujo de trabajo más intuitivo y consistente

Combinando ambos enfoques

En la práctica, muchos analistas de datos combinan ambos enfoques según la tarea:

# Ejemplo de combinación de enfoques
resultado_combinado <- datos %>%
  # Usamos tidyverse para filtrar y seleccionar
  filter(edad > 25) %>%
  select(nombre, edad, ciudad) %>%
  # Usamos una función de R base
  transform(edad_normalizada = scale(edad)) %>%
  # Volvemos a tidyverse
  arrange(desc(edad))

Ejemplo práctico comparativo

Veamos un ejemplo completo que ilustra las diferencias en un análisis típico:

# Datos de ejemplo: información de ventas
ventas_datos <- data.frame(
  fecha = as.Date('2023-01-01') + 0:364,
  producto = sample(c("A", "B", "C"), 365, replace = TRUE),
  unidades = sample(1:100, 365, replace = TRUE),
  precio = sample(c(10, 15, 20, 25), 365, replace = TRUE)
)
ventas_datos$mes <- format(ventas_datos$fecha, "%m")
ventas_datos$ingresos <- ventas_datos$unidades * ventas_datos$precio

# Análisis con R base: ventas mensuales por producto
ventas_mensuales_base <- aggregate(
  ingresos ~ mes + producto, 
  data = ventas_datos, 
  FUN = sum
)
top_productos_base <- ventas_mensuales_base[
  order(ventas_mensuales_base$mes, ventas_mensuales_base$ingresos, decreasing = TRUE),
]
top_por_mes_base <- by(top_productos_base, top_productos_base$mes, 
                      function(x) x[1:2, ])

# Análisis equivalente con tidyverse
ventas_mensuales_tidy <- ventas_datos %>%
  group_by(mes, producto) %>%
  summarise(ingresos_totales = sum(ingresos), .groups = "drop") %>%
  arrange(mes, desc(ingresos_totales)) %>%
  group_by(mes) %>%
  slice_head(n = 2)

El enfoque tidyverse resulta más conciso y expresivo, especialmente para análisis complejos con múltiples pasos.

Transición entre enfoques

Si estás acostumbrado a R base y quieres migrar hacia tidyverse, puedes hacerlo gradualmente:

1. Comienza usando pipes (%>%) con funciones de R base
2. Incorpora verbos de dplyr uno a uno (primero filter(), luego select(), etc.)
3. Aprende a usar group_by() y summarise() para reemplazar aggregate()
4. Explora funciones más avanzadas según tus necesidades

Recuerda que no es necesario elegir exclusivamente uno u otro enfoque. La flexibilidad de R te permite utilizar las herramientas más adecuadas para cada tarea específica.