Programación funcional en R, vectorización en R, Aplicar funciones en R, Familia apply en R, Operaciones vectorizadas en R
La programación funcional en R es un poderoso paradigma que se centra en el procesamiento de datos de manera eficiente a través de funciones. Al aprovechar las funciones de aplicación incorporadas de R y las operaciones vectorizadas, puede escribir código más conciso, legible y rápido, a menudo eliminando la necesidad de bucles explícitos. Este tutorial le presentará las funciones clave (lapply() y sapply()) de la familia apply, demostrará las operaciones vectorizadas y proporcionará ejemplos adicionales utilizando apply(), tapply(), mapply() y vapply(). Estas técnicas le ayudarán a escribir código R elegante y eficiente.
R proporciona una variedad de funciones que le ayudan a aplicar operaciones sobre colecciones de datos sin recurrir a bucles. Estas funciones incluyen:
apply(): Aplica una función a los márgenes de una matriz.lapply(): Devuelve una lista aplicando una función sobre una lista o vector.sapply(): Una versión fácil de usar de lapply() que simplifica la salida.vapply(): Similar a sapply() pero requiere especificar el tipo de salida.tapply(): Aplica una función sobre subconjuntos de un vector, categorizados por un factor.mapply(): Versión multivariante de lapply(), aplicando una función en paralelo sobre un conjunto de argumentos.lapply() y sapply()# Crear una lista de vectores numéricos
num_list <- list(a = 1:5, b = 6:10, c = 11:15)
# Utilizar `lapply` para calcular la media de cada vector (devuelve una lista)
means_list <- lapply(num_list, mean)
print(means_list)$a
[1] 3
$b
[1] 8
$c
[1] 13# Utilizar `sapply` para calcular la media (se simplifica a un vector)
means_vector <- sapply(num_list, mean)
print(means_vector) a b c
3 8 13 Las operaciones vectoriales en R le permiten realizar operaciones de elemento a elemento en vectores o matrices enteras sin bucles explícitos. Este enfoque suele ser más rápido y conciso.
# Crear un vector numérico
x <- 1:10
# Multiplica cada elemento por 2 utilizando la multiplicación vectorizada
y <- x * 2
print(y) [1] 2 4 6 8 10 12 14 16 18 20# Calcular la raíz cuadrada de cada elemento
sqrt_values <- sqrt(x)
print(sqrt_values) [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427
[9] 3.000000 3.162278Para aprovechar al máximo la potencia de la familia apply de R, considere estas funciones adicionales:
apply()La función apply() se utiliza normalmente con matrices o arrays para aplicar una función sobre filas o columnas.
# Crear una matriz 3x3
matrix_data <- matrix(1:9, nrow = 3, ncol = 3)
print(matrix_data) [,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9# Sumar cada fila (`margin = 1`)
row_sums <- apply(matrix_data, 1, sum)
print(row_sums)[1] 12 15 18# Suma cada columna (`margin = 2`)
col_sums <- apply(matrix_data, 2, sum)
print(col_sums)[1] 6 15 24tapply()La función tapply() aplica una función a subconjuntos de un vector, definidos por un factor, lo que resulta útil para operaciones agrupadas.
#|label: tapply-example
# Ejemplo de vector de edades y un factor de agrupación
ages <- c(23, 35, 27, 45, 31, 29)
groups <- factor(c("A", "B", "A", "B", "A", "B"))
# Calcular la edad media de cada grupo
mean_ages <- tapply(ages, groups, mean)
print(mean_ages)Resultados:
A B
27.00000 36.33333 mapply()La función mapply() es una versión multivariante de sapply(), que aplica una función en paralelo sobre un conjunto de argumentos.
#|label: mapply-example
# Definir dos vectores numéricos
v1 <- 1:5
v2 <- 6:10
# Utilizar mapply para sumar los elementos correspondientes de ambos vectores
sums <- mapply(sum, v1, v2)
print(sums)Resultados:
[1] 7 9 11 13 15vapply()La función vapply() es similar a sapply(), pero requiere que especifique el tipo de salida para obtener resultados más predecibles.
#|label: vapply-example
# Definir una función para calcular la raíz cuadrada de un número
sqrt_func <- function(x) sqrt(x)
# Aplique la función a un vector utilizando vapply, especificando que la salida debe ser numeric(1)
sqrt_values <- vapply(1:5, sqrt_func, FUN.VALUE = numeric(1))
print(sqrt_values)Conciso:
Las construcciones funcionales le permiten escribir menos líneas de código para operaciones comunes.
Legibilidad:
El código que aprovecha las funciones de aplicación y las operaciones vectorizadas suele ser más legible que los bucles anidados.
Rendimiento:
Las operaciones vectorizadas se implementan en código C optimizado, que puede ser significativamente más rápido que los bucles equivalentes de R.
Mantenibilidad:
Un enfoque funcional puede conducir a un código más fácil de probar y mantener, ya que las funciones encapsulan comportamientos específicos.
Mantener Funciones Puras:
Siempre que sea posible, diseñe funciones que no tengan efectos secundarios. Esto facilita las pruebas y el razonamiento sobre el código.
Usar nombres descriptivos:
Nombra claramente tus funciones y variables para indicar su propósito.
Aprovechar las funciones integradas:
Utilice el rico conjunto de funciones de aplicación y operaciones vectorizadas de R antes de recurrir a bucles explícitos.
Perfilado de código:
Utilice herramientas de creación de perfiles (por ejemplo, Rprof()) para identificar cuellos de botella y optimizar secciones críticas para el rendimiento.
La programación funcional en R le permite escribir código más conciso, eficiente y fácil de mantener. Utilizando la familia apply y las operaciones vectorizadas, puede realizar manipulaciones de datos complejas con facilidad. Experimente con los ejemplos proporcionados e integre estas técnicas en su flujo de trabajo para mejorar sus capacidades de procesamiento de datos.
Feliz codificación, y disfrute escribiendo programas eficientes en R utilizando técnicas de programación funcional!
Aquí hay más artículos de la misma categoría para ayudarte a profundizar en el tema.
@online{kassambara2024,
author = {Kassambara, Alboukadel},
title = {Programación funcional en R},
date = {2024-02-10},
url = {https://www.datanovia.com/es/learn/programming/r/advanced/functional-programming.html},
langid = {es}
}