R Language
Installer des paquets
Recherche…
Syntaxe
- install.packages (pkgs, lib, repos, méthode, destdir, dépendances, ...)
Paramètres
Paramètre | Détails |
---|---|
pkgs | vecteur de caractères des noms de paquets. Si repos = NULL , un vecteur de caractères des chemins de fichiers. |
lib | vecteur de caractères donnant les répertoires de la bibliothèque où installer les paquets. |
repos | vecteur de caractères, l'URL de base des référentiels à utiliser peut être NULL à installer à partir de fichiers locaux |
méthode | méthode de téléchargement |
destdir | répertoire où les paquets téléchargés sont stockés |
dépendances | logique indiquant s'il faut également installer les packages désinstallés dont dépendent ces packages / link to / import / suggest (et ainsi de suite récursivement). Non utilisé si repos = NULL . |
... | Arguments à transmettre à "download.file" ou aux fonctions pour les installations binaires sous OS X et Windows. |
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:
install.packages(c("curl", "httr"))
config = httr::config(ssl_verifypeer = FALSE)
install.packages("RCurl") options(RCurlOptions = c(getOption("RCurlOptions"),ssl.verifypeer = FALSE, ssl.verifyhost = FALSE ) )
getOption("RCurlOptions")
Vous devriez voir ce qui suit:
ssl.verifypeer ssl.verifyhost FALSE FALSE
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"
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.