Packages (R Package)

3.1 Qu'est-ce qu'un package dans R ?

Un package contient des fonctions qui facilitent votre travail et le rendent plus efficace. Les packages sont donc des extensions de R qui en élargissent les fonctionnalités. Même si l'installation standard de R comporte de nombreux outils puissants, ceux-ci ne suffisent pas pour travailler de manière efficace et confortable. Vous devez installer des packages, qui rendent le travail à la fois plus agréable et plus simple. On compte actuellement environ 18 810 packages. Vous pouvez installer n'importe quel package en quelques secondes. Les packages sont validés par des experts. Tous les packages sont en code source ouvert, que vous pouvez examiner quand vous le souhaitez (ce que les débutants font rarement).

3.1.1 Exemples de packages R populaires

• ggplot2 pour la visualisation des données.
• dplyr pour la manipulation des données.
• tidyr pour la manipulation des données.
• survival pour l'analyse de survie.
• tidymodels pour créer, comparer et évaluer des modèles de prédiction.
• forcats pour gérer les variables catégorielles.
• stringr pour gérer les chaînes de caractères.
• purrr pour rendre l'utilisation des fonctions plus efficace.

3.1.2 Comment installer des packages dans R

Installer et activer un package

Un package ne s'installe qu'une seule fois. Après l'installation, le package est disponible pour R. Pour utiliser le package, vous devez l'activer à chaque démarrage de R.

Avant d'utiliser un package, vous devez l'installer puis l'activer. Un package ne s'installe qu'une seule fois, mais il doit être activé à chaque démarrage de R. L'installation standard de R comprend plusieurs packages préinstallés. Ces packages contiennent les fonctions les plus élémentaires, par exemple les opérations mathématiques de base.

Pour installer un package, on utilise la fonction [install.packages()](https://rdrr.io/r/utils/install.packages.html). Ci-dessous, on installe le package dplyr. Notez que le nom du package s'écrit entre guillemets :

install.packages("dplyr")

3.1.3 Comment mettre à jour un package R.

Même si vous n'installez le package qu'une seule fois, vous pouvez avoir besoin de le mettre à jour. Les mises à jour sont moins fréquentes et, pour la plupart des packages, une ou deux mises à jour par an suffisent. Mettez à jour le package avec la commande suivante :

update.packages("dplyr")

Vous pouvez également mettre à jour un package en le réinstallant (R écrase alors l'ancienne version du package).

3.1.4 Code breaking updates

La grande majorité des mises à jour de packages sont conçues de sorte que le code ancien (existant) continue de fonctionner normalement. Cela signifie que votre code continuera très probablement de fonctionner après la mise à jour d'un package. Les mises à jour peuvent donc être effectuées sans trop d'inquiétude. Il arrive toutefois que des modifications plus importantes soient apportées à un package, ce qui peut empêcher votre code de fonctionner après une mise à jour. En anglais, on parle de code breaking updates. Vous devez soupçonner ce cas de figure si votre code renvoie des messages d'erreur après une mise à jour. Il est presque toujours facile de résoudre ces problèmes en consultant la documentation mise à jour du package. En règle générale, de très légers ajustements du code suffisent pour qu'il fonctionne à nouveau.

3.1.5 Installer des packages sans commande

Vous pouvez installer des packages dans R sans écrire de commande. Ce n'est pas recommandé, car toutes les opérations et commandes devraient être documentées dans l'ordre chronologique dans le code. Par souci d'exhaustivité, voici néanmoins comment installer des packages sans code. Dans l'exemple ci-dessous (voir la figure 3.1), nous installons le package rms :

1. Cliquez sur l'onglet Packages dans la fenêtre en bas à droite.
2. Cliquez sur Install en haut à gauche.
3. Saisissez le nom du package (rms) dans le champ de recherche.
4. Cliquez sur Install.

Pour poursuivre ce cours, nous devons installer plusieurs packages. Vous pouvez installer plusieurs packages en répétant la fonction [install.packages()](https://rdrr.io/r/utils/install.packages.html) sur plusieurs lignes, comme suit :

install.packages("dplyr")
install.packages("ggplot2")
install.packages("rms")
install.packages("tidymodels")

Le code ci-dessus enfreint cependant le principe DRY, qui signifie Don’t Repeat Yourself. Lorsque vous programmez, vous devez réduire au minimum les répétitions. Un bon code est concis et ne contient pas de répétitions. Nous créons donc maintenant un vecteur contenant les noms des packages, et dans la fonction [install.packages()](https://rdrr.io/r/utils/install.packages.html) nous indiquons uniquement le nom du vecteur.

Notez que, dans le code ci-dessous, certaines lignes commencent par #, ce qui signifie qu'il s'agit de commentaires. Un commentaire est simplement une note qui explique le code afin que vous et vos collaborateurs puissiez le comprendre. Le commentaire n'est pas évalué par R.

## La fonction c() crée un vecteur contenant les packages à installer
new_packages <- c("dplyr", "ggplot2", "rms", "tidymodels")

## installe les packages
install.packages(new_packages)

Nous aurions pu raccourcir davantage en sautant l'étape de création du vecteur, comme suit :

install.packages(c("dplyr", "ggplot2", "rms", "tidymodels"))

Cette dernière variante est concise et ne contient aucune répétition. Notez également que, dans ce dernier exemple, nous avons laissé une fonction ([install.packages()](https://rdrr.io/r/utils/install.packages.html)) englober une autre fonction ([c()](https://rdrr.io/r/base/c.html)). C'est tout l'attrait de R, à savoir la possibilité d'imbriquer des fonctions dans d'autres fonctions. Vous découvrirez par la suite que cela permet des opérations puissantes.

3.1.6 Charger des packages dans R

Chaque fois que vous démarrez R, une nouvelle session est créée. Cela implique ce qui suit :

1. Votre Environment est vide.
2. Seuls quelques packages de l'installation standard sont activés.

C'est pourquoi chaque script commence généralement par quelques lignes qui activent les packages à utiliser. Cela peut par exemple ressembler à la figure 3.2. Notez que les packages se chargent avec la fonction [library()](https://rdrr.io/r/base/library.html).

Notez que les guillemets ne sont pas nécessaires pour charger un package !

3.1.7 Erreur lors de l'activation d'un package

R renvoie une erreur si vous essayez de charger un package qui n'est pas installé. Nous allons maintenant essayer de charger un package appelé polish, qui n'est pas installé :

library(polish)

Error in library(polish): there is no package called 'polish'

3.1.7.1 Activation réussie d'un package

R renvoie un message lorsqu'un package a été chargé. Ce message peut contenir des informations importantes. Lors du chargement du package dplyr, on voit les informations suivantes :

library(dplyr)

Attaching package: ‘dplyr’

The following objects are masked from ‘package:stats’:

    filter, lag

The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union

Le message ci-dessus contient des informations importantes. Vous verrez souvent des messages similaires et devez y prêter attention. Le message indique ce qui suit :

• Les fonctions [filter()](https://dplyr.tidyverse.org/reference/filter.html) et lag() du package stats sont masquées.
• Les fonctions [intersect()](https://generics.r-lib.org/reference/setops.html), [setdiff()](https://generics.r-lib.org/reference/setops.html), [setequal()](https://generics.r-lib.org/reference/setops.html) et [union()](https://generics.r-lib.org/reference/setops.html) du package base sont masquées.

Cela signifie que, si vous utilisez désormais la fonction [filter()](https://dplyr.tidyverse.org/reference/filter.html), vous utilisez la fonction [filter()](https://dplyr.tidyverse.org/reference/filter.html) du package dplyr, et il en va de même pour les autres fonctions masquées par dplyr. Vous pouvez néanmoins toujours utiliser les fonctions masquées, mais vous devez pour cela indiquer le nom du package avant le nom de la fonction, comme suit :

stats::filter()
stats::lag()

base::intersect()
base::setdiff()
base::setequal()
base::union()

C'est ainsi que l'on indique explicitement à R quelle fonction on souhaite utiliser. Notez les deux deux-points (:) entre le nom du package et celui de la fonction.

Fonctions masquées

Lors de l'activation d'un package, des fonctions d'autres packages peuvent être masquées. Cela tient en général au fait que les fonctions des différents packages portent le même nom. Pour utiliser des fonctions masquées, le nom de la fonction doit être précédé du nom du package et de deux deux-points (:).

3.1.7.2 Erreur lors de l'utilisation de fonctions de packages non activés

R renvoie une erreur si vous essayez d'utiliser des fonctions de packages qui ne sont pas chargés. Dans l'exemple ci-dessous, nous essayons d'utiliser la fonction splined(), qui se trouve dans un package actuellement non activé.

## Nous allons rechercher le chiffre 5 dans une suite de 9 chiffres
## Les chaînes peuvent être détectées avec la fonction str_detect()
str_detect(string ='1 2 3 4 5 6 7 8 9',
           pattern = '5')

Error in str_detect(string = "1 2 3 4 5 6 7 8 9", pattern = "5") :
  could not find function "str_detect"

Ce message d'erreur signifie simplement que R ne trouve la fonction dans aucun des packages actuellement activés. Pour y remédier, vous devez soit activer le package (avec la fonction [library()](https://rdrr.io/r/base/library.html)), soit indiquer le nom du package (et deux deux-points) avant le nom de la fonction, comme suit :

stringr::str_detect(string ='1 2 3 4 5 6 7 8 9', pattern = '5')

[1] TRUE

3.1.8 Pacman charge et installe plusieurs packages à la fois

R ne dispose d'aucune fonction intégrée pour activer plusieurs packages à la fois. Heureusement, la fonction p_load() du package pacman permet d'activer plusieurs packages simultanément et, en outre, d'installer les packages manquants.

Installez pacman avec la commande suivante :

install.packages("pacman")

Vous pouvez ensuite activer plusieurs packages à la fois avec p_load(). S'il vous manque l'un des packages, pacman l'installera :

p_load(survival, ggplot2, lubridate)

3.1.9 Autres packages R

Tous les packages examinés et approuvés se trouvent sur le CRAN.

• Tous les packages R sur le CRAN, par ordre alphabétique.
• Tous les packages R sur le CRAN, par thème

3.2.0 Tidyverse : un package révolutionnaire

R a traditionnellement été considéré comme un langage difficile. On le comprend assez facilement lorsqu'on constate à quel point il peut être fastidieux d'effectuer une opération aussi triviale que filtrer les lignes d'un tableau. Supposons que vous disposiez d'un tableau contenant des observations sur des hommes et des femmes et que vous ne souhaitiez conserver que les hommes pour la suite des analyses. En code R traditionnel, cela s'écrit comme suit :

my_data_frame[my_data_frame$Sex == 'Male',]

• **my_data_frame** est le nom de notre data frame
• Sex est une colonne de notre data frame
• Le symbole **$** sert à faire référence à une colonne d'un data frame.
  • **my_data_frame$Sex** signifie que nous voulons utiliser la colonne Sex de **my_data_frame**.
  • Nous utilisons des crochets (**[]**) pour filtrer les lignes de sorte que tous les Males soient conservés.
  • Dans les crochets, nous écrivons une virgule (**,**) après Males pour préciser que ce sont des lignes que nous filtrons. Après la virgule, on n'écrit rien, à moins de vouloir aussi sélectionner des colonnes).

C'est l'un des nombreux exemples de code R que la plupart des gens ont du mal à écrire et à lire. Le tidyverse contient des packages qui simplifient la programmation en R. En fait, le tidyverse permet à n'importe qui de lire et d'écrire du code R. Voici le même code avec dplyr, l'un des packages inclus dans le tidyverse :

filter(my_data_frame, Sex=="Males")

Le code ci-dessus est facile à écrire et facile à comprendre. Pour installer le tidyverse, saisissez la commande suivante :

install.packages("tidyverse")

Cette commande télécharge et installe le tidyverse depuis le CRAN. Le package tidyverse contient plusieurs packages :

• ggplot2
• tibble
• tidyr
• readr
• purrr
• dplyr

3.2.0 Bioconductor : des packages pour la recherche médicale

Bioconductor est probablement le logiciel le plus utilisé au monde pour les calculs et les analyses en recherche médicale fondamentale. Bioconductor se compose d'un grand nombre de packages spécialement développés pour la recherche médicale. Vous trouverez ici la liste complète des packages.

Installer des packages depuis Bioconductor

Les packages de base de Bioconductor s'installent avec la commande suivante :

if (!require("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
BiocManager::install()

Installez des packages spécifiques, par exemple « GenomicFeatures » et « AnnotationDbi », avec la commande :

BiocManager::install(c("GenomicFeatures", "AnnotationDbi"))

Si vous avez installé Bioconductor, vous pouvez également lister tous les packages disponibles avec la commande :

BiocManager::available()

3.2.1 ROpenSci

ROpenSci réunit des chercheurs et des développeurs de logiciels expérimentés qui développent eux aussi des packages spécialement destinés à la recherche médicale. Cliquez ici pour voir l'ensemble des packages.