Tutorial R: mutate y transmute para transformación

Creación de columnas con mutate()

La función mutate() del paquete dplyr es una herramienta fundamental para transformar datos en R. Esta función nos permite crear nuevas columnas en un data frame o modificar columnas existentes, manteniendo todas las filas originales.

Fundamentos de mutate()

La función mutate() opera sobre un data frame y devuelve otro data frame con las mismas filas pero con columnas adicionales o modificadas. Su sintaxis básica es:

mutate(data, nueva_columna = expresión)

Donde:

• data es el data frame que queremos modificar
• nueva_columna es el nombre de la columna que queremos crear
• expresión es el cálculo que define el contenido de la nueva columna

Veamos un ejemplo sencillo:

# Cargar la librería dplyr
library(dplyr)

# Crear un data frame de ejemplo
estudiantes <- data.frame(
  nombre = c("Ana", "Carlos", "Elena", "David"),
  nota_parcial = c(7.5, 6.8, 9.2, 5.4),
  nota_final = c(8.1, 7.2, 9.5, 6.0)
)

# Crear una nueva columna con la nota media
estudiantes_con_media <- mutate(estudiantes, 
                               nota_media = (nota_parcial + nota_final) / 2)

# Visualizar el resultado
estudiantes_con_media

En este ejemplo, hemos creado una nueva columna llamada nota_media que contiene el promedio de las notas parcial y final para cada estudiante.

Creación de múltiples columnas

Una de las ventajas de mutate() es que podemos crear varias columnas en una sola llamada a la función, separando cada definición con comas:

# Crear múltiples columnas nuevas
estudiantes_ampliado <- mutate(estudiantes,
                              nota_media = (nota_parcial + nota_final) / 2,
                              aprobado = nota_media >= 5,
                              diferencia = nota_final - nota_parcial)

# Visualizar el resultado
estudiantes_ampliado

Este código crea tres columnas nuevas:

• nota_media: el promedio de las dos notas
• aprobado: un valor lógico (TRUE/FALSE) que indica si el estudiante ha aprobado
• diferencia: cuánto ha mejorado (o empeorado) el estudiante entre el parcial y el final

Uso de mutate() con el operador pipe

El operador pipe (%>%) de dplyr nos permite encadenar operaciones de forma más legible. Esto es especialmente útil cuando realizamos múltiples transformaciones:

# Usando el operador pipe
estudiantes %>%
  mutate(nota_media = (nota_parcial + nota_final) / 2) %>%
  mutate(rendimiento = if_else(nota_media > 8, "Alto", "Normal"))

Este enfoque hace que el código sea más fácil de leer y mantener, especialmente en análisis de datos complejos.

Operaciones vectorizadas en mutate()

La función mutate() trabaja con operaciones vectorizadas, lo que significa que aplica la misma operación a cada fila del data frame. Podemos usar funciones matemáticas, lógicas y de texto:

# Ejemplo con diferentes tipos de operaciones
datos <- data.frame(
  valor = c(10, 25, 8, 16),
  texto = c("a", "b", "c", "d")
)

datos %>%
  mutate(
    doble = valor * 2,                    # Operación matemática
    raiz = sqrt(valor),                   # Función matemática
    mayor_que_15 = valor > 15,            # Operación lógica
    texto_mayus = toupper(texto)          # Función de texto
  )

Uso de funciones de dplyr dentro de mutate()

Podemos combinar mutate() con otras funciones de dplyr para crear transformaciones más complejas:

# Datos de ventas mensuales
ventas <- data.frame(
  producto = c("A", "B", "C", "D"),
  enero = c(150, 200, 120, 80),
  febrero = c(160, 210, 140, 90),
  marzo = c(180, 205, 130, 100)
)

# Calcular estadísticas por producto
ventas %>%
  mutate(
    total_trimestre = enero + febrero + marzo,
    promedio_mensual = (enero + febrero + marzo) / 3,
    mejor_mes = pmax(enero, febrero, marzo)
  )

En este ejemplo, pmax() es una función vectorizada que devuelve el valor máximo entre varios vectores, elemento por elemento.

Modificación de columnas existentes

Además de crear nuevas columnas, mutate() también puede modificar columnas existentes:

# Convertir temperaturas de Celsius a Fahrenheit
temperaturas <- data.frame(
  ciudad = c("Madrid", "Barcelona", "Sevilla", "Bilbao"),
  temp_celsius = c(22, 24, 30, 18)
)

temperaturas %>%
  mutate(temp_celsius = temp_celsius + 273.15,  # Convertir a Kelvin
         temp_fahrenheit = (temp_celsius - 273.15) * 9/5 + 32)

Observa cómo primero modificamos la columna temp_celsius y luego usamos ese valor actualizado para calcular temp_fahrenheit.

Uso de mutate() con funciones personalizadas

También podemos usar nuestras propias funciones dentro de mutate():

# Función personalizada para calcular el IMC
calcular_imc <- function(peso, altura) {
  peso / (altura/100)^2
}

# Datos de pacientes
pacientes <- data.frame(
  nombre = c("Juan", "María", "Pedro", "Lucía"),
  peso = c(75, 62, 85, 58),
  altura = c(178, 165, 182, 160)
)

# Calcular IMC usando la función personalizada
pacientes %>%
  mutate(imc = calcular_imc(peso, altura),
         categoria = case_when(
           imc < 18.5 ~ "Bajo peso",
           imc < 25 ~ "Normal",
           imc < 30 ~ "Sobrepeso",
           TRUE ~ "Obesidad"
         ))

Este ejemplo muestra cómo podemos combinar funciones personalizadas con mutate() para crear transformaciones más complejas.

Consideraciones prácticas

Al trabajar con mutate(), es importante tener en cuenta algunas consideraciones:

• Las operaciones se ejecutan en el orden en que aparecen, por lo que podemos usar columnas recién creadas en cálculos posteriores.
• Las transformaciones son vectorizadas, lo que significa que R aplica la operación a cada elemento del vector de forma eficiente.
• Si queremos conservar solo las nuevas columnas, deberíamos usar transmute() en lugar de mutate().
• Para transformaciones condicionales más complejas, podemos combinar mutate() con case_when().

# Ejemplo de uso práctico con datos reales
library(dplyr)

# Supongamos que tenemos datos de ventas
ventas_mensuales <- data.frame(
  producto = c("A", "B", "C", "A", "B", "C"),
  mes = c("Enero", "Enero", "Enero", "Febrero", "Febrero", "Febrero"),
  unidades = c(120, 85, 63, 140, 90, 70),
  precio_unitario = c(25, 50, 30, 25, 52, 30)
)

# Transformar los datos
ventas_mensuales %>%
  mutate(
    ingresos = unidades * precio_unitario,
    impuesto = ingresos * 0.21,
    ingreso_neto = ingresos - impuesto,
    rendimiento = if_else(ingresos > 3000, "Alto", "Normal")
  )

Este ejemplo muestra cómo podemos encadenar varias transformaciones para realizar un análisis completo de datos de ventas, calculando ingresos, impuestos y clasificando el rendimiento.

Transformaciones condicionales con case_when()

Cuando trabajamos con datos, a menudo necesitamos aplicar transformaciones condicionales basadas en múltiples criterios. La función case_when() de dplyr nos proporciona una forma elegante y potente de realizar estas operaciones, similar a las estructuras CASE en SQL o a múltiples declaraciones IF-ELSE anidadas en otros lenguajes.

case_when() es especialmente útil cuando necesitamos crear nuevas variables basadas en condiciones complejas, y funciona perfectamente dentro de mutate() para aplicar estas transformaciones a nuestros data frames.

Sintaxis básica

La sintaxis de case_when() sigue un patrón de condición ~ resultado:

case_when(
  condición1 ~ resultado1,
  condición2 ~ resultado2,
  condición3 ~ resultado3,
  TRUE ~ resultado_por_defecto
)

Cada condición se evalúa en orden, y cuando una condición es TRUE, se devuelve el resultado correspondiente. Si ninguna condición se cumple, se utiliza el valor asociado con TRUE como valor predeterminado.

Veamos un ejemplo sencillo:

library(dplyr)

# Crear un data frame de ejemplo
calificaciones <- data.frame(
  estudiante = c("Ana", "Bruno", "Carmen", "David", "Elena"),
  puntuacion = c(85, 62, 91, 45, 78)
)

# Asignar letras según la puntuación
calificaciones %>%
  mutate(
    nota = case_when(
      puntuacion >= 90 ~ "A",
      puntuacion >= 80 ~ "B",
      puntuacion >= 70 ~ "C",
      puntuacion >= 60 ~ "D",
      TRUE ~ "F"
    )
  )

En este ejemplo, cada estudiante recibe una nota según su puntuación. Las condiciones se evalúan en orden, por lo que un estudiante con 91 puntos recibirá una "A", no una "B", aunque técnicamente también cumple la condición puntuacion >= 80.

Múltiples condiciones y operadores lógicos

Podemos crear condiciones más complejas utilizando operadores lógicos como & (AND), | (OR) y ! (NOT):

# Datos de empleados
empleados <- data.frame(
  nombre = c("Juan", "María", "Carlos", "Laura", "Pedro"),
  departamento = c("Ventas", "Marketing", "Ventas", "IT", "Marketing"),
  años_servicio = c(3, 7, 2, 5, 10),
  salario = c(28000, 45000, 25000, 50000, 60000)
)

# Clasificar empleados según múltiples criterios
empleados %>%
  mutate(
    categoria = case_when(
      departamento == "Ventas" & salario > 30000 ~ "Ventas Premium",
      departamento == "Ventas" ~ "Ventas Regular",
      departamento == "Marketing" & años_servicio >= 8 ~ "Marketing Senior",
      departamento == "Marketing" ~ "Marketing Junior",
      departamento == "IT" & salario >= 45000 ~ "IT Avanzado",
      TRUE ~ "Otro"
    )
  )

Este ejemplo muestra cómo podemos combinar diferentes condiciones para crear categorías más específicas.

Trabajando con diferentes tipos de datos

Una ventaja importante de case_when() es que puede manejar diferentes tipos de datos en las condiciones, pero los resultados deben ser del mismo tipo:

# Datos de productos
productos <- data.frame(
  id = 1:5,
  nombre = c("Laptop", "Smartphone", "Tablet", "Monitor", "Teclado"),
  precio = c(1200, 800, 350, 250, 45),
  stock = c(15, 30, 10, 5, 50)
)

# Clasificar productos según diferentes criterios
productos %>%
  mutate(
    estado = case_when(
      precio > 1000 ~ "Premium",
      stock < 10 ~ "Stock bajo",
      nombre %in% c("Smartphone", "Tablet") ~ "Dispositivo móvil",
      TRUE ~ "Regular"
    ),
    prioridad_reposicion = case_when(
      stock <= 5 ~ 1,
      stock <= 15 ~ 2,
      stock <= 30 ~ 3,
      TRUE ~ 4
    )
  )

En este ejemplo, creamos dos nuevas columnas: estado (texto) y prioridad_reposicion (numérica), cada una basada en diferentes condiciones.

Uso con fechas y valores temporales

case_when() también es útil para trabajar con fechas y valores temporales:

library(lubridate)  # Para manejo de fechas

# Datos de pedidos
pedidos <- data.frame(
  id = 1:5,
  fecha = as.Date(c("2023-01-15", "2023-02-20", "2023-03-05", 
                    "2023-04-10", "2023-05-25")),
  monto = c(120, 350, 80, 200, 500)
)

# Clasificar pedidos por trimestre y tamaño
pedidos %>%
  mutate(
    trimestre = case_when(
      month(fecha) <= 3 ~ "Q1",
      month(fecha) <= 6 ~ "Q2",
      month(fecha) <= 9 ~ "Q3",
      TRUE ~ "Q4"
    ),
    tamaño_pedido = case_when(
      monto < 100 ~ "Pequeño",
      monto < 300 ~ "Mediano",
      monto < 500 ~ "Grande",
      TRUE ~ "VIP"
    )
  )

Este ejemplo muestra cómo podemos extraer información de fechas (como el mes) y usarla en nuestras condiciones.

Manejo de valores NA

El manejo de valores NA (datos faltantes) es una consideración importante cuando usamos case_when(). Por defecto, si una condición evalúa a NA, el resultado también será NA:

# Datos con valores NA
datos_incompletos <- data.frame(
  id = 1:5,
  valor_a = c(10, NA, 30, 40, NA),
  valor_b = c(5, 15, NA, 25, 35)
)

# Manejo de NA en case_when
datos_incompletos %>%
  mutate(
    categoria = case_when(
      is.na(valor_a) | is.na(valor_b) ~ "Datos incompletos",
      valor_a > valor_b ~ "A mayor que B",
      valor_a < valor_b ~ "B mayor que A",
      TRUE ~ "Valores iguales"
    ),
    suma = case_when(
      !is.na(valor_a) & !is.na(valor_b) ~ valor_a + valor_b,
      !is.na(valor_a) ~ valor_a,
      !is.na(valor_b) ~ valor_b,
      TRUE ~ NA_real_
    )
  )

En este ejemplo, manejamos explícitamente los valores NA en nuestras condiciones para asegurarnos de que los resultados sean los esperados.

Comparación con if_else() y recode()

Aunque case_when() es muy versátil, a veces otras funciones pueden ser más apropiadas:

• if_else(): Para condiciones simples con solo dos resultados posibles
• recode(): Para mapear valores específicos a nuevos valores

# Ejemplo comparativo
datos <- data.frame(
  valor = c(1, 2, 3, 4, 5),
  grupo = c("A", "B", "A", "C", "B")
)

datos %>%
  mutate(
    # Usando case_when para condiciones complejas
    categoria = case_when(
      valor < 3 & grupo == "A" ~ "Bajo A",
      valor < 3 & grupo == "B" ~ "Bajo B",
      valor >= 3 & grupo == "A" ~ "Alto A",
      valor >= 3 & grupo == "B" ~ "Alto B",
      TRUE ~ "Otro"
    ),
    
    # Usando if_else para condición simple
    es_par = if_else(valor %% 2 == 0, "Par", "Impar"),
    
    # Usando recode para mapeo directo
    grupo_nuevo = recode(grupo,
                         "A" = "Grupo 1",
                         "B" = "Grupo 2",
                         "C" = "Grupo 3")
  )

Este ejemplo muestra cuándo podría ser más apropiado usar cada función según la complejidad de la transformación.

Aplicaciones prácticas

Veamos algunos casos de uso comunes de case_when() en análisis de datos:

# Datos de ventas
ventas <- data.frame(
  producto = c("A", "B", "C", "D", "E"),
  unidades = c(120, 85, 200, 45, 300),
  region = c("Norte", "Sur", "Norte", "Este", "Oeste"),
  canal = c("Online", "Tienda", "Online", "Tienda", "Online")
)

# Análisis con case_when
ventas %>%
  mutate(
    # Categorizar por volumen
    volumen = case_when(
      unidades < 50 ~ "Bajo",
      unidades < 100 ~ "Medio",
      unidades < 250 ~ "Alto",
      TRUE ~ "Muy alto"
    ),
    
    # Prioridad de marketing
    prioridad_marketing = case_when(
      canal == "Online" & unidades < 100 ~ "Alta",
      canal == "Tienda" & region == "Sur" ~ "Media",
      unidades > 250 ~ "Baja",
      TRUE ~ "Normal"
    ),
    
    # Calcular bonificación
    bonificacion = case_when(
      unidades >= 250 ~ unidades * 0.05,
      unidades >= 100 & canal == "Online" ~ unidades * 0.03,
      unidades >= 100 & canal == "Tienda" ~ unidades * 0.02,
      TRUE ~ 0
    )
  )

Este ejemplo muestra cómo case_when() puede ser utilizado para crear categorías, establecer prioridades y realizar cálculos condicionales en un contexto de análisis de ventas.

case_when() es una herramienta extremadamente versátil para transformaciones condicionales en R, permitiéndonos implementar lógica compleja de manera clara y concisa dentro de nuestros flujos de trabajo de manipulación de datos.

transmute() para transformaciones selectivas

Cuando trabajamos con datos en R, a menudo necesitamos crear nuevas variables a partir de las existentes, pero no siempre queremos conservar todas las columnas originales. La función transmute() del paquete dplyr nos permite realizar transformaciones y seleccionar específicamente qué columnas mantener en un solo paso.

Fundamentos de transmute()

La función transmute() es similar a mutate(), pero con una diferencia clave: mientras que mutate() conserva todas las columnas originales además de las nuevas, transmute() solo mantiene las columnas que creamos explícitamente. Su sintaxis básica es:

transmute(data, nueva_columna1 = expresión1, nueva_columna2 = expresión2, ...)

Veamos un ejemplo sencillo para entender esta diferencia:

library(dplyr)

# Crear un data frame de ejemplo
productos <- data.frame(
  id = 1:4,
  nombre = c("Laptop", "Teléfono", "Tablet", "Monitor"),
  costo = c(500, 300, 200, 150),
  precio = c(800, 500, 350, 250)
)

# Usando mutate() - mantiene todas las columnas
productos_mutate <- productos %>%
  mutate(margen = precio - costo)

# Usando transmute() - solo mantiene las columnas especificadas
productos_transmute <- productos %>%
  transmute(nombre, margen = precio - costo)

# Comparar resultados
productos_mutate
productos_transmute

En este ejemplo, productos_mutate contiene todas las columnas originales (id, nombre, costo, precio) más la nueva columna margen. En cambio, productos_transmute solo contiene las columnas nombre y margen.

Cuándo usar transmute()

La función transmute() es especialmente útil en los siguientes escenarios:

• Cuando necesitamos extraer información específica de un conjunto de datos más grande
• Para simplificar datos eliminando columnas innecesarias
• Al crear tablas intermedias para análisis posteriores
• Para preparar datos antes de exportarlos a otros sistemas

# Datos de ventas mensuales
ventas <- data.frame(
  producto = c("A", "B", "C", "D"),
  unidades = c(120, 85, 200, 45),
  precio_unitario = c(10, 15, 8, 25),
  costo_unitario = c(6, 9, 5, 15),
  gastos_marketing = c(200, 300, 150, 100)
)

# Extraer solo información de rentabilidad
rentabilidad <- ventas %>%
  transmute(
    producto,
    ingresos = unidades * precio_unitario,
    costos = unidades * costo_unitario + gastos_marketing,
    beneficio = ingresos - costos,
    margen = round((beneficio / ingresos) * 100, 1)
  )

rentabilidad

En este ejemplo, hemos transformado un conjunto de datos de ventas en un análisis de rentabilidad, conservando solo la información relevante para este propósito.

Combinando columnas existentes y nuevas

Con transmute() podemos incluir tanto columnas existentes como nuevas columnas calculadas:

# Datos de estudiantes
estudiantes <- data.frame(
  id = 1:5,
  nombre = c("Ana", "Bruno", "Carmen", "David", "Elena"),
  matematicas = c(85, 70, 92, 65, 78),
  ciencias = c(90, 65, 88, 72, 81),
  literatura = c(75, 82, 90, 68, 85)
)

# Extraer información relevante para un informe
informe_estudiantes <- estudiantes %>%
  transmute(
    nombre,
    promedio = (matematicas + ciencias + literatura) / 3,
    mejor_materia = case_when(
      matematicas > ciencias & matematicas > literatura ~ "Matemáticas",
      ciencias > matematicas & ciencias > literatura ~ "Ciencias",
      TRUE ~ "Literatura"
    )
  )

informe_estudiantes

Este código genera un informe simplificado que solo incluye el nombre del estudiante, su promedio general y su mejor materia.

Transformaciones con funciones de agregación

Aunque transmute() opera a nivel de fila, podemos combinarla con funciones de agregación para crear transformaciones más complejas:

# Datos de temperaturas mensuales
temperaturas <- data.frame(
  ciudad = c("Madrid", "Barcelona", "Sevilla", "Madrid", "Barcelona", "Sevilla"),
  mes = c("Enero", "Enero", "Enero", "Febrero", "Febrero", "Febrero"),
  min = c(2, 5, 6, 3, 6, 8),
  max = c(12, 14, 16, 14, 15, 18)
)

# Extraer información de amplitud térmica
amplitud_termica <- temperaturas %>%
  transmute(
    ciudad, 
    mes,
    temperatura_media = (min + max) / 2,
    amplitud = max - min,
    categoria = if_else(amplitud > 10, "Alta variación", "Estable")
  )

amplitud_termica

Este ejemplo muestra cómo podemos calcular la temperatura media y la amplitud térmica, conservando solo las variables relevantes para nuestro análisis.

Uso de transmute() con operaciones vectorizadas

Al igual que mutate(), transmute() funciona con operaciones vectorizadas, lo que nos permite aplicar transformaciones eficientes a todas las filas:

# Datos de productos
inventario <- data.frame(
  codigo = c("A001", "B002", "C003", "D004"),
  stock_actual = c(120, 85, 30, 200),
  stock_minimo = c(50, 40, 20, 100),
  tiempo_reposicion = c(5, 3, 7, 4)  # días
)

# Análisis de reposición
analisis_reposicion <- inventario %>%
  transmute(
    codigo,
    dias_disponibles = round(stock_actual / (stock_minimo / 2)),
    necesita_pedido = stock_actual < stock_minimo * 1.5,
    urgencia = case_when(
      stock_actual <= stock_minimo ~ "Alta",
      stock_actual <= stock_minimo * 2 ~ "Media",
      TRUE ~ "Baja"
    )
  )

analisis_reposicion

En este ejemplo, hemos creado un análisis de reposición que incluye solo la información relevante para la toma de decisiones sobre nuevos pedidos.

Combinando transmute() con otras funciones de dplyr

transmute() se integra perfectamente con otras funciones de dplyr, lo que nos permite crear flujos de trabajo más complejos:

# Datos de ventas por región
ventas_regionales <- data.frame(
  region = c("Norte", "Sur", "Este", "Oeste", "Norte", "Sur", "Este", "Oeste"),
  producto = c("A", "A", "A", "A", "B", "B", "B", "B"),
  unidades = c(120, 85, 95, 110, 80, 120, 70, 90),
  precio = c(10, 10, 10, 10, 15, 15, 15, 15)
)

# Análisis de ventas por región y producto
ventas_regionales %>%
  # Primero filtramos
  filter(unidades > 80) %>%
  # Luego transformamos selectivamente
  transmute(
    region,
    producto,
    ingresos = unidades * precio,
    porcentaje_objetivo = round((unidades / 100) * 100)
  ) %>%
  # Finalmente ordenamos
  arrange(desc(ingresos))

Este ejemplo muestra cómo podemos combinar filter(), transmute() y arrange() para crear un flujo de trabajo completo de análisis de datos.

Comparación entre select(), mutate() y transmute()

Para entender mejor cuándo usar transmute(), es útil compararlo con otras funciones de dplyr:

# Datos de ejemplo
datos <- data.frame(
  id = 1:3,
  valor_a = c(10, 20, 30),
  valor_b = c(5, 15, 25)
)

# select() - solo selecciona columnas existentes
datos %>% select(id, valor_a)

# mutate() - mantiene todas las columnas y añade nuevas
datos %>% mutate(suma = valor_a + valor_b)

# transmute() - solo mantiene las columnas especificadas
datos %>% transmute(id, suma = valor_a + valor_b)

• select(): Selecciona columnas existentes sin modificarlas
• mutate(): Mantiene todas las columnas originales y añade nuevas columnas calculadas
• transmute(): Solo mantiene las columnas que especificamos explícitamente (existentes o nuevas)

Aplicaciones prácticas

Veamos algunos casos de uso prácticos donde transmute() resulta especialmente útil:

# Datos de una encuesta
encuesta <- data.frame(
  id = 1:5,
  edad = c(25, 34, 42, 19, 56),
  ingresos = c(28000, 45000, 52000, 18000, 65000),
  satisfaccion_1 = c(4, 3, 5, 2, 4),  # Escala 1-5
  satisfaccion_2 = c(3, 4, 5, 3, 4),
  satisfaccion_3 = c(5, 3, 4, 2, 5)
)

# Preparar datos para análisis estadístico
datos_analisis <- encuesta %>%
  transmute(
    grupo_edad = case_when(
      edad < 25 ~ "18-24",
      edad < 35 ~ "25-34",
      edad < 45 ~ "35-44",
      edad < 55 ~ "45-54",
      TRUE ~ "55+"
    ),
    nivel_ingresos = case_when(
      ingresos < 20000 ~ "Bajo",
      ingresos < 40000 ~ "Medio-bajo",
      ingresos < 60000 ~ "Medio-alto",
      TRUE ~ "Alto"
    ),
    satisfaccion_media = (satisfaccion_1 + satisfaccion_2 + satisfaccion_3) / 3,
    satisfaccion_alta = satisfaccion_media >= 4
  )

datos_analisis

En este ejemplo, hemos transformado datos detallados de una encuesta en categorías más adecuadas para un análisis estadístico, conservando solo la información relevante.

Consideraciones al usar transmute()

Al trabajar con transmute(), es importante tener en cuenta:

• Si necesitas mantener alguna columna original, debes incluirla explícitamente
• Las columnas aparecerán en el orden en que las especifiques
• Puedes usar columnas recién creadas en cálculos posteriores dentro de la misma llamada a transmute()
• Si solo necesitas seleccionar columnas sin transformarlas, select() puede ser más apropiado

# Ejemplo de transformación progresiva
datos_financieros <- data.frame(
  empresa = c("A", "B", "C", "D"),
  ingresos = c(1200000, 850000, 2300000, 750000),
  costos = c(800000, 650000, 1700000, 600000),
  impuestos = c(120000, 60000, 180000, 45000)
)

# Análisis financiero simplificado
datos_financieros %>%
  transmute(
    empresa,
    beneficio_bruto = ingresos - costos,
    margen_bruto = round((beneficio_bruto / ingresos) * 100, 1),
    beneficio_neto = beneficio_bruto - impuestos,
    margen_neto = round((beneficio_neto / ingresos) * 100, 1)
  )

Este ejemplo muestra cómo podemos usar valores calculados (como beneficio_bruto) en cálculos posteriores dentro de la misma llamada a transmute().

La función transmute() es una herramienta poderosa para transformaciones selectivas de datos, permitiéndonos crear exactamente las variables que necesitamos sin acumular columnas innecesarias, lo que resulta en flujos de trabajo más limpios y eficientes en nuestros análisis de datos.