R Language
Installer des paquets

Syntaxe

• install.packages (pkgs, lib, repos, méthode, destdir, dépendances, ...)

Paramètres

Remarques

Téléchargez et installez des packages à partir de référentiels

Les packages sont des collections de fonctions R, de données et de code compilé dans un format bien défini . Les référentiels publics (et privés) sont utilisés pour héberger des collections de packages R. La plus grande collection de packages R est disponible auprès de CRAN.

Utiliser CRAN

Un package peut être installé à partir de CRAN en utilisant le code suivant:

install.packages("dplyr")

Où "dplyr" est appelé un vecteur de caractères.

Vous pouvez installer plusieurs packages en une seule fois en utilisant la fonction de combinaison c() et en passant une série de vecteurs de caractères de noms de packages:

install.packages(c("dplyr", "tidyr", "ggplot2"))

Dans certains cas, install.packages peut demander un miroir CRAN ou échouer, en fonction de la valeur de getOption("repos") . Pour éviter cela, spécifiez un miroir CRAN comme argument de repos :

install.packages("dplyr", repos = "https://cloud.r-project.org/") 

En utilisant l'argument repos , il est également possible d'installer à partir d'autres référentiels. Pour des informations complètes sur toutes les options disponibles, exécutez ?install.packages .

La plupart des paquets nécessitent des fonctions, qui ont été implémentées dans d'autres packages (par exemple, le package data.table ). Pour installer un package (ou plusieurs packages) avec tous les packages utilisés par ce package, les dependencies argument doivent être définies sur TRUE ):

install.packages("data.table", dependencies = TRUE)

Utilisation du bioconducteur

Bioconductor héberge une importante collection de paquets liés à la bioinformatique. Ils fournissent leur propre gestion de paquet centrée autour de la fonction biocLite :

    ## Try http:// if https:// URLs are not supported
    source("https://bioconductor.org/biocLite.R")
    biocLite()

Par défaut, cela installe un sous-ensemble de packages fournissant les fonctionnalités les plus couramment utilisées. Des packages spécifiques peuvent être installés en transmettant un vecteur de noms de packages. Par exemple, pour installer RImmPort partir de Bioconductor:

    source("https://bioconductor.org/biocLite.R")
    biocLite("RImmPort")

Installer le paquet depuis une source locale

Pour installer le package à partir du fichier source local:

install.packages(path_to_source, repos = NULL, type="source")

install.packages("~/Downloads/dplyr-master.zip", repos=NULL, type="source")

Ici, path_to_source est le chemin absolu du fichier source local.

Une autre commande qui ouvre une fenêtre pour choisir les fichiers sources téléchargés zip ou tar.gz est:

install.packages(file.choose(), repos=NULL)

Un autre moyen possible est d'utiliser RStudio basé sur une interface graphique :

Étape 1: Aller aux outils .

Étape 2: allez à l' installation des packages .

Étape 3: Dans le programme d' installation à partir de le définir comme fichier archive de package (.zip; .tar.gz)

Étape 4: Ensuite Parcourir trouvez votre fichier de package ( par exemple crayon_1.3.1.zip) et après un certain temps (après montre le chemin du paquet et le nom de fichier dans l'onglet Archive Package)

Une autre façon d'installer le paquet R à partir d'une source locale consiste à utiliser la fonction install_local() du paquet devtools.

library(devtools)
install_local("~/Downloads/dplyr-master.zip")

Installer des paquets depuis GitHub

Pour installer les paquets directement depuis GitHub, utilisez le paquet devtools :

library(devtools)
install_github("authorName/repositoryName")

Pour installer ggplot2 depuis github:

devtools::install_github("tidyverse/ggplot2")

La commande ci - dessus installera la version de ggplot2 qui correspond à la branche principale. Pour installer à partir d'une branche différente d'un référentiel, utilisez l'argument ref pour fournir le nom de la branche. Par exemple, la commande suivante installera la dev_general branche du googleway paquet.

devtools::install_github("SymbolixAU/googleway", ref = "dev_general")

Une autre option consiste à utiliser le package ghit . Il fournit une alternative légère à l'installation de paquets à partir de github:

install.packages("ghit")
ghit::install_github("google/CausalImpact")

Pour installer un package qui se trouve dans un référentiel privé sur Github, générez un jeton d'accès personnel à l' adresse http://www.github.com/settings/tokens/ (voir? Install_github pour la documentation sur le même). Suivez ces étapes:

1. install.packages(c("curl", "httr"))
   

2. config = httr::config(ssl_verifypeer = FALSE)
   

3.  install.packages("RCurl")
    options(RCurlOptions = c(getOption("RCurlOptions"),ssl.verifypeer = FALSE, ssl.verifyhost = FALSE ) )
   

4. getOption("RCurlOptions")
   

   Vous devriez voir ce qui suit:

   ssl.verifypeer ssl.verifyhost 
       
   FALSE          FALSE 
   

5. library(httr)
   set_config(config(ssl_verifypeer = 0L)) 
   

   Cela évite l'erreur commune: "Le certificat homologue ne peut pas être authentifié avec des certificats CA donnés"

6. Enfin, utilisez la commande suivante pour installer votre package de manière transparente

   install_github("username/package_name",auth_token="abc")
   

Vous pouvez également définir une variable d'environnement GITHUB_PAT en utilisant

Sys.setenv(GITHUB_PAT = "access_token")
devtools::install_github("organisation/package_name")

Le PAT généré dans Github n'est visible qu'une seule fois, c.-à-d. Lorsqu'il est créé initialement, il est donc prudent de sauvegarder ce jeton dans .Rprofile . Cela est également utile si l'organisation dispose de nombreux référentiels privés.

Utilisation d'un gestionnaire de paquets CLI - Utilisation de base de pacman

pacman est un gestionnaire de paquets simple pour R.

pacman permet à un utilisateur de charger de manière compacte tous les paquets souhaités, en installant ceux qui manquent (et leurs dépendances), avec une seule commande, p_load . pacman n'exige pas que l'utilisateur tape des guillemets autour d'un nom de package. L'utilisation de base est la suivante:

p_load(data.table, dplyr, ggplot2)

Le seul paquet nécessitant une instruction library , require ou install.packages avec cette approche est pacman lui-même:

library(pacman)
p_load(data.table, dplyr, ggplot2)

ou, également valable:

pacman::p_load(data.table, dplyr, ggplot2)

En plus de gagner du temps en exigeant moins de code pour gérer les paquets, pacman facilite également la construction de code reproductible en installant tous les paquets nécessaires si et seulement s'ils ne sont pas déjà installés.

Comme vous ne savez peut-être pas si pacman est installé dans la bibliothèque d'un utilisateur qui utilisera votre code (ou vous-même dans de futures utilisations de votre propre code), il est pacman d'inclure une instruction conditionnelle pour installer pacman si ce n'est pas déjà fait. chargé:

if(!(require(pacman)) install.packages("pacman")
pacman::p_load(data.table, dplyr, ggplot2)

Installer la version de développement local d'un package

Tout en travaillant sur le développement d'un package R, il est souvent nécessaire d'installer la dernière version du package. Cela peut être réalisé en construisant d'abord une distribution source du paquet (sur la ligne de commande)

R CMD build my_package

puis en l' installant dans R. Toutes les sessions R en cours d'exécution avec la version précédente du package chargé devront le recharger.

unloadNamespace("my_package")
library(my_package)

Une approche plus pratique utilise le package devtools pour simplifier le processus. Dans une session R avec le répertoire de travail défini sur le répertoire du package

devtools::install()

va construire, installer et recharger le paquet.