Begin'R
Les statistiques avec R
Navigation
[Retour au sommaire]
# Fonctions :Objectifs 1. Créer une fonction. 2. Régler des paramètres par défaut. 3. Appeler une fonction dans un script R. :Aide : Présentation générale des fonctions {#presentation_generale_fonctions, toggle=display, title-display=show} Définitions : * Les fonctions regroupent un ensemble d'instructions réutilisables simplement et qui accomplissent un ensemble d'opérations. Elles peuvent (mais ce n'est pas obligé) accepter des valeurs (appelées "arguments" ou "paramètres"). S'il y en a plusieurs, les arguments sont séparés par des virgules. * Une **fonction** réalise une succession d'instructions et peut renvoyer une (et une seule !) valeur issue d'un calcul (instruction **`return()`**). :Remarque{#remarque_fonctionprocedure} Les fonctions sont essentielles afin d'encapsuler une série de traitements dans l'objectif de les réutiliser et/ou les partager plus simplement. Ainsi, le fait que les développeurs de R aient préalablement défini la fonction `log()` ou la fonction `print()` permet aujourd'hui de les utiliser sans se soucier de leur fonctionnement. En langage R, La syntaxe pour la création d'une fonction est la suivante : ```r Nom_de_la_fonction <- function(liste_des_paramètres_d_entrée){ # Corps de la fonction return(paramètre_de_sortie) } ``` :Remarque{#remarque_fonction} * Lors de l'écriture d'une fonction, le nom de celle-ci est suivi du mot-clé `function`. * Les instructions qui composent la fonction sont encadrées de `{` et `}`. * Le mot clé `return` permet de renvoyer un paramètre de sortie :Exemple {#example_fonction_ecart_type, toggle=collapse, title-display=show} La fonction ci-dessous permet de calculer et de renvoyer en paramètre de sortie l'écart-type empirique d'une série de données `x`. Cette fonction intitulée `calc_ecart_type` est créée dans le fichier R du même nom (`'calc_ecart_type.r'`). ```r calc_ecart_type <- function(x){ # Calcul de l'écart-type empirique s <- sum( (x-mean(x))^2 ) / length(x) # renvoie de l'écart-type empirique en paramètre de sortie return(s) } ``` Le programme principal suivant permet de faire appel à la fonction `calc_ecart_type()`. Il faut tout d'abord déclarer la fonction `calc_ecart_type()` à l'aide de la fonction `source()` qui prend comme unique paramètre d'entrée le nom du fichier R contenant les lignes de code de la fonction `calc_ecart_type()`. Une fois la fonction `calc_ecart_type()` déclarée, il est possible d'utiliser cette fonction sur le jeu de données souhaité et de récupérer en sortie l'écart-type empirique. ```r # Déclaration de la fonction 'calc_ecart_type()' se trouvant dans le fichier 'calc_ecart_type.r'. source('calc_ecart_type.r') x <- c(1,2,3,4) # Calcul de l'écart-type empirique à l'aide de la fonction calc_ecart_type() s <- calc_ecart_type(x) # Affichage de l'écart-type empirique cat("L'écart-type empirique vaut", s) ``` ``` ## L'écart-type empirique vaut 1.25 ``` :Résumé | Type de fonction | Code de la fonction | Appel de la fonction | |-------------------|-------------------------|----------------------| |sans paramètre de sortie | [ici](#example_Code_fonction_sans_sortie) | [ici](#example_appel_fonction_sans_sortie) | |avec un paramètre de sortie | [ici](#example_Code_fonction_avec_sortie) | [ici](#example_appel_fonction_avec_sortie) | |avec un paramètre d'entrée par défaut | [ici](#example_Code_fonction_avec_parametre_defaut) | [ici](#example_appel_fonction_avec_avec_parametre_defaut) | <!-- Sans paramètre de sortie --> :Exemple {#example_Code_fonction_sans_sortie, toggle=popup} La fonction suivante intitulée `'affiche_somme()'` permet de calculer la somme des entiers de `1` à `N`. Dans les exercices précédents, le code R associé à cet algorithme a été vu. Afin de l'encapsuler dans une fonction, un fichier intitulé `'affiche_somme.r'` contenant les lignes de code suivantes est créé : ```r # Le paramètre N est le paramètre d'entrée de la fonction. affiche_somme <- function( N ){ Somme <- 0 # Somme – variable de sortie i <- 1 # Compteur - varie de 1 à N while (i <= N){ Somme <- Somme + i # incrémentation de Somme i <- i + 1 # incrémentation du compteur } # Affichage du résultat cat("La somme des entiers de 1 a",N,"vaut :",Somme) } ``` :Remarque{#remarque_procedure1} * Ici, il n'y a pas de paramètres de sortie (pas d'utilisation du mot-clé `return`). L'affichage de la variable `somme` est réalisé par la fonction elle-même. :Exemple {#example_appel_fonction_sans_sortie, toggle=popup} A l'aide de cette fonction `'affiche_somme()'`, les lignes de code suivantes permettent de calculer la somme des entiers de `1` à `5`. ```r # Déclaration de la fonction 'affiche_somme()' source('affiche_somme.r') N <- 5 # Calcul et affichage de la somme affiche_somme(N) ``` ``` ## La somme des entiers de 1 a 5 vaut : 15 ``` :Remarque{#remarque_fonction2} L'instruction `source('affiche_somme.r')` permet de déclarer la fonction `affiche_somme()` définie dans le fichier R du même nom. <!-- Avec paramètre de sortie --> :Exemple {#example_Code_fonction_avec_sortie, toggle=popup} L'exemple précédent du calcul de la somme des entiers de `1` à `N` est repris en utilisant une fonction qui renvoie un paramètre de sortie. Cela peut permettre par la suite de réaliser un traitement sur la valeur retournée. Pour cela, un fichier intitulé `'calcul_somme()'` est créé. Il contient les lignes de code suivantes : ```r # Le paramètre N est le paramètre d'entrée de la fonction # La variable Somme est renvoyée comme paramètre de sortie. calcul_somme <- function( N ){ Somme <- 0 # Somme – variable de sortie i <- 1 # Compteur - varie de 1 à N while (i <= N){ Somme <- Somme + i # incrémentation de Somme i <- i + 1 # incrémentation du compteur } return(Somme) # renvoie la somme en paramètre de sortie } ``` :Remarque{#remarque_fonction1} * Noter l'utilisation du mot clé `return` pour renvoyer la variable `Somme` comme paramètre de sortie de la fonction. * L'instruction `return()` doit obligatoirement être la dernière instruction de la fonction. * Il est recommandé, dans les lignes précédant la définition de la fonction, d'insérer quelques lignes de commentaires indiquant l'objectif de la fonction et la signification de ses paramètres d'entrée et de sortie. :Exemple {#example_appel_fonction_avec_sortie, toggle=popup} Maintenant, l'exécution des lignes de code suivantes, dans la console R ou dans un autre script, permet de calculer la somme des entiers de `1` à `5`. ```r # Déclaration de la fonction 'calcul_somme()' source('calcul_somme.r') N <- 5 # Calcul de la somme Somme <- calcul_somme(N) # Affichage du résultat cat("La somme des entiers de 1 à",N,"vaut :",Somme) ``` ``` ## La somme des entiers de 1 à 5 vaut : 15 ``` :Remarque{#remarque_procedure2} <!-- * Les deux exemples ci-dessus, utilisant respectivement les fonctions `'affiche_somme()'` et `'calcul_somme()'`, produisent le même affichage : `La somme des entiers de 1 a 5 vaut : 15`. --> * L'avantage de cet exemple est que la fonction `'calcul_somme()'` renvoie une valeur numérique qu'il est possible d'utiliser pour un autre traitement. <!-- Paramètre d'entrée par défaut --> :Exemple {#example_Code_fonction_avec_parametre_defaut, toggle=popup} La fonction suivante permet de calculer l'écart-type estimé ou l'écart-type empirique d'une série de données `x` selon la valeur de la variable `type`. Lorsque `type` est égal à `"estimation"`, la fonction renvoie en paramètre de sortie l'écart-type estimé $\hat{\sigma}$. En revanche lorsque `type` est différent de la chaîne de caractères `"estimation"`, la fonction renvoie en sortie l'écart-type empirique. Par défaut, la variable `type` est égale à `"estimation"` comme cela est spécifiée dans la liste des paramètres d'entrée de la fonction (`type = "estimation"`). ```r calcul_ecart_type <- function(x, type = "estimation"){ if(type == "estimation"){ s <- sd(x) # Calcul de l'écart-type estimé } else{ s <- sum( (x-mean(x))^2 ) / length(x) # Calcul de l'écart-type empirique } # affichage de l'écart-type en paramètre de sortie return(s) } ``` :Exemple {#example_appel_fonction_avec_avec_parametre_defaut, toggle=popup} Maintenant, l'exécution des lignes de code suivantes permet de calculer soit l'écart-type estimé, soit l'écart-type empirique. ```r # Déclaration de la fonction 'calcul_ecart_type()' source('calcul_ecart_type.r') x <- c(1,2,3,4) # Calcul de l'écart-type estimé s <- calcul_ecart_type(x) cat("L'écart-type estimé vaut", round(s,2)) ``` ``` ## L'écart-type estimé vaut 1.29 ``` ```r # Calcul de l'écart-type estimé s <- calcul_ecart_type(x, type = 'estimation') cat("L'écart-type estimé vaut", round(s,2)) ``` ``` ## L'écart-type estimé vaut 1.29 ``` ```r # Calcul de l'écart-type empirique s <- calcul_ecart_type(x, type = 'empirique') cat("L'écart-type empirique vaut", round(s,2)) ``` ``` ## L'écart-type empirique vaut 1.25 ``` :Remarque{#remarque_parametre_defaut} * Lorsque l'argument `type` n'est pas renseigné, il prend sa valeur par défaut. Ici, il prend la valeur `'estimation'` et la fonction `calcul_ecart_type()` renvoie l'écart-type estimé. Les deux instructions suivantes sont donc équivalentes : ```r s = calcul_ecart_type(x) s = calcul_ecart_type(x, type = 'estimation') ``` :Remarque{#remarque_parametre_defaut2} * Lorsque les arguments sont spécifiés dans l'appel de la fonction, l'ordre des arguments nommés n'est pas important. * En revanche, lorsque les arguments ne sont pas spécifiés dans l'appel de la fonction, l'ordre chronologique des arguments doit être le même que celui dans la définition de la fonction. En conséquence, les instructions suivantes sont équivalentes. ```r donnees <- c(1,4,5,2) s = calcul_ecart_type(x = donnees, type = 'estimation') s = calcul_ecart_type(type = 'estimation', x = donnees) s = calcul_ecart_type(donnees, 'estimation') s = calcul_ecart_type(donnees, type = 'estimation') s = calcul_ecart_type(type = 'estimation', donnees) ``` :Suite Structure algorithmiques et fonctions {#algo, toggle=collapse, title-display=hidden} [Préambule : de l'algorithme au programme](caps_algo_1_de_l_algo_au_programme.html) [Les opérateurs](caps_algo_2_operateurs.html) [Structures algorithmiques](caps_algo_3_structures_algorithmiques.html) [Structures alternatives](caps_algo_4_structures_test.html) [Structures itératives](caps_algo_5_structures_iteratives.html) [Fonctions](caps_algo_6_fonctions.html) [Exercices bilan](caps_algo_7_exercice_bilan_programmation_R.html)
