Chapitre 3 Les Fonctions et packages

3.1 Les Fonctions

Pour aller un peu plus loin nous allons aborder, un autre concept fondamental de R, à savoir les fonctions. Une fonction se caractérise de la manière suivante :

  • elle a un nom;

  • elle a une liste d’arguments, avec éventuellement des valeurs par défaut;

  • elle retourne un résultat ou effectue une action comme dessiner un graphique, lire un fichier, etc.

L’appel d’une fonction se fait typiquement comme suit

nom.fonct(arg.1 = val.1, arg.2 = val.2, ...)

val.1, val.2, …, sont les valeurs attribuées aux arguments arg.1, arg.2, ….Lorsqu’on passe un argument à une fonction de cette manière, c’est-à-dire sous la forme nom=valeur, on parle d’argument nommé.

Illustrons cela avec la fonction seq, qui produit une suite (séquence) de nombres:

seq(from = 1, to = 9, by = 2)
[1] 1 3 5 7 9

Certains arguments peuvent être facultatifs et ont des valeurs par défaut prédéfinies, par exemple, si on omet by, R utilise by = 1:

seq(from = 1, to = 9)
[1] 1 2 3 4 5 6 7 8 9

Pour connaître les valeurs par défaut, les autres utilisations de la fonction et le type de résultat qu’elle retourne, vous pouvez accéder à l’aide en tapant help(nom.fonct) ou ?nom.fonct.

help(seq)

Cette commande affiche une page (en anglais) décrivant la fonction, ses paramètres, son résultat, ….

Dans la section Usage du fichier d’aide, les arguments, suivi par le symbole = ont une valeur par défaut. Il n’est donc pas nécessaire de les inclure dans l’appel de la fonction, auquel cas la valeur pas défaut sera prise en compte. Tous les autres arguments doivent recevoir une valeur.

La majorité des fiches d’aide comportent des exemples d’utilisation de la fonction à la fin. Ces exemples sont souvent très utiles pour comprendre comment utiliser la fonction.

Chaque fonction a un ordre par défaut pour ces arguments (voir la section Usage du fichier d’aide de la fonction). L’ordre des arguments est important:

  • Si vous fournissez les arguments dans l’ordre prédéfini, alors ils n’ont pas besoin d’être nommés
  • s’ils ne sont pas appelés dans l’ordre, alors il est nécessaire de les nommer .

Notez que les noms formels peuvent être abrégés tant que l’abréviation n’est pas ambiguë. Ainsi les commandes suivantes produisent toutes le même résultat.

seq(from = 1, to = 9, by = 2)
[1] 1 3 5 7 9
seq(f = 1, t = 9, b = 2)
[1] 1 3 5 7 9
seq(1, by = 2, to = 9)
[1] 1 3 5 7 9
seq(1, 9, 2)
[1] 1 3 5 7 9

Pour éviter toute surprise, il est conseillé de nommer tous les arguments lorsqu’on fait appel à une fonction.

seq(1, 2, 9)
[1] 1

Quelques fonctions utiles

Dans les exemples suivant x<-c(4, -1, 2, 6, 2) .

Fonction Utilité Exemple Sortie
: générer des nombres 1:5 1, 2, 3, 4, 5
3:0 3, 2, 1, 0
seq générer une séquence selon une règle. seq(1, 2, by = 0.3) 1, 1.3, 1.6, 1.9
seq(1, 2, length = 5) 1, 1.25, 1.5, 1.75, 2
rep répéter rep(2, 4) 2, 2, 2, 2
rep(c(2, 5), c(1, 2)) 2, 5, 5
round arrondir round(0.555, 1) 0.6
round(c(0.555, 1.2), 0) 1, 1
sort tri croissant ou décroissant sort(x) -1, 2, 2, 4, 6
sort(x, decreasing = TRUE) 6, 4, 2, 2, -1
order rang du plus petit au plus grand ou l’inverse order(x) 2, 3, 5, 1, 4
order(x, decreasing = TRUE) 4, 1, 3, 5, 2
unique extraction les éléments différents unique(x) 4, -1, 2, 6
length taille d’un vecteur length(x) 5
%in% appartenance d’une ou plusieurs valeurs à un vecteur (-1:2) %in% x TRUE, FALSE, FALSE, TRUE
ifelse instructions conditionnelles ifelse(x>=0, x-1, x+1) 3, 0, 1, 5, 1
paste concaténation paste(“Hello”, “world”, sep = " “) Hello world
paste(“Face”, 1:6, sep = “_“) Face_1, Face_2, Face_3, Face_4, Face_5, Face_6
sum somme sum(x) 13
prod produit prod(x) -96
min minimum min(x) -1
max maximum max(x) 6
which.min position du minimum which.min(x) 2
which.max position du maximum which.max(x) 4

L’opérateur : est bel et bien une fonction comme les autres. En effet, au lieu de taper 1:5, on peut très bien écrire “:”(1,5). Cela est aussi le cas de beaucoup d’autres opérateurs tel que +, -, *, %in%, ….

L’argument na.rm

Imaginons que la deuxième personne interrogée n’ait pas voulu nous répondre. Nous avons alors dans notre vecteur une valeur manquante.

tailles <- c(163, NA, 167, 170, 171, 172, 173, 174, 185, 192)
sum(tailles)
[1] NA

Par défaut, R renvoie NA pour un grand nombre d’opérations lorsque les données comportent une valeur manquante. On peut cependant facilement modifier ce comportement :

sum(tailles, na.rm = TRUE)
[1] 1567

Assigner la valeur TRUE (VRAI) à l’argument na.rm indique à la fonction sum de ne pas tenir compte des valeurs manquantes dans le calcul.

Créer sa propre fonction

On peut aussi créer sa propre fonction. Une nouvelle fonction est créée par une construction de la forme :

                    fun.name <- function( arglist ) {
                    expr
                    } 

avec :

  • fun.name : le nom d’un objet où est stockée la fonction.
  • arglist : une liste d’arguments formels séparés par des virgules.
  • expr : un bloc d’expressions (code R) se terminant typiquement par return(val) qui arrête la fonction et renvoie la valeur val.

Voici une fonction qui calcule l’indice de masse corporelle (imc) :

imcF <- function(tail, poi, d = 2) {
    tail.m <- tail/100
    imc <- poi/(tail.m^d)
    return(imc)
}
tailles <- c(167, 192, 173, 174, 172, 167, 171, 185, 163, 170)
poids <- c(86, 74, 83, 50, 78, 66, 66, 51, 50, 55)
imcF(tailles, poids)
 [1] 30.837 20.074 27.732 16.515 26.366 23.665 22.571 14.901 18.819 19.031

3.2 Les scripts

Jusqu’à maintenant nous avons utilisé uniquement la console pour communiquer avec R via l’invite de commandes.

Le principal problème de ce mode d’interaction est qu’une fois qu’une commande est tapée, elle est pour ainsi dire « perdue », c’est-à-dire qu’on doit la saisir à nouveau si on veut l’exécuter une seconde fois.

L’utilisation de la console est donc restreinte aux petites commandes « jetables », le plus souvent utilisées comme test.

La plupart du temps, les commandes seront stockées dans un fichier à part, que l’on pourra facilement ouvrir, éditer et exécuter entièrement ou en partie si besoin. On appelle en général ce type de fichier un script.

Créer un nouveau script

Pour créer un nouveau script R, faire : File > New file > R Script.

Une nouvelle fenêtre (vide) apparaît. Nous pouvons désormais y saisir des commandes.

Exemple : Dans un nouveau script R, tapez :

## 1. Mes données ----------------------------------
#---------------------------------------------------

tailles <- c(156, 164, 197, 147, 173)
poids <- c(45, 59, 110, 44, 88)

## 2. Traitement des données -----------------------
#---------------------------------------------------

tailles <- sort(tailles)
poids <- sort(poids)

## 3. Indice de Masse Corporelle -------------------
#---------------------------------------------------

IMC <- poids/((tailles/100)^2)

## 4. Ma Fonction ---------------------------------
#---------------------------------------------------

imcF <- function(tail, poi, d = 2) {
    tail.m <- tail/100
    imc <- poi/(tail.m^d)
    return(imc)
}

## 5.a Résultats A---------------------------------
#--------------------------------------------------

IMC

## 5.b Résultats B---------------------------------
#--------------------------------------------------

imcF(tailles, poids)

Il est très important de documenter son code R au fur et à mesure, faute de quoi on risque de ne plus y comprendre grand chose si on le reprend ne serait-ce que quelques semaines plus tard.

Manipuler un script

  • Pour exécuter une ou plusieurs lignes de code, sélectionnez les lignes en question puis cliquez sur l’icône Run.

  • Pour exécuter tout le contenu d’un script, cliquez sur l’icône Source.

  • Pour sauvegarder votre script, faire : File > Save. Et vous choisissez un nom (par exemple code.R) et un emplacement pour votre fichier.

  • Vous pouvez ouvrir un script existant à l’aide du menu Rstudio: File > Open File

  • Vous pouvez aussi modifier, supprimer ou partager votre fichier librement!

Au sein d’un même projet, on peut avoir plusieurs scripts R (File > New file > R Script). Cela permet de mieux organiser son code.

Il est possible d’appeler un script, sans l’ouvrir, à l’aide de la fonction source à laquelle on précisera le nom et le chemin complet du fichier du script en question

source("D:/LMAT1152/code.R")

Si le fichier “code.R” se trouve dans le répertoire “LMAT1152” du disque (partition) “D”.

Noter qu’en R, pour indiquer les chemins d’accès à un fichier il faut toujours utiliser / (forward Slash) ou \\ et non pas \ (backslash).

Si le fichier “code.R” est dans votre répertoire de travail (voir la section suivante), alors il suffit d’écrire

source("code.R")

Vous pouvez aussi “sourcer” un fichier à l’aide du menu Rstudio: Code > Source File

Le répertoire de travail

R a parfois besoin de lire ou d’écrire dans des fichiers externes. Il le fait par exemple :

  • lors de l’importation de données provenant d’un fichier externe;
  • lors de l’enregistrement ou l’appel d’un script.

R se définit un emplacement par défaut pour ces fichiers. Cet emplacement porte le nom de working directory.

Lorsqu’aucun emplacement (chemin) n’est spécifié lors d’une communication entre R et un fichier externe, R considérera par défaut que le fichier se trouve dans le répertoire courant.

Pour connaître le répertoire de travail actuel, on utilise la fonction getwd :

getwd()

Remarquez que cette fonction n’a pas de paramètres obligatoires.

  • Sous RStudio, le nom de votre répertoire de travail est affiché dans le quadrant inférieur gauche, en gris, à la droite du mot Console.

  • Le contenu de votre répertoire de travail est également affiché dans le quadrant inférieur droite, sous la rubrique “Files”.

  • Le répertoire de travail peut être modifié avec la fonction setwd ou via le menu Session > Set Working Directory.

3.3 Packages – Extensions

L’installation par défaut du logiciel R contient le cœur du programme ainsi qu’un ensemble de fonctions de base.

R étant un logiciel libre, il bénéficie d’une forte communauté d’utilisateurs pouvant librement contribuer au développement du logiciel en lui ajoutant des fonctionnalités supplémentaires. Ces contributions prennent la forme d’extensions (packages) pouvant être installées par l’utilisateur et fournissant alors diverses fonctions supplémentaires.

Avant tout, sachez que, par défaut, R vient charger avec un certain nombre de packages. Pour les connaître, taper la commande suivante.

getOption("defaultPackages")
[1] "datasets"  "utils"     "grDevices" "graphics"  "stats"     "methods"  

Installer et charger un package

Pour installer un nouveau package (à partir du CRAN, le(s) serveur officiel de R), il suffit de s’assurer d’être connecté à internet et puis utiliser le menu Package dans le quadrant bas-droite de Rstudio.

Cliquer sur Install et indiquer le nom de l’extension dans le champ Package.

Vous pouvez aussi taper la commande

install.packages("nom.package")

nom.package est le nom du package à instlaller.

R va alors télécharger l’ensemble des fichiers nécessaires sur le disque dur de votre ordinateur (taper la commande .libPaths( ) pour aficher le(s) dossier(s) d’installation).

Taper la commande suivante pour installer le package ggplot2:

install.packages("ggplot2")

ggplot permet la production de graphiques très élaborés en peu de temps.

Vous pouvez avoir de l’aide sur un package avec help(package = nom.package) et/ou package?nom.package. Exemple:

help(package = ggplot2)
`?`(package, ggplot2)

Une fois l’extension installée, elle peut être chargée (appelée) en cochant son nom dans la liste de packages disponibles (voir rubrique Packages dans le quadrant bas-droite de Rstudio)

ou avec la commande library(nom.package) ou require(nom.package), où “nom.package” est le nom du package à charger.

Exemple: taper la commande suivante

require("ggplot2")

Une fois l’extension chargée, on peut utiliser les fonctions de l’extension, consulter leur page d’aide en ligne, accéder aux jeux de données qu’elle contient, etc. durant la session en cours.

Il est important de bien comprendre la différence entre install.packages et library:

  • La première va chercher les extensions sur internet et les installe en local sur le disque dur de l’ordinateur. On n’a besoin d’effectuer cette opération qu’une seule fois.

  • La seconde lit les informations de l’extension sur le disque dur et les met à disposition de R. On a besoin de l’exécuter à chaque début de session.

Pour continuer, installer maintenant le package tidyverse.

tidyverse est une contraction de tidy (qu’on pourrait traduire par “bien rangé”) et de universe. Il s’agit d’une collection d’extensions conçues pour travailler ensemble et basées sur une philosophie commune.

La commande install.packages("tidyverse") va en fait installer plusieurs extensions qui constituent le “coeur” du tidyverse, à savoir :

  • ggplot2 (visualisation)
  • dplyr (manipulation des données)
  • tidyr (remise en forme des données)
  • purrr (programmation)
  • readr (importation de données)
  • tibble (tableaux de données)
  • forcats (variables qualitatives)
  • stringr (chaînes de caractères)

Pour savoir plus, voir tidyverse

Pour la suite, le package tidyverse doit être installé sur votre machine. Aussi assurez-vous de le charger.

3.4 Exercices

Exercice 1

Calculer le revenu minimum et maximum parmi ceux du vecteur suivant.

conjoint1 <- c(1200, 1180, 1750, 2100)
c(min(conjoint1), max(conjoint1))
# ou
range(conjoint1)

Recommencer avec le vecteur suivant.

conjoint1 <- c(1200, 1180, 1750, NA)
range(conjoint1, na.rm = TRUE)

Exercice 2

À l’aide des fonctions :, rep, seq et c seulement, générer les séquences suivantes.

0 6 0 6 0 6
1 4 7 10
1 2 3 1 2 3 1 2 3 1 2 3
1 1 1 2 2 3
rep(c(0, 6), 3)
seq(1, 10, by = 3)
rep(1:3, 1:3)
rep(1:3, 3:1)

Exercice 3

  1. Créer un vecteur v1 qui va de 1 à −1 par pas de −0.25.
  2. Créer un vecteur v2 qui va de 0 à 100 d’une longueur de 23.
  3. Créer un vecteur v3 qui contient les chaînes : “1ère année”, “2ème année”, “LP”.
  4. Créer un vecteur v4 qui répéte trois fois la chaîne “promo”.
  5. Regrouper les vecteurs v3 et v4, pour avoir le vecteur v5 suivant: "promo=1ère année" "promo=2ème année" "promo=LP"
v1 <- seq(1, -1, by = -0.25)
v2 <- seq(0, 100, length = 23)
v3 <- c("1ère année", "2ème année", "LP")
v4 <- rep("promo", 3)
v5 <- paste(v4, v3, sep = "=")