Funciones R


Una función es un bloque de código que solo se ejecuta cuando se le llama.

Puede pasar datos, conocidos como parámetros, a una función.

Una función puede devolver datos como resultado.


Crear una función

Para crear una función, utilice la function()palabra clave:

Ejemplo

my_function <- function() { # create a function with the name my_function
  print("Hello World!")
}

Llamar a una función

Para llamar a una función, use el nombre de la función seguido de paréntesis, como my_function() :

Ejemplo

my_function <- function() {
  print("Hello World!")
}

my_function() # call the function named my_function

Argumentos

La información se puede pasar a funciones como argumentos.

Los argumentos se especifican después del nombre de la función, entre paréntesis. Puede agregar tantos argumentos como desee, simplemente sepárelos con una coma.

El siguiente ejemplo tiene una función con un argumento (fname). Cuando se llama a la función, pasamos un nombre, que se usa dentro de la función para imprimir el nombre completo:

Ejemplo

my_function <- function(fname) {
  paste(fname, "Griffin")
}

my_function("Peter")
my_function("Lois")
my_function("Stewie")

¿Parámetros o argumentos?

Los términos "parámetro" y "argumento" se pueden usar para lo mismo: información que se pasa a una función.

Desde la perspectiva de una función:

Un parámetro es la variable que aparece entre paréntesis en la definición de la función.

Un argumento es el valor que se envía a la función cuando se llama.



Número de argumentos

Por defecto, una función debe llamarse con el número correcto de argumentos. Lo que significa que si su función espera 2 argumentos, debe llamar a la función con 2 argumentos, ni más ni menos:

Ejemplo

Esta función espera 2 argumentos y obtiene 2 argumentos:

my_function <- function(fname, lname) {
  paste(fname, lname)
}

my_function("Peter", "Griffin")

Si intenta llamar a la función con 1 o 3 argumentos, obtendrá un error:

Ejemplo

Esta función espera 2 argumentos y obtiene 1 argumento:

my_function <- function(fname, lname) {
  paste(fname, lname)
}

my_function("Peter")

Valor de parámetro predeterminado

El siguiente ejemplo muestra cómo utilizar un valor de parámetro predeterminado.

Si llamamos a la función sin un argumento, usa el valor predeterminado:

Ejemplo

my_function <- function(country = "Norway") {
  paste("I am from", country)
}

my_function("Sweden")
my_function("India")
my_function() # will get the default value, which is Norway
my_function("USA")

Valores devueltos

Para permitir que una función devuelva un resultado, use la return()función:

Ejemplo

my_function <- function(x) {
  return (5 * x)
}

print(my_function(3))
print(my_function(5))
print(my_function(9))

La salida del código anterior será:

[1] 15
[1] 25
[1] 45

Funciones anidadas

Hay dos formas de crear una función anidada:

  • Llamar a una función dentro de otra función.
  • Escribe una función dentro de una función.

Ejemplo

Llame a una función dentro de otra función:

Nested_function <- function(x, y) {
  a <- x + y
  return(a)
}

Nested_function(Nested_function(2,2), Nested_function(3,3))

Ejemplo explicado

La función le dice a x que sume y.

La primera entrada Nested_function(2,2) es "x" de la función principal.

La segunda entrada Nested_function(3,3) es "y" de la función principal.

Por lo tanto, la salida es (2+2) + (3+3) = 10 .

Ejemplo

Escribe una función dentro de una función:

Outer_func <- function(x) {
  Inner_func <- function(y) {
    a <- x + y
    return(a)
  }
  return (Inner_func)
}
output <- Outer_func(3) # To call the Outer_func
output(5)

Ejemplo explicado

No puede llamar directamente a la función porque Inner_func se ha definido (anidado) dentro de Outer_func.

Necesitamos llamar a Outer_func primero para llamar a Inner_func como segundo paso.

Necesitamos crear una nueva variable llamada salida y darle un valor, que es 3 aquí.

Luego imprimimos la salida con el valor deseado de "y", que en este caso es 5.

La salida es por lo tanto 8 (3 + 5).


recursividad

R también acepta la función recursiva, lo que significa que una función definida puede llamarse a sí misma.

La recursividad es un concepto matemático y de programación común. Significa que una función se llama a sí misma. Esto tiene la ventaja de que puede recorrer los datos para llegar a un resultado.

El desarrollador debe tener mucho cuidado con la recursividad, ya que puede ser bastante fácil escribir una función que nunca termina, o una que usa cantidades excesivas de memoria o potencia del procesador. Sin embargo, cuando se escribe correctamente, la recursividad puede ser un enfoque de programación muy eficiente y matemáticamente elegante.

En este ejemplo, tri_recursion()es una función que hemos definido para llamarse a sí misma ("recurso"). Usamos la kvariable como los datos, que decrementan ( -1) cada vez que recursamos. La recursión termina cuando la condición no es mayor que 0 (es decir, cuando es 0).

Para un nuevo desarrollador, puede tomar algún tiempo averiguar cómo funciona exactamente esto, la mejor manera de averiguarlo es probándolo y modificándolo.

Ejemplo

tri_recursion <- function(k) {
  if (k > 0) {
    result <- k + tri_recursion(k - 1)
    print(result)
  } else {
    result = 0
    return(result)
  }
}
tri_recursion(6)