Créer ses propres fonctions dans R

Créer des fonctions dans R

Vous pouvez créer vos propres fonctions pour rendre votre code plus efficace et éviter les répétitions. Il n'est toutefois pas nécessaire de créer ses propres fonctions pour utiliser R. Une fonction se crée selon la structure suivante :

my_function <- function(argument1, argument2) {
  body
}

Remarques :

• La fonction est créée avec function().
• Dans function(), on spécifie les arguments de la fonction. Il peut y en avoir plusieurs.
• Entre accolades ([{}](https://rdrr.io/r/base/Paren.html)) se trouve le corps (angl. body) de la fonction. C'est là que figurent les instructions de la fonction.
• La fonction est assignée à l'objet my_function, qui peut ensuite être utilisé pour exécuter la fonction.

Créons une fonction à deux arguments qui sont multipliés l'un par l'autre. Nous appelons cette fonction my_first_function :

my_first_function <- function(argument1, argument2) {
  argument1*argument2
}

Testons maintenant la fonction :

my_first_function(argument1=5, argument2=5)

[1] 25

Comme pour toutes les autres fonctions, nous pouvons nous dispenser d'utiliser le nom des arguments. Les valeurs que nous indiquons sont alors transmises aux arguments un par un, dans l'ordre :

my_first_function(5, 5)

[1] 25

Notez que, dans cet exemple, R renvoie la toute dernière valeur créée par la fonction. On peut toutefois, et on devrait, indiquer explicitement ce que l'on souhaite renvoyer, ce que l'on fait avec la fonction [return()](https://rdrr.io/r/base/function.html). Modifions la fonction de sorte qu'elle crée un objet (product) que nous renvoyons ensuite :

my_first_function <- function(argument1, argument2) {
  product = argument1*argument2
  return(product)
}

Testons la fonction :

my_first_function(5, 5)

[1] 25

Si l'on ne spécifie pas return(), R renvoie donc automatiquement le dernier objet créé.

Créons une nouvelle fonction à deux arguments, à savoir une valeur x et une valeur y correspondant aux coordonnées d'un point sur un graphique. Nous appelons cette fonction to_plot ; elle utilise la fonction [plot()](https://rdrr.io/r/graphics/plot.default.html) pour créer le graphique :

to_plot <- function(x, y) {
  plot(x, y)
}

Nous testons la fonction en fixant x à 1 et y à 5 :

to_plot(x=1, y=5)

La fonction suivante permet à l'utilisateur de générer aléatoirement des nombres, qui sont ensuite représentés sur un graphique. L'utilisateur doit indiquer combien de valeurs générer, ainsi que la moyenne des valeurs sur l'axe des x et celle des valeurs sur l'axe des y.

to_plot <- function(random_numbers, x_mean, y_mean) {
  x <- rnorm(n = random_numbers, mean = x_mean)
  y <- rnorm(n = random_numbers, mean = y_mean)
  return(plot(x, y))
}

Nous testons la fonction en demandant la génération de 100 valeurs, avec une moyenne de 10 sur l'axe des x et de 100 sur l'axe des y :

to_plot(random_numbers=100, x_mean=10, y_mean=100)

Recréons la même fonction, mais cette fois avec des valeurs par défaut pour tous les paramètres. Nous pourrons ainsi exécuter la fonction sans spécifier les arguments !

to_plot <- function(random_numbers=20, x_mean=1, y_mean=10) {
  x <- rnorm(n = random_numbers, mean = x_mean)
  y <- rnorm(n = random_numbers, mean = y_mean)
  plot(x, y)
}

## Teste la fonction
to_plot()

Les fonctions ci-dessus sont très simples et pratiquement superflues. Leur but est d'illustrer la manière dont on définit des fonctions dans R. En pratique, les fonctions comptent entre 5 et 50 lignes. Il est souvent préférable de découper les fonctions plus longues en plusieurs fonctions.

Nous allons maintenant créer une fonction un peu plus élaborée. Elle doit accomplir plusieurs tâches, par exemple charger un package, créer un graphique, enregistrer ce graphique au format PDF et également l'afficher. La fonction contient désormais des commentaires qui précisent ce que nous faisons à chaque étape :

## Crée la fonction to_plot()
## La fonction a les arguments random_numbers, x_mean, y_mean, title
to_plot <- function(random_numbers=20, x_mean=10, y_mean=10, my_title) {
  # Active le package ggplot2, utilisé pour créer des graphiques
  library(ggplot2)

  # Crée les valeurs x
  x <- rnorm(n = random_numbers, mean = x_mean)
  # Prend le logarithme des valeurs x
  x <- log(x)

  # Crée les valeurs y
  y <- rnorm(n = random_numbers, mean = y_mean)
  # Élève les valeurs y au carré
  y = y^2

  # Enregistre x et y dans un data frame
  my_data <- data.frame(x, y)

  # Crée un graphique
  my_plot <- ggplot(my_data, aes(x=x, y=y)) +
    # Demande l'affichage de points sur le graphique
    geom_point() +
    # Indique que le titre du graphique doit être égal à l'argument title de la fonction
    labs(title=my_title)

  # Enregistre le graphique dans un fichier PDF
  ggsave(plot=my_plot, filename='my_plot.pdf')
  return(my_plot)
}

## Teste la fonction
to_plot(random_numbers=10, x_mean=10, y_mean=10, my_title="Min första graf")

Saving 7 x 5 in image

Comme pour les autres fonctions de R, vous pouvez imbriquer vos fonctions les unes dans les autres.

Fonctions

• Créez une fonction avec la syntaxe : name <- function(...args...) {...body...}.
• Utilisez la fonction avec la syntaxe : name(...values...).
• Utilisez des commentaires lorsque vous créez des fonctions
• R recherche les variables dans le cadre d'exécution courant (stack frame) avant de les rechercher au niveau supérieur.
• Indiquez des valeurs par défaut pour les arguments lorsque c'est pertinent