Fonctions R
Une fonction est un bloc de code qui ne s'exécute que lorsqu'elle est appelée.
Vous pouvez transmettre des données, appelées paramètres, dans une fonction.
Une fonction peut renvoyer des données en conséquence.
Création d'une fonction
Pour créer une fonction, utilisez le function()mot clé :
Exemple
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
Appeler une fonction
Pour appeler une fonction, utilisez le nom de la fonction suivi de parenthèses, comme my_function() :
Exemple
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
Arguments
Les informations peuvent être transmises aux fonctions en tant qu'arguments.
Les arguments sont spécifiés après le nom de la fonction, entre parenthèses. Vous pouvez ajouter autant d'arguments que vous le souhaitez, séparez-les simplement par une virgule.
L'exemple suivant a une fonction avec un argument (fname). Lorsque la fonction est appelée, nous transmettons un prénom, qui est utilisé à l'intérieur de la fonction pour imprimer le nom complet :
Exemple
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
Paramètres ou arguments ?
Les termes « paramètre » et « argument » peuvent être utilisés pour la même chose : des informations transmises à une fonction.
Du point de vue d'une fonction :
Un paramètre est la variable répertoriée entre parenthèses dans la définition de la fonction.
Un argument est la valeur qui est envoyée à la fonction lorsqu'elle est appelée.
Nombre d'arguments
Par défaut, une fonction doit être appelée avec le bon nombre d'arguments. Cela signifie que si votre fonction attend 2 arguments, vous devez appeler la fonction avec 2 arguments, ni plus, ni moins :
Exemple
Cette fonction attend 2 arguments et obtient 2 arguments :
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
Si vous essayez d'appeler la fonction avec 1 ou 3 arguments, vous obtiendrez une erreur :
Exemple
Cette fonction attend 2 arguments et obtient 1 argument :
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
Valeur de paramètre par défaut
L'exemple suivant montre comment utiliser une valeur de paramètre par défaut.
Si nous appelons la fonction sans argument, elle utilise la valeur par défaut :
Exemple
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")
Valeurs de retour
Pour laisser une fonction renvoyer un résultat, utilisez la return()fonction :
Exemple
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
La sortie du code ci-dessus sera :
[1] 15
[1] 25
[1] 45
Fonctions imbriquées
Il existe deux manières de créer une fonction imbriquée :
- Appelez une fonction dans une autre fonction.
- Ecrire une fonction dans une fonction.
Exemple
Appelez une fonction dans une autre fonction :
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
Exemple expliqué
La fonction dit à x d'ajouter y.
La première entrée Nested_function(2,2) est "x" de la fonction principale.
La deuxième entrée Nested_function(3,3) est "y" de la fonction principale.
La sortie est donc (2+2) + (3+3) = 10 .
Exemple
Ecrire une fonction dans une fonction :
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)
Exemple expliqué
Vous ne pouvez pas appeler directement la fonction car Inner_func a été défini (imbriqué) dans Outer_func.
Nous devons d'abord appeler Outer_func afin d'appeler Inner_func dans un deuxième temps.
Nous devons créer une nouvelle variable appelée output et lui donner une valeur, qui est 3 ici.
Nous imprimons ensuite la sortie avec la valeur souhaitée de "y", qui dans ce cas est 5.
La sortie est donc 8 (3 + 5).
Récursivité
R accepte également la récursivité des fonctions, ce qui signifie qu'une fonction définie peut s'appeler elle-même.
La récursivité est un concept mathématique et de programmation courant. Cela signifie qu'une fonction s'appelle elle-même. Cela a l'avantage de signifier que vous pouvez parcourir les données pour atteindre un résultat.
Le développeur doit être très prudent avec la récursivité car il peut être assez facile de se glisser dans l'écriture d'une fonction qui ne se termine jamais, ou qui utilise des quantités excessives de mémoire ou de puissance de processeur. Cependant, lorsqu'elle est écrite correctement, la récursivité peut être une approche de programmation très efficace et mathématiquement élégante.
Dans cet exemple, tri_recursion()est une fonction que nous avons définie pour s'appeler elle-même ("recurse"). Nous utilisons la
kvariable comme donnée, qui décrémente ( -1) chaque fois que nous récursons. La récursivité se termine lorsque la condition n'est pas supérieure à 0 (c'est-à-dire lorsqu'elle vaut 0).
Pour un nouveau développeur, cela peut prendre un certain temps pour comprendre comment cela fonctionne exactement, la meilleure façon de le savoir est de le tester et de le modifier.
Exemple
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)