web-dev-qa-db-fra.com

Charger plusieurs paquets à la fois

Comment puis-je charger un paquet de paquets à la fois sans retaper la commande require à plusieurs reprises? J'ai essayé trois approches, toutes qui plantent et brûlent.

En gros, je veux fournir un vecteur de noms de paquetages à une fonction qui les chargera.

x<-c("plyr", "psych", "tm")

require(x)
lapply(x, require)
do.call("require", x)
rpackages
152
Tyler Rinker

Plusieurs permutations de vos fonctions proposées fonctionnent - mais seulement si vous spécifiez le character.only argument pour être TRUE. Exemple rapide:

lapply(x, require, character.only = TRUE)
221
daroczig

Le package CRAN pacman que je maintiens (écrit avec Dason Kurkiewicz) peut accomplir cela:

Pour que l'utilisateur puisse faire:

## install.packages("pacman")
pacman::p_load(dplyr, psych, tm)

et si le paquet est manquant p_load le téléchargera à partir de CRAN ou de Bioconductor.

50
Tyler Rinker

Cela devrait faire l'affaire:

lapply(x, FUN = function(X) {
    do.call("require", list(X)) 
})

(Le bit clé est que l'argument args de do.call(what, args)doit soit une liste --- même s'il ne comporte qu'un seul élément!)

23
Josh O'Brien

pour quelqu'un qui veut installer et charger des paquets simultanément, je suis tombé sur cette fonction dans le lien ci-dessous https://Gist.github.com/stevenworthington/317816

# ipak function: install and load multiple R packages.
# check to see if packages are installed. Install them if they are not, then load them into the R session.

ipak <- function(pkg){
new.pkg <- pkg[!(pkg %in% installed.packages()[, "Package"])]
if (length(new.pkg)) 
    install.packages(new.pkg, dependencies = TRUE)
sapply(pkg, require, character.only = TRUE)
}

# usage
packages <- c("ggplot2", "plyr", "reshape2", "RColorBrewer", "scales", "grid")
ipak(packages)
11
bala

Une option alternative vient du paquetage easypackages. Une fois installé, vous pouvez charger les paquets de la manière la plus intuitive possible:

libraries("plyr", "psych", "tm")

Le paquet inclut également une fonction pour installer plusieurs paquets:

packages("plyr", "psych", "tm")

Référence ici .

7
luchonacho

Vous pouvez simplement utiliser le paquet lubripack, qui installe proprement de nouveaux paquets, puis les charge tous sur une seule ligne.

lubripack("plyr", "psych", "tm")

Voici la sortie après avoir exécuté le code ci-dessus dans RStudio.

enter image description here

Comment installer le paquet:

Exécutez le code ci-dessous pour télécharger le package et l'installer à partir de GitHub. Pas besoin d'avoir un compte GitHub.

library(devtools)
install_github("espanta/lubripack")
4
Espanta

En vous appuyant sur la solution de daroczig, si vous ne souhaitez pas spécifier de liste en entrée, vous pouvez utiliser

# Foo
mLoad <- function(...) {
  sapply(sapply(match.call(), as.character)[-1], require, character.only = TRUE)
}

# Example 
mLoad(plyr, dplyr, data.table)

... qui est plus court que

lapply(list('plyr', 'dplyr', 'data.table'), require, character.only = TRUE)
3
goclem

J'utilise la fonction suivante:

mrip <- function(..., install = TRUE){
    reqFun <- function(pack) {
        if(!suppressWarnings(suppressMessages(require(pack, character.only = TRUE)))) {
            message(paste0("unable to load package ", pack,
                           ": attempting to download & then load"))
            install.packages(pack)
            require(pack, character.only = TRUE)
        }
    }
    lapply(..., reqFun)
}

Cela tente de charger, et si cela échoue, installe, puis essayez de charger à nouveau.

2
ricardo

Léger mod de la réponse de Tyler Rinker pour ajouter une vérification pour installer et charger pacman:

#Install/load pacman
if(!require(pacman)){install.packages("pacman");require(pacman)}
#Install/load tons of packages
p_load(plyr,psych,tm)

J'aime la solution p_load car elle évite de citer!

0
mattador

Je pense que le code fourni par @daroczig peut être amélioré en remplaçant le require par library et en encapsulant l'appel lapply à l'intérieur de la fonction invisible(). Ainsi, le code amélioré ressemblera à ceci:

invisible(lapply(x, library, character.only = TRUE))

Ce code est amélioré car:

  1. library() est généralement préférable à require() pour le chargement de packages, car le premier génère une erreur si le package n'est pas installé, alors que le dernier ne donne qu'un avertissement. De plus, require() appelle library(), alors pourquoi ne pas utiliser library() directement!

    library("time")
# Error in library("time") : there is no package called ‘time’

require("time")
# Loading required package: time
# Warning message:
# In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
# there is no package called ‘time’

  2. L'objet de liste renvoyé et imprimé par l'appel lapply() n'a pas de signification dans ce cas, il est donc logique de rendre la sortie invisible. Supposons que vous utilisiez R Notebook pour votre travail d'analyse. L'utilisation de la fonction invisible() supprime le contenu de l'objet de liste et évite l'encombrement du fichier rendu.

0
Ashirwad