Tutorial R: pivot_longer y pivot_wider para reestructuración

Conversión de formato ancho a largo con pivot_longer()

La manipulación de datos en R a menudo requiere cambiar la estructura de nuestros conjuntos de datos. Uno de los formatos más comunes que encontraremos son los datos en formato ancho, donde cada variable tiene su propia columna. Sin embargo, para muchos análisis y visualizaciones, necesitamos transformar estos datos a un formato largo, donde los valores de múltiples columnas se apilan en una sola.

La función pivot_longer() del paquete tidyr nos permite realizar esta transformación de manera eficiente. Esta función toma columnas y las convierte en filas, creando un conjunto de datos más estrecho pero más largo.

Entendiendo el formato ancho vs. largo

Antes de sumergirnos en el código, veamos la diferencia entre estos formatos:

• Formato ancho: Cada variable tiene su propia columna. Es el formato habitual de las hojas de cálculo.
• Formato largo: Los nombres de las variables se almacenan en una columna y sus valores en otra.

Veamos un ejemplo sencillo para ilustrar esto:

# Cargamos las librerías necesarias
library(tidyverse)

# Creamos un conjunto de datos en formato ancho
datos_ancho <- tibble(
  id = 1:3,
  peso_2020 = c(70, 65, 80),
  peso_2021 = c(72, 63, 81),
  peso_2022 = c(71, 64, 82)
)

# Mostramos los datos
datos_ancho

Este conjunto de datos muestra el peso de tres personas durante tres años consecutivos. Cada año tiene su propia columna, lo que lo convierte en un formato ancho.

Uso básico de pivot_longer()

Para convertir estos datos a formato largo, utilizamos pivot_longer():

datos_largo <- datos_ancho %>%
  pivot_longer(
    cols = starts_with("peso_"),    # Columnas a transformar
    names_to = "año",               # Nueva columna para los nombres
    values_to = "peso"              # Nueva columna para los valores
  )

# Mostramos el resultado
datos_largo

Ahora tenemos un conjunto de datos con más filas pero menos columnas. Cada combinación de id y año aparece como una fila separada, con el peso correspondiente.

Parámetros principales de pivot_longer()

La función pivot_longer() tiene varios parámetros importantes:

• cols: Especifica qué columnas queremos transformar. Podemos usar:

• Nombres de columnas directamente: c(col1, col2, col3)
• Selectores de tidyselect: starts_with(), contains(), matches(), etc.
• Rangos de columnas: col1:col5

• names_to: El nombre de la nueva columna que contendrá los nombres de las columnas originales.

• values_to: El nombre de la nueva columna que contendrá los valores.

Ejemplo con datos reales

Veamos un ejemplo más realista con datos de ventas trimestrales:

# Datos de ventas trimestrales por producto
ventas <- tibble(
  producto = c("Laptop", "Teléfono", "Tablet", "Auriculares"),
  Q1_2022 = c(120, 340, 90, 65),
  Q2_2022 = c(110, 290, 105, 72),
  Q3_2022 = c(130, 310, 115, 80),
  Q4_2022 = c(150, 380, 125, 95)
)

# Mostramos los datos originales
ventas

Ahora convertimos estos datos a formato largo:

ventas_largo <- ventas %>%
  pivot_longer(
    cols = -producto,              # Todas las columnas excepto "producto"
    names_to = "trimestre",        # Nueva columna para los trimestres
    values_to = "unidades_vendidas" # Nueva columna para las ventas
  )

# Mostramos el resultado
ventas_largo

Este formato facilita enormemente la creación de visualizaciones como gráficos de líneas para tendencias temporales:

# Creamos un gráfico de líneas
ggplot(ventas_largo, aes(x = trimestre, y = unidades_vendidas, color = producto, group = producto)) +
  geom_line() +
  geom_point() +
  theme_minimal() +
  labs(title = "Ventas trimestrales por producto",
       x = "Trimestre",
       y = "Unidades vendidas")

Procesamiento de nombres de columnas

A veces, los nombres de las columnas contienen información que queremos separar en múltiples columnas. pivot_longer() nos permite hacer esto con el parámetro names_pattern o names_sep:

# Separando el trimestre y el año
ventas_detallado <- ventas %>%
  pivot_longer(
    cols = -producto,
    names_to = c("trimestre", "año"),  # Dos nuevas columnas
    names_pattern = "(Q[1-4])_(\\d{4})",  # Patrón de expresión regular
    values_to = "unidades_vendidas"
  )

# Mostramos el resultado
ventas_detallado

También podemos usar names_sep si los componentes están separados por un carácter específico:

# Datos con nombres de columnas separados por punto
datos_puntos <- tibble(
  id = 1:3,
  peso.2020 = c(70, 65, 80),
  peso.2021 = c(72, 63, 81),
  peso.2022 = c(71, 64, 82)
)

# Transformación usando names_sep
datos_separados <- datos_puntos %>%
  pivot_longer(
    cols = -id,
    names_to = c("medida", "año"),
    names_sep = "\\.",  # Separador (punto)
    values_to = "valor"
  )

# Mostramos el resultado
datos_separados

Manejo de valores NA

Por defecto, pivot_longer() mantiene los valores NA. Sin embargo, podemos eliminarlos con el parámetro values_drop_na:

# Datos con algunos valores NA
datos_na <- tibble(
  id = 1:3,
  peso_2020 = c(70, NA, 80),
  peso_2021 = c(72, 63, NA),
  peso_2022 = c(71, 64, 82)
)

# Transformación eliminando NAs
datos_sin_na <- datos_na %>%
  pivot_longer(
    cols = starts_with("peso_"),
    names_to = "año",
    values_to = "peso",
    values_drop_na = TRUE  # Eliminar filas con NA
  )

# Mostramos el resultado
datos_sin_na

Consejos prácticos

• Nombres de columnas: Si tus columnas tienen nombres que no son sintácticamente válidos en R (contienen espacios, comienzan con números, etc.), usa comillas invertidas para referenciarlos: `2020 Sales`.

• Columnas de identificación: Mantén las columnas que identifican cada observación fuera de la transformación usando el operador - o seleccionando específicamente las columnas a transformar.

• Transformación de tipos: Puedes convertir los tipos de datos de las nuevas columnas usando names_transform y values_transform:

# Transformando tipos de datos
datos_transformados <- datos_ancho %>%
  pivot_longer(
    cols = starts_with("peso_"),
    names_to = "año",
    names_prefix = "peso_",  # Eliminar el prefijo "peso_"
    names_transform = list(año = as.integer),  # Convertir año a entero
    values_to = "peso",
    values_transform = list(peso = as.double)  # Asegurar que peso es numérico
  )

# Mostramos el resultado
datos_transformados

La función pivot_longer() es una herramienta fundamental para la preparación de datos en análisis exploratorio y visualización. Dominar esta función te permitirá adaptar tus datos al formato necesario para diferentes tipos de análisis y representaciones gráficas.

Transformación a formato ancho con pivot_wider()

La función pivot_wider() realiza la operación inversa a pivot_longer(), permitiéndonos transformar datos en formato largo a formato ancho. Esta transformación es especialmente útil cuando necesitamos crear tablas de resumen, preparar datos para ciertos tipos de visualizaciones o exportar información en un formato más legible para personas no familiarizadas con análisis de datos.

Fundamentos de pivot_wider()

La función pivot_wider() toma valores de una columna y los expande en múltiples columnas, creando un conjunto de datos más ancho pero con menos filas. Los dos parámetros principales que necesitamos especificar son:

• names_from: La columna que contiene los valores que se convertirán en nombres de columnas
• values_from: La columna que contiene los valores que se distribuirán en las nuevas columnas

Veamos un ejemplo básico:

library(tidyverse)

# Datos en formato largo
datos_largo <- tibble(
  id = rep(1:3, each = 3),
  año = rep(c("2020", "2021", "2022"), 3),
  peso = c(70, 72, 71, 65, 63, 64, 80, 81, 82)
)

# Mostramos los datos en formato largo
datos_largo

Ahora transformamos estos datos a formato ancho:

datos_ancho <- datos_largo %>%
  pivot_wider(
    names_from = año,       # Columna cuyos valores serán nombres de columnas
    values_from = peso      # Columna cuyos valores se distribuirán
  )

# Mostramos el resultado
datos_ancho

El resultado es una tabla donde cada año tiene su propia columna, y cada fila representa un individuo único identificado por su ID.

Ejemplo práctico con datos de ventas

Supongamos que tenemos datos de ventas en formato largo, donde cada fila representa las ventas de un producto en una región específica:

# Datos de ventas en formato largo
ventas_largo <- tibble(
  producto = rep(c("Laptop", "Teléfono", "Tablet"), each = 4),
  región = rep(c("Norte", "Sur", "Este", "Oeste"), 3),
  unidades = c(45, 32, 40, 38, 120, 105, 115, 95, 55, 48, 52, 50)
)

# Mostramos los datos
ventas_largo

Para crear una tabla que muestre los productos en las filas y las regiones en las columnas:

ventas_ancho <- ventas_largo %>%
  pivot_wider(
    names_from = región,
    values_from = unidades
  )

# Mostramos la tabla resultante
ventas_ancho

Esta representación facilita la comparación de ventas entre regiones para cada producto.

Manejo de valores múltiples

¿Qué sucede cuando hay múltiples valores para una combinación de variables? Por ejemplo, si tenemos varias mediciones para cada combinación de producto y región:

# Datos con mediciones múltiples
ventas_múltiples <- tibble(
  producto = rep(c("Laptop", "Teléfono"), each = 6),
  región = rep(c("Norte", "Sur", "Este"), times = 4),
  trimestre = rep(c("Q1", "Q2"), times = 6),
  unidades = c(45, 50, 32, 35, 40, 42, 120, 125, 105, 110, 115, 118)
)

# Mostramos los datos
ventas_múltiples

Si intentamos hacer un pivot_wider() simple, obtendremos un error porque hay valores duplicados. Para solucionarlo, podemos:

1. Usar una función de resumen con el parámetro values_fn:

# Usando la media como función de resumen
ventas_resumen <- ventas_múltiples %>%
  pivot_wider(
    names_from = región,
    values_from = unidades,
    values_fn = mean  # Calcula la media de los valores duplicados
  )

# Mostramos el resultado
ventas_resumen

2. Incluir otra variable en names_from para crear identificadores únicos:

# Combinando región y trimestre para crear nombres de columnas únicos
ventas_detalladas <- ventas_múltiples %>%
  pivot_wider(
    names_from = c(región, trimestre),
    values_from = unidades,
    names_sep = "_"  # Separador entre región y trimestre
  )

# Mostramos el resultado
ventas_detalladas

Personalización de nombres de columnas

Podemos personalizar cómo se generan los nombres de las nuevas columnas:

# Personalizando los nombres de columnas
ventas_personalizadas <- ventas_largo %>%
  pivot_wider(
    names_from = región,
    values_from = unidades,
    names_prefix = "Región_"  # Añade un prefijo a los nombres
  )

# Mostramos el resultado
ventas_personalizadas

También podemos usar names_glue para crear formatos más complejos:

# Usando glue para formatear nombres
ventas_formateadas <- ventas_largo %>%
  pivot_wider(
    names_from = región,
    values_from = unidades,
    names_glue = "Ventas_{región}"  # Formato personalizado
  )

# Mostramos el resultado
ventas_formateadas

Manejo de valores faltantes

Por defecto, pivot_wider() rellena con NA las combinaciones que no existen en los datos originales. Podemos cambiar este comportamiento con el parámetro values_fill:

# Datos con valores faltantes
ventas_incompletas <- tibble(
  producto = c("Laptop", "Laptop", "Teléfono", "Teléfono", "Tablet"),
  región = c("Norte", "Sur", "Norte", "Este", "Norte"),
  unidades = c(45, 32, 120, 115, 55)
)

# Transformación con valores de relleno personalizados
ventas_completas <- ventas_incompletas %>%
  pivot_wider(
    names_from = región,
    values_from = unidades,
    values_fill = 0  # Rellena con 0 en lugar de NA
  )

# Mostramos el resultado
ventas_completas

Múltiples columnas de valores

Podemos expandir múltiples columnas de valores simultáneamente:

# Datos con múltiples métricas
ventas_métricas <- tibble(
  producto = rep(c("Laptop", "Teléfono", "Tablet"), each = 2),
  región = rep(c("Norte", "Sur"), 3),
  unidades = c(45, 32, 120, 105, 55, 48),
  ingresos = c(45000, 32000, 60000, 52500, 22000, 19200)
)

# Expandiendo múltiples columnas de valores
ventas_completo <- ventas_métricas %>%
  pivot_wider(
    names_from = región,
    values_from = c(unidades, ingresos)
  )

# Mostramos el resultado
ventas_completo

El resultado tendrá columnas con nombres como unidades_Norte, unidades_Sur, ingresos_Norte, ingresos_Sur.

Aplicaciones prácticas

La transformación a formato ancho es especialmente útil para:

• Crear tablas de resumen para informes y presentaciones
• Preparar datos para análisis estadísticos que requieren variables en columnas separadas
• Generar matrices de correlación o mapas de calor
• Exportar datos en formatos más familiares para usuarios de hojas de cálculo

Por ejemplo, podemos crear fácilmente una tabla de contingencia:

# Datos de encuesta
encuesta <- tibble(
  id = 1:20,
  género = sample(c("Hombre", "Mujer"), 20, replace = TRUE),
  respuesta = sample(c("Sí", "No", "Tal vez"), 20, replace = TRUE)
)

# Creando una tabla de contingencia
tabla_contingencia <- encuesta %>%
  count(género, respuesta) %>%
  pivot_wider(
    names_from = respuesta,
    values_from = n,
    values_fill = 0
  )

# Mostramos la tabla
tabla_contingencia

Consejos para usar pivot_wider() eficientemente

• Identifica claramente qué columnas deben convertirse en nombres de columnas y cuáles contienen los valores a distribuir.

• Asegúrate de tener identificadores únicos para cada fila en el conjunto de datos resultante, o usa funciones de resumen para manejar duplicados.

• Considera el formato final que necesitas para tu análisis o visualización antes de decidir la estructura.

• Combina con otras funciones de dplyr como select(), mutate() o group_by() para preparar tus datos antes de la transformación.

# Ejemplo de flujo de trabajo completo
resultado_final <- ventas_largo %>%
  # Filtramos productos específicos
  filter(producto != "Tablet") %>%
  # Calculamos una métrica adicional
  mutate(valor = unidades * case_when(
    producto == "Laptop" ~ 1000,
    producto == "Teléfono" ~ 500,
    TRUE ~ 0
  )) %>%
  # Transformamos a formato ancho
  pivot_wider(
    names_from = región,
    values_from = c(unidades, valor)
  )

# Mostramos el resultado
resultado_final

La función pivot_wider() es una herramienta esencial en el arsenal de manipulación de datos en R, complementando perfectamente a pivot_longer() y permitiéndonos adaptar nuestros datos al formato más adecuado para cada situación de análisis.

Separación y unión de columnas (separate, unite)

Además de transformar datos entre formatos largo y ancho, a menudo necesitamos manipular el contenido de las columnas dividiéndolas o combinándolas. El paquete tidyr nos proporciona dos funciones fundamentales para estas operaciones: separate() y unite().

Separación de columnas con separate()

La función separate() nos permite dividir una columna en múltiples columnas basándose en un carácter separador o una posición específica. Esta función es extremadamente útil cuando tenemos datos compuestos almacenados en una sola columna.

Veamos un ejemplo básico:

library(tidyverse)

# Creamos un conjunto de datos con fechas en formato año-mes-día
datos_fechas <- tibble(
  id = 1:5,
  fecha = c("2022-01-15", "2022-02-20", "2022-03-10", "2022-04-05", "2022-05-12")
)

# Mostramos los datos originales
datos_fechas

Ahora separamos la columna fecha en tres componentes:

datos_separados <- datos_fechas %>%
  separate(
    col = fecha,                # Columna a separar
    into = c("año", "mes", "día"),  # Nuevas columnas a crear
    sep = "-"                   # Carácter separador
  )

# Mostramos el resultado
datos_separados

Por defecto, separate() convierte las nuevas columnas a caracteres. Si queremos convertirlas a otros tipos de datos, podemos usar el parámetro convert:

datos_convertidos <- datos_fechas %>%
  separate(
    col = fecha,
    into = c("año", "mes", "día"),
    sep = "-",
    convert = TRUE  # Convierte automáticamente a tipos apropiados (numéricos)
  )

datos_convertidos

Separación por posición

También podemos separar una columna basándonos en posiciones específicas:

# Datos con códigos de producto
productos <- tibble(
  código = c("ABC123", "DEF456", "GHI789", "JKL012"),
  precio = c(29.99, 49.99, 19.99, 39.99)
)

# Separamos el código en categoría (letras) y número (dígitos)
productos_separados <- productos %>%
  separate(
    col = código,
    into = c("categoría", "número"),
    sep = 3  # Separar después del tercer carácter
  )

productos_separados

Mantener la columna original

Si queremos mantener la columna original después de la separación, podemos usar el parámetro remove = FALSE:

datos_completos <- datos_fechas %>%
  separate(
    col = fecha,
    into = c("año", "mes", "día"),
    sep = "-",
    convert = TRUE,
    remove = FALSE  # Mantiene la columna original
  )

datos_completos

Manejo de valores faltantes

Cuando una columna no tiene suficientes partes para separar, separate() genera valores NA. Podemos controlar este comportamiento con el parámetro fill:

# Datos con formatos inconsistentes
datos_mixtos <- tibble(
  id = 1:3,
  información = c("Smith,John,45", "Johnson,Mary", "Brown,Robert,38")
)

# Separamos con manejo de valores faltantes
datos_separados_fill <- datos_mixtos %>%
  separate(
    col = información,
    into = c("apellido", "nombre", "edad"),
    sep = ",",
    fill = "right"  # Opciones: "right", "left", "none"
  )

datos_separados_fill

Unión de columnas con unite()

La función unite() realiza la operación inversa a separate(), combinando múltiples columnas en una sola. Esta función es particularmente útil para crear identificadores compuestos o reformatear datos.

Veamos un ejemplo básico:

# Datos con componentes de fecha separados
fechas_separadas <- tibble(
  id = 1:5,
  año = c(2022, 2022, 2022, 2022, 2022),
  mes = c(1, 2, 3, 4, 5),
  día = c(15, 20, 10, 5, 12)
)

# Unimos las columnas para formar fechas
fechas_unidas <- fechas_separadas %>%
  unite(
    col = "fecha",           # Nombre de la nueva columna
    c(año, mes, día),        # Columnas a unir
    sep = "-"                # Separador a usar
  )

fechas_unidas

Formateo de valores

Por defecto, unite() convierte todos los valores a caracteres. Si queremos asegurarnos de que los números tengan un formato específico (como añadir ceros a la izquierda), podemos usar mutate() antes de unir:

fechas_formateadas <- fechas_separadas %>%
  mutate(
    mes = sprintf("%02d", mes),  # Formato de dos dígitos con cero a la izquierda
    día = sprintf("%02d", día)
  ) %>%
  unite(
    col = "fecha",
    c(año, mes, día),
    sep = "-"
  )

fechas_formateadas

Mantener las columnas originales

Si queremos mantener las columnas originales después de la unión, usamos el parámetro remove = FALSE:

datos_completos_unite <- fechas_separadas %>%
  unite(
    col = "fecha",
    c(año, mes, día),
    sep = "-",
    remove = FALSE  # Mantiene las columnas originales
  )

datos_completos_unite

Aplicaciones prácticas

Limpieza de datos de encuestas

Supongamos que tenemos datos de una encuesta donde los nombres están en formato "Apellido, Nombre":

# Datos de encuesta
encuesta <- tibble(
  id = 1:4,
  nombre_completo = c("García, Ana", "López, Carlos", "Martínez, Elena", "Rodríguez, Juan"),
  puntuación = c(85, 92, 78, 88)
)

# Separamos el nombre completo
encuesta_procesada <- encuesta %>%
  separate(
    col = nombre_completo,
    into = c("apellido", "nombre"),
    sep = ", "
  )

encuesta_procesada

Procesamiento de direcciones

Podemos separar y luego unir direcciones con un formato diferente:

# Datos de direcciones
direcciones <- tibble(
  id = 1:3,
  dirección = c("Calle Mayor 25, 28001 Madrid", 
                "Avenida Diagonal 500, 08006 Barcelona",
                "Plaza Nueva 1, 41001 Sevilla")
)

# Procesamos las direcciones
direcciones_procesadas <- direcciones %>%
  # Separamos la dirección en calle y código postal + ciudad
  separate(
    col = dirección,
    into = c("calle_número", "cp_ciudad"),
    sep = ", "
  ) %>%
  # Separamos el código postal y la ciudad
  separate(
    col = cp_ciudad,
    into = c("código_postal", "ciudad"),
    sep = " ",
    extra = "merge"  # Mantiene juntas las palabras adicionales (para ciudades con espacios)
  )

direcciones_procesadas

Creación de identificadores compuestos

Podemos crear identificadores únicos combinando múltiples columnas:

# Datos de estudiantes
estudiantes <- tibble(
  nombre = c("Ana", "Carlos", "Elena", "Juan"),
  curso = c("1A", "2B", "1A", "3C"),
  año = c(2022, 2022, 2022, 2022)
)

# Creamos un ID único
estudiantes_con_id <- estudiantes %>%
  unite(
    col = "id_estudiante",
    c(curso, año, nombre),
    sep = "_",
    remove = FALSE  # Mantenemos las columnas originales
  )

estudiantes_con_id

Combinando separate() y unite() con pivot_longer() y pivot_wider()

Estas funciones se complementan perfectamente con las transformaciones de formato que vimos anteriormente:

# Datos de ventas trimestrales
ventas_trim <- tibble(
  producto = c("Laptop", "Teléfono", "Tablet"),
  Q1_2022 = c(120, 340, 90),
  Q2_2022 = c(110, 290, 105),
  Q3_2022 = c(130, 310, 115),
  Q4_2022 = c(150, 380, 125)
)

# Transformación completa
ventas_procesadas <- ventas_trim %>%
  # Convertimos a formato largo
  pivot_longer(
    cols = -producto,
    names_to = "periodo",
    values_to = "unidades"
  ) %>%
  # Separamos el periodo en trimestre y año
  separate(
    col = periodo,
    into = c("trimestre", "año"),
    sep = "_"
  ) %>%
  # Ordenamos por producto y año-trimestre
  arrange(producto, año, trimestre)

ventas_procesadas

Función separate_rows()

Una variante útil es separate_rows(), que divide una celda en múltiples filas en lugar de múltiples columnas:

# Datos con múltiples valores en una celda
productos_múltiples <- tibble(
  cliente = c("Cliente1", "Cliente2", "Cliente3"),
  productos_comprados = c("Laptop, Teléfono", "Tablet", "Auriculares, Cargador, Funda")
)

# Separamos en múltiples filas
compras_detalladas <- productos_múltiples %>%
  separate_rows(
    productos_comprados,
    sep = ", "
  )

compras_detalladas

Consejos prácticos

• Inspecciona tus datos antes de usar separate() para asegurarte de que el separador es consistente en todas las filas.

• Usa extra y fill para manejar casos donde el número de partes varía entre filas:

• extra = "warn" (por defecto): advierte sobre partes adicionales
• extra = "drop": descarta partes adicionales
• extra = "merge": combina partes adicionales en la última columna

• Considera el tipo de datos de las columnas resultantes y usa convert = TRUE o mutate() para asegurar el formato correcto.

• Combina estas funciones con otras herramientas de dplyr y tidyr para crear flujos de trabajo eficientes de limpieza y transformación de datos.

Las funciones separate() y unite() son herramientas fundamentales en el ecosistema tidyverse que complementan perfectamente las capacidades de reestructuración de datos que ofrecen pivot_longer() y pivot_wider(). Dominar estas funciones te permitirá manipular tus datos con precisión y flexibilidad para adaptarlos a tus necesidades de análisis.