Tutoriel sur l’utilisation des fonctions en R

Si vous envisagez une carrière en data science, plus vous commencez à coder tôt, mieux c’est. Quel que soit le langage choisi pour démarrer votre apprentissage, vous croiserez très vite la route des fonctions. 

Les fonctions sont un concept central de quasiment tous les langages modernes, y compris les langages plébiscités en data science comme Python, Julia et, bien sûr, R.

Dans ce tutoriel, nous verrons ce que sont les fonctions en R et comment les utiliser. En couvrant leur finalité, leur syntaxe et leur typologie, vous disposerez de tout le nécessaire pour maîtriser ce concept clé en programmation. Et surtout, vous ferez vos premiers pas dans l’art d’écrire vos propres fonctions. 

Qu’est-ce qu’une fonction en R ?

En programmation, une fonction est un ensemble d’instructions organisées pour accomplir une tâche précise. L’idée est de créer des blocs autonomes, appelés uniquement lorsque c’est nécessaire. 

Grâce aux fonctions, vous n’avez plus à réécrire un programme depuis zéro, vous évitez les répétitions et vous améliorez la robustesse comme la lisibilité du code. En règle générale, dès que vous pensez exécuter plus de deux fois une même série d’instructions, il est recommandé d’en faire une fonction.

Les fonctions ont des usages innombrables et prennent diverses formes. Dans la plupart des cas, elles reçoivent des données en entrée, les traitent, puis renvoient un résultat. Les données sur lesquelles elles opèrent sont précisées via des arguments, qui peuvent aussi piloter ou modifier la manière dont la fonction exécute la tâche.

Selon leur origine, on distingue trois grands types de fonctions en R :

• Fonctions natives
• Fonctions disponibles dans des packages R
• Fonctions définies par l’utilisateur (UDF)

Dans les sections suivantes, nous détaillons les spécificités de chaque type de fonction en R. 

Fonctions natives en R

R est un langage puissant doté d’un large catalogue de fonctions natives appelables à tout moment. Langage orienté mathématiques, R propose de nombreuses fonctions pour les opérations numériques. Voici quelques-unes des plus utiles :

• print(). Affiche un objet R dans la console
• min(), max(). Calcule le minimum et le maximum d’un vecteur numérique
• sum(). Calcule la somme d’un vecteur numérique
• mean(). Calcule la moyenne d’un vecteur numérique
• range(). Renvoie les valeurs minimale et maximale d’un vecteur numérique
• str(). Affiche la structure d’un objet R
• ncol(). Renvoie le nombre de colonnes d’une matrice ou d’un data frame
• length(). Renvoie le nombre d’éléments d’un objet R, par exemple un vecteur, une liste ou une matrice.

Dans l’exemple ci-dessous, voyez comme il est simple d’utiliser ces fonctions pour calculer quelques statistiques à partir d’un vecteur :

>>> v <- c(1, 3, 0.2, 1.5, 1.7)
>>> print(v)
[1] 1.0 3.0 0.2 1.5 1.7
>>> sum(v)
[1] 7.4
>>> mean(v)
[1] 1.48
>>> length(v)
[1] 5

Retrouvez les fonctions R et bien plus dans notre parcours de compétences R complet, pour apprendre à coder comme un·e pro. 

Fonctions dans les packages R

Aussi nombreuses et variées soient-elles, les fonctions natives ne suffisent pas pour tout ce qu’il est possible de faire avec R, de la création de visualisations percutantes à l’entraînement de modèles de machine learning puissants. 

La grande majorité des fonctions nécessaires proviennent de packages (ou bibliothèques) externes. Les packages sont des ensembles structurés de fonctions R, de données et de code compilé, conçus pour ajouter des fonctionnalités spécifiques. La plupart sont gratuits et disponibles sur des dépôts populaires comme CRAN, qui répertorie aujourd’hui près de 20 000 packages contribués. 

Pour utiliser les fonctions d’un package, vous devez d’abord l’installer. Par exemple, pour installer stringr, un package populaire pour travailler avec les expressions régulières, utilisez :

install.packages('stringr')

Une fois installé, chargez-le dans votre environnement R avec :

library(stringr)

Vous pouvez maintenant utiliser toutes les fonctions de stringr. Essayons par exemple str_detect(), qui renvoie un vecteur logique avec TRUE pour chaque élément de la chaîne qui correspond au motif et FALSE sinon.

str_detect('DataCamp', "Data")
[1] TRUE

Pour en savoir plus sur les packages R et leur utilisation, consultez ce tutoriel sur les packages R de DataCamp.

Fonctions définies par l’utilisateur

La meilleure façon de comprendre le fonctionnement des fonctions en R est d’écrire les vôtres. Les fonctions dites « définies par l’utilisateur » (UDF) sont conçues par des programmeurs pour réaliser une tâche spécifique. 

Les fonctions R suivent généralement la syntaxe suivante :

function_name <- function(argument_1, argument_2) { 
  function body
  return (output)
}

On distingue quatre éléments principaux :

• Nom de la fonction. Pour créer une UDF, commencez par lui donner un nom et l’assigner à un nouvel objet. Il suffira ensuite d’appeler ce nom pour utiliser la fonction. 
• Arguments. Les arguments (ou paramètres) de la fonction se placent entre parenthèses. Ils indiquent quelles données prendre en entrée et/ou comment modifier le comportement de la fonction. 
• Corps de la fonction. Entre accolades se trouve le corps de la fonction, c’est-à-dire les instructions pour résoudre la tâche, en s’appuyant sur les informations fournies par les arguments. 
• Instruction de retour. L’instruction return est nécessaire si vous souhaitez enregistrer dans des variables le ou les résultats produits par le corps de la fonction. 

Par exemple, si vous voulez créer une fonction qui calcule la moyenne de deux nombres :

mean_two_numbers <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Pour calculer ensuite la moyenne de 10 et 20, appelez simplement la fonction ainsi :

>>> mean_two_numbers(10,20)
[1] 15

Types d’arguments dans les fonctions R

Les arguments sont essentiels dans toute fonction. Même s’il est théoriquement possible d’écrire une fonction sans paramètre (voir l’exemple ci-dessous), la plupart en possèdent. C’est logique : les arguments indiquent quelles données fournir en entrée. De même, si vous souhaitez proposer plusieurs manières d’exécuter une tâche, ce sont les arguments qui porteront ces options.

hello <- function() {
  print('hello, my friend')
}

>>> hello()
[1] "hello, my friend"

Il n’y a pas de limite au nombre d’arguments d’une fonction R : ajoutez-les entre parenthèses, séparés par des virgules. En général, plus une fonction a d’arguments, plus elle est complexe.

Une fois la fonction paramétrée, vous devrez fournir une valeur à chacun des paramètres lors de l’appel, faute de quoi R renverra une erreur. Par exemple, si vous n’indiquez pas les deux nombres pour calculer leur moyenne, notre fonction échouera.

Vous pouvez toutefois éviter l’erreur en définissant des valeurs par défaut au moment de créer la fonction. Un argument par défaut fournit une valeur utilisée si vous appelez la fonction sans renseigner cet argument. Reprenons notre fonction de moyenne de deux nombres et ajoutons cette fois une valeur par défaut pour le second nombre.

mean_two_numbers <- function(num_1, num_2 = 30) {
  mean <- (num_1 + num_2) / 2
  return (mean)
}

Si nous appelons maintenant la fonction sans fournir la valeur du paramètre num_2, R prendra automatiquement la valeur par défaut (ici 30) :

>>> mean_two_numbers(num_1 = 10)
[1] 20

Comprendre les valeurs de retour des fonctions R

Les fonctions prennent généralement des données en entrée et renvoient un résultat en sortie. Dans certains langages, pour enregistrer le résultat d’une fonction dans une variable, il faut inclure explicitement l’instruction return à la fin du corps de fonction. Sinon, la fonction affiche une valeur qui n’existe qu’à l’intérieur de sa portée.

Ce n’est pas le cas en R, qui renvoie toujours une valeur stockable dans une variable. Toutefois, par souci de lisibilité, il est recommandé d’inclure l’instruction return lors de la définition d’une fonction.

mean_two_numbers <- function(num_1, num_2) {
  # Fonction avec return 
  mean <- (num_1 + num_2) / 2
  return (mean)
}
mean_two_numbers_2 <- function(num_1, num_2) {
  # Fonction sans return
  mean <- (num_1 + num_2) / 2
  mean
}

> mean_two_numbers(10,50)
[1] 30
 > mean_two_numbers_2(10,50)
[1] 30

Enfin, si vous souhaitez qu’une fonction renvoie plusieurs valeurs, stockez les différents résultats dans une liste et retournez-la :

mean_sum <- function(num_1, num_2) {
  mean <- (num_1 + num_2) / 2
  sum <- num_1 + num_2
  return (list(mean, sum))
}

>>> mean_sum (10, 20)
[[1]]
[1] 15
[[2]]
[1] 30

Appeler des fonctions en R

Nous avons déjà vu plusieurs exemples d’appel de fonction. Il est toutefois utile de préciser ce que R fait en coulisse au moment de passer les arguments. 

R permet de passer des arguments par position ou par nom. Avec la première stratégie, vous fournissez les valeurs dans le même ordre que les arguments sont définis dans la fonction. 

Si vous passez les arguments par nom, vous spécifiez explicitement le nom de chaque argument et sa valeur associée. Dans ce cas, l’ordre n’a pas d’importance.

Il est également possible de combiner les deux approches. Les arguments nommés sont d’abord extraits et apparient leurs valeurs, tandis que les autres sont associés par position.

hello <- function(name, surname) {
  print(paste('Hello', name, surname))
}

# Appel par position
> hello('Greta','Thunberg')
[1] "Hello, Greta Thunberg"
# Appel par nom
> hello(surname='Thunberg', name='Greta')
[1] "Hello, Greta Thunberg"
# Appel mixte (par nom et par position)
> hello(surname='Thunberg', 'Greta')
[1] "Hello, Greta Thunberg"

Documenter des fonctions en R

Une bonne pratique lors de la création de fonctions consiste à documenter leur utilisation, surtout si elles sont complexes. De manière informelle, vous pouvez ajouter des commentaires dans le corps des fonctions. Vous pouvez afficher cette « documentation » en appelant la fonction sans paramètres :

hello <- function(name, surname) {
  # Dire bonjour à une personne avec son prénom et son nom
  print(paste('Hello', name, surname))
}

>>> hello
function(name, surname) {
  # Dire bonjour à une personne avec son prénom et son nom
  print(paste('Hello,', name, surname))

En revanche, si votre fonction fait partie d’un package plus large et que vous souhaitez la documenter proprement, rédigez une documentation formelle dans un fichier .Rd séparé. Vous en voyez le résultat dans l’aide d’une fonction donnée, par exemple ?mean. 

Conclusion

Vous êtes arrivé au bout de ce tutoriel : bravo ! Comme dans de nombreux langages, les fonctions sont incontournables en R. Qu’elles soient natives, issues de packages externes ou écrites par vos soins, les maîtriser est une étape clé de votre parcours en programmation. Pour continuer à progresser sur les fonctions en R, explorez les ressources suivantes !

• Introduction to Writing Functions in R Course
• Intermediate R Course
• Tutoriel sur la famille de fonctions « apply » en R
• Parcours R Programming