Elegante Möglichkeit, nach fehlenden Paketen zu suchen und diese zu installieren?

Ich scheine heutzutage viel Code mit Mitautoren zu teilen. Viele von ihnen sind Anfänger / Fortgeschrittene und wissen nicht, dass sie Pakete installieren müssen, die sie noch nicht haben.

Gibt es eine elegante Möglichkeit zum Aufrufen installed.packages(), vergleichen Sie diese mit denen, die ich lade und installiere, wenn sie fehlen?

Ja. Wenn Sie eine Paketliste haben, vergleichen Sie diese mit der Ausgabe von installed.packages()[,"Package"]und installieren Sie die fehlenden Pakete. Etwas wie das:

list.of.packages <- c("ggplot2", "Rcpp")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages)) install.packages(new.packages)

Andernfalls:

Wenn Sie Ihren Code in ein Paket einfügen und diese abhängig machen, werden sie automatisch installiert, wenn Sie Ihr Paket installieren.

Dason K. und ich haben das Pacman- Paket, das das gut kann. Die Funktion p_loadim Paket erledigt dies. Die erste Zeile soll nur sicherstellen, dass Pacman installiert ist.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(package1, package2, package_n)

Sie können einfach den Rückgabewert von verwenden require:

if(!require(somepackage)){
    install.packages("somepackage")
    library(somepackage)
}

Ich verwende librarynach der Installation, weil es eine Ausnahme auslöst, wenn die Installation nicht erfolgreich war oder das Paket aus einem anderen Grund nicht geladen werden kann. Sie machen dies robuster und wiederverwendbarer:

dynamic_require <- function(package){
  if(eval(parse(text=paste("require(",package,")")))) return True

  install.packages(package)
  return eval(parse(text=paste("require(",package,")")))
}

Der Nachteil dieser Methode ist, dass Sie den Paketnamen in Anführungszeichen setzen müssen, was Sie nicht wirklich tun require.

if (!require('ggplot2')) install.packages('ggplot2'); library('ggplot2')

"ggplot2" ist das Paket. Es wird überprüft, ob das Paket installiert ist. Wenn dies nicht der Fall ist, wird es installiert. Anschließend wird das Paket geladen, unabhängig davon, welchen Zweig es verwendet hat.

Diese Lösung verwendet einen Zeichenvektor mit Paketnamen und versucht, diese zu laden oder zu installieren, wenn das Laden fehlschlägt. Es hängt vom Rückgabeverhalten ab require, dies zu tun, weil ...

require Gibt (unsichtbar) eine logische Angabe zurück, ob das erforderliche Paket verfügbar ist

Daher können wir einfach sehen, ob wir das erforderliche Paket laden konnten, und wenn nicht, installieren Sie es mit Abhängigkeiten. Geben Sie also einen Zeichenvektor für Pakete an, die Sie laden möchten ...

foo <- function(x){
  for( i in x ){
    #  require returns TRUE invisibly if it was able to load package
    if( ! require( i , character.only = TRUE ) ){
      #  If package was not able to be loaded then re-install
      install.packages( i , dependencies = TRUE )
      #  Load package after installing
      require( i , character.only = TRUE )
    }
  }
}

#  Then try/install packages...
foo( c("ggplot2" , "reshape2" , "data.table" ) )

Viele der obigen Antworten (und Duplikate dieser Frage) hängen davon ab, installed.packageswelche Form schlecht ist. Aus der Dokumentation:

Dies kann langsam sein, wenn Tausende von Paketen installiert sind. Verwenden Sie diese Option also nicht, um herauszufinden, ob ein benanntes Paket installiert ist (verwenden Sie system.file oder find.package) oder um herauszufinden, ob ein Paket verwendbar ist (rufen Sie require auf und überprüfen Sie das Rückgabewert) noch um Details einer kleinen Anzahl von Paketen zu finden (verwenden Sie packageDescription). Es muss mehrere Dateien pro installiertem Paket lesen, was unter Windows und einigen im Netzwerk bereitgestellten Dateisystemen langsam ist.

Ein besserer Ansatz ist es also, zu versuchen, das Paket mit requireund zu laden und zu installieren, wenn das Laden fehlschlägt ( requirewird zurückgegeben, FALSEwenn es nicht gefunden wird). Ich bevorzuge diese Implementierung:

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    if(length(need)>0){ 
        install.packages(need)
        lapply(need,require,character.only=TRUE)
    }
}

welches so verwendet werden kann:

using("RCurl","ggplot2","jsonlite","magrittr")

Auf diese Weise werden alle Pakete geladen, dann zurückgegangen und alle fehlenden Pakete installiert (wenn Sie möchten, können Sie eine Eingabeaufforderung einfügen, um zu fragen, ob der Benutzer Pakete installieren möchte). Anstatt anzurufeninstall.packages jedes Paket separat der gesamte Vektor deinstallierter Pakete nur einmal übergeben.

Hier ist dieselbe Funktion, jedoch mit einem Windows-Dialogfeld, in dem Sie gefragt werden, ob der Benutzer die fehlenden Pakete installieren möchte

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    n<-length(need)
    if(n>0){
        libsmsg<-if(n>2) paste(paste(need[1:(n-1)],collapse=", "),",",sep="") else need[1]
        print(libsmsg)
        if(n>1){
            libsmsg<-paste(libsmsg," and ", need[n],sep="")
        }
        libsmsg<-paste("The following packages could not be found: ",libsmsg,"\n\r\n\rInstall missing packages?",collapse="")
        if(winDialog(type = c("yesno"), libsmsg)=="YES"){       
            install.packages(need)
            lapply(need,require,character.only=TRUE)
        }
    }
}

Obwohl die Antwort von Shane wirklich gut ist, musste ich für eines meiner Projekte die Ausgangsmeldungen, Warnungen entfernen und Pakete automatisch installieren . Ich habe es endlich geschafft, dieses Skript zu bekommen:

InstalledPackage <- function(package) 
{
    available <- suppressMessages(suppressWarnings(sapply(package, require, quietly = TRUE, character.only = TRUE, warn.conflicts = FALSE)))
    missing <- package[!available]
    if (length(missing) > 0) return(FALSE)
    return(TRUE)
}

CRANChoosen <- function()
{
    return(getOption("repos")["CRAN"] != "@CRAN@")
}

UsePackage <- function(package, defaultCRANmirror = "http://cran.at.r-project.org") 
{
    if(!InstalledPackage(package))
    {
        if(!CRANChoosen())
        {       
            chooseCRANmirror()
            if(!CRANChoosen())
            {
                options(repos = c(CRAN = defaultCRANmirror))
            }
        }

        suppressMessages(suppressWarnings(install.packages(package)))
        if(!InstalledPackage(package)) return(FALSE)
    }
    return(TRUE)
}

Verwenden:

libraries <- c("ReadImages", "ggplot2")
for(library in libraries) 
{ 
    if(!UsePackage(library))
    {
        stop("Error!", library)
    }
}

# List of packages for session
.packages = c("ggplot2", "plyr", "rms")

# Install CRAN packages (if not already installed)
.inst <- .packages %in% installed.packages()
if(length(.packages[!.inst]) > 0) install.packages(.packages[!.inst])

# Load packages into session 
lapply(.packages, require, character.only=TRUE)

Dies ist der Zweck des rbundler-Pakets : eine Möglichkeit zur Steuerung der Pakete bereitzustellen, die für ein bestimmtes Projekt installiert werden. Derzeit arbeitet das Paket mit der devtools-Funktionalität, um Pakete im Verzeichnis Ihres Projekts zu installieren. Die Funktionalität ist ähnlich wie Ruby bundler .

Wenn Ihr Projekt ein Paket ist (empfohlen), müssen Sie nur rbundler laden und die Pakete bündeln. Die bundleFunktion überprüft die DESCRIPTIONDatei Ihres Pakets, um festzustellen, welche Pakete gebündelt werden sollen.

library(rbundler)
bundle('.', repos="http://cran.us.r-project.org")

Jetzt werden die Pakete im Verzeichnis .Rbundle installiert.

Wenn Ihr Projekt kein Paket ist, können Sie es fälschen, indem Sie eine DESCRIPTIONDatei im Stammverzeichnis Ihres Projekts mit einem Depends-Feld erstellen, in dem die zu installierenden Pakete aufgeführt sind (mit optionalen Versionsinformationen):

Depends: ggplot2 (>= 0.9.2), arm, glmnet

Hier ist das Github-Repo für das Projekt, wenn Sie daran interessiert sind, einen Beitrag zu leisten: rbundler .

Sicher.

Sie müssen 'installierte Pakete' mit 'gewünschten Paketen' vergleichen. Das kommt meiner Arbeit mit CRANberries sehr nahe, da ich "gespeicherte bekannte Pakete" mit "derzeit bekannten Paketen" vergleichen muss, um neue und / oder aktualisierte Pakete zu ermitteln.

Also mach so etwas

AP <- available.packages(contrib.url(repos[i,"url"]))   # available t repos[i]

Um alle bekannten Pakete zu erhalten, rufen Sie einfach die aktuell installierten Pakete auf und vergleichen Sie diese mit einem bestimmten Satz von Zielpaketen.

Verwenden Sie diese packratOption, damit die gemeinsam genutzten Bibliotheken exakt identisch sind und die Umgebung anderer nicht ändern.

In Bezug auf Eleganz und Best Practice denke ich, dass Sie grundsätzlich falsch vorgehen. Das Paket packratwurde für diese Probleme entwickelt. Es wird von RStudio von Hadley Wickham entwickelt. Anstatt Abhängigkeiten installieren zu müssen und möglicherweise das Umgebungssystem einer anderen Person durcheinander zu bringen, packratverwendet sie ein eigenes Verzeichnis und installiert dort alle Abhängigkeiten für Ihre Programme und berührt nicht die Umgebung einer anderen Person.

Packrat ist ein Abhängigkeitsmanagementsystem für R.

R-Paketabhängigkeiten können frustrierend sein. Mussten Sie jemals Trial-and-Error verwenden, um herauszufinden, welche R-Pakete Sie installieren müssen, damit der Code eines anderen funktioniert - und dann wurden diese Pakete für immer global installiert, da Sie jetzt nicht sicher sind, ob Sie sie benötigen ? Haben Sie jemals ein Paket aktualisiert, damit Code in einem Ihrer Projekte funktioniert, nur um festzustellen, dass das aktualisierte Paket dazu führt, dass Code in einem anderen Projekt nicht mehr funktioniert?

Wir haben Packrat gebaut, um diese Probleme zu lösen. Verwenden Sie packrat, um Ihre R-Projekte zu verbessern:

• Isoliert: Wenn Sie ein neues oder aktualisiertes Paket für ein Projekt installieren, werden Ihre anderen Projekte nicht beschädigt, und umgekehrt. Das liegt daran, dass packrat jedem Projekt eine eigene private Paketbibliothek gibt.
• Tragbar: Transportieren Sie Ihre Projekte problemlos von einem Computer auf einen anderen, auch über verschiedene Plattformen hinweg. Packrat erleichtert die Installation der Pakete, von denen Ihr Projekt abhängt.
• Reproduzierbar: Packrat zeichnet die genauen Paketversionen auf, von denen Sie abhängig sind, und stellt sicher, dass diese genauen Versionen überall installiert werden.

https://rstudio.github.io/packrat/

Die folgende einfache Funktion wirkt wie ein Zauber:

  usePackage<-function(p){
      # load a package if installed, else load after installation.
      # Args:
      #   p: package name in quotes

      if (!is.element(p, installed.packages()[,1])){
        print(paste('Package:',p,'Not found, Installing Now...'))
        install.packages(p, dep = TRUE)}
      print(paste('Loading Package :',p))
      require(p, character.only = TRUE)  
    }

(nicht meins, habe dies vor einiger Zeit im Internet gefunden und benutze es seitdem. Ich bin mir der Originalquelle nicht sicher.)

Ich benutze folgende Funktion, um Paket zu installieren, wenn require("<package>") Beenden mit dem Fehler "Paket nicht gefunden" beendet wird. Es werden sowohl CRAN- als auch Bioconductor-Repositorys nach fehlenden Paketen abgefragt.

Adaptiert von der Originalarbeit von Joshua Wiley, http://r.789695.n4.nabble.com/Install-package-automatically-if-not-there-td2267532.html

install.packages.auto <- function(x) { 
  x <- as.character(substitute(x)) 
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else { 
    #update.packages(ask= FALSE) #update installed packages.
    eval(parse(text = sprintf("install.packages(\"%s\", dependencies = TRUE)", x)))
  }
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else {
    source("http://bioconductor.org/biocLite.R")
    #biocLite(character(), ask=FALSE) #update installed packages.
    eval(parse(text = sprintf("biocLite(\"%s\")", x)))
    eval(parse(text = sprintf("require(\"%s\")", x)))
  }
}

Beispiel:

install.packages.auto(qvalue) # from bioconductor
install.packages.auto(rNMF) # from CRAN

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)aktualisiert alle auf dem System installierten Pakete. Dies kann lange dauern und gilt als vollständiges R-Upgrade, für das möglicherweise nicht immer eine Garantie besteht!

Sie können die setdiffFunktion einfach verwenden , um die nicht installierten Pakete abzurufen und anschließend zu installieren. Im folgenden Beispiel prüfen wir, ob die Pakete ggplot2und Rcppinstalliert sind, bevor Sie sie installieren.

unavailable <- setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages()))
install.packages(unavailable)

In einer Zeile kann das Obige geschrieben werden als:

install.packages(setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages())))

Ich habe die Funktion implementiert, um erforderliche R-Pakete still zu installieren und zu laden. Hoffnung könnte helfen. Hier ist der Code:

# Function to Install and Load R Packages
Install_And_Load <- function(Required_Packages)
{
    Remaining_Packages <- Required_Packages[!(Required_Packages %in% installed.packages()[,"Package"])];

    if(length(Remaining_Packages)) 
    {
        install.packages(Remaining_Packages);
    }
    for(package_name in Required_Packages)
    {
        library(package_name,character.only=TRUE,quietly=TRUE);
    }
}

# Specify the list of required packages to be installed and load    
Required_Packages=c("ggplot2", "Rcpp");

# Call the Function
Install_And_Load(Required_Packages);

Die kommende Version von RStudio (1.2), die bereits als Vorschau verfügbar ist, enthält eine Funktion zum Erkennen fehlender Pakete library()und require()Aufrufe und zum Auffordern des Benutzers, diese zu installieren:

Fehlende R-Pakete erkennen

Viele R-Skripte werden mit Aufrufen library()und require()Laden der Pakete geöffnet , die zur Ausführung benötigt werden. Wenn Sie ein R-Skript öffnen, das auf Pakete verweist, die Sie nicht installiert haben, bietet RStudio jetzt an, alle erforderlichen Pakete mit einem einzigen Klick zu installieren. Kein install.packages()wiederholtes Tippen mehr, bis die Fehler behoben sind!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Dies scheint das ursprüngliche Anliegen von OP besonders gut anzusprechen:

Viele von ihnen sind Anfänger / Fortgeschrittene und wissen nicht, dass sie Pakete installieren müssen, die sie noch nicht haben.

In Bezug auf Ihr Hauptziel "Bibliotheken zu installieren, die sie noch nicht haben" und unabhängig von der Verwendung von "instllaed.packages ()". Die folgende Funktion maskiert die ursprüngliche Funktion von require. Es wird versucht, das benannte Paket "x" zu laden und zu überprüfen. Wenn es nicht installiert ist, installieren Sie es direkt einschließlich der Abhängigkeiten. und zuletzt normal laden. Sie benennen den Funktionsnamen von 'require' in 'library' um, um die Integrität aufrechtzuerhalten. Die einzige Einschränkung besteht darin, dass Paketnamen in Anführungszeichen gesetzt werden sollten.

require <- function(x) { 
  if (!base::require(x, character.only = TRUE)) {
  install.packages(x, dep = TRUE) ; 
  base::require(x, character.only = TRUE)
  } 
}

So können Sie das Paket auf die altmodische Weise von R laden und installieren. Require ("ggplot2") require ("Rcpp")

Ganz einfach.

pkgs = c("pacman","data.table")
if(length(new.pkgs <- setdiff(pkgs, rownames(installed.packages())))) install.packages(new.pkgs)

Ich dachte, ich würde den Beitrag leisten, den ich benutze:

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")

source("https://bioconductor.org/biocLite.R")
if (!require("ggsci")) biocLite("ggsci")

Mit lapply family und anonymem Funktionsansatz können Sie:

1. Versuchen Sie, alle aufgelisteten Pakete anzuhängen.
2. Installation fehlt nur (mit || Lazy Evaluation).
3. Versuchen Sie erneut, diese anzuhängen, die in Schritt 1 fehlten und in Schritt 2 installiert wurden.

4. Drucken Sie den endgültigen Ladestatus jedes Pakets aus ( TRUE/ FALSE).

   req <- substitute(require(x, character.only = TRUE))
   lbs <- c("plyr", "psych", "tm")
   sapply(lbs, function(x) eval(req) || {install.packages(x); eval(req)})
   
   plyr psych    tm 
   TRUE  TRUE  TRUE 

Ich verwende Folgendes, um zu überprüfen, ob das Paket installiert ist und ob Abhängigkeiten aktualisiert werden, und lade dann das Paket.

p<-c('ggplot2','Rcpp')
install_package<-function(pack)
{if(!(pack %in% row.names(installed.packages())))
{
  update.packages(ask=F)
  install.packages(pack,dependencies=T)
}
 require(pack,character.only=TRUE)
}
for(pack in p) {install_package(pack)}

completeFun <- function(data, desiredCols) {
  completeVec <- complete.cases(data[, desiredCols])
  return(data[completeVec, ])
}

Hier ist mein Code dafür:

packages <- c("dplyr", "gridBase", "gridExtra")
package_loader <- function(x){
    for (i in 1:length(x)){
        if (!identical((x[i], installed.packages()[x[i],1])){
            install.packages(x[i], dep = TRUE)
        } else {
            require(x[i], character.only = TRUE)
        }
    }
}
package_loader(packages)

 48 lapply_install_and_load <- function (package1, ...)
 49 {
 50     #
 51     # convert arguments to vector
 52     #
 53     packages <- c(package1, ...)
 54     #
 55     # check if loaded and installed
 56     #
 57     loaded        <- packages %in% (.packages())
 58     names(loaded) <- packages
 59     #
 60     installed        <- packages %in% rownames(installed.packages())
 61     names(installed) <- packages
 62     #
 63     # start loop to determine if each package is installed
 64     #
 65     load_it <- function (p, loaded, installed)
 66     {
 67         if (loaded[p])
 68         {
 69             print(paste(p, "loaded"))
 70         }
 71         else
 72         {
 73             print(paste(p, "not loaded"))
 74             if (installed[p])
 75             {
 76                 print(paste(p, "installed"))
 77                 do.call("library", list(p))
 78             }
 79             else
 80             {
 81                 print(paste(p, "not installed"))
 82                 install.packages(p)
 83                 do.call("library", list(p))
 84             }
 85         }
 86     }
 87     #
 88     lapply(packages, load_it, loaded, installed)
 89 }

library <- function(x){
  x = toString(substitute(x))
if(!require(x,character.only=TRUE)){
  install.packages(x)
  base::library(x,character.only=TRUE)
}}

Dies funktioniert mit nicht zitierten Paketnamen und ist ziemlich elegant (vgl. GeoObserver-Antwort)

In meinem Fall wollte ich einen Einzeiler, den ich über die Befehlszeile ausführen kann (tatsächlich über ein Makefile). Hier ist ein Beispiel für die Installation von "VGAM" und "Feder", falls diese noch nicht installiert sind:

R -e 'for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")'

Aus R heraus wäre es nur:

for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")

Es gibt hier nichts außer den vorherigen Lösungen außer dem:

• Ich halte es in einer einzigen Zeile
• Ich codiere das hart repos Parameter (um zu vermeiden, dass Popups nach dem zu verwendenden Spiegel fragen)
• Ich mache mir nicht die Mühe, eine Funktion zu definieren, die an anderer Stelle verwendet werden soll

Beachten Sie auch das Wichtige character.only=TRUE(ohne es requirewürde das versuchen, das Paket zu laden p).

  packages_installed <- function(pkg_list){
        pkgs <- unlist(pkg_list)
        req <- unlist(lapply(pkgs, require, character.only = TRUE))
        not_installed <- pkgs[req == FALSE]
        lapply(not_installed, install.packages, 
               repos = "http://cran.r-project.org")# add lib.loc if needed
        lapply(pkgs, library, character.only = TRUE)
}

Lassen Sie mich ein bisschen Wahnsinn teilen:

c("ggplot2","ggsci", "hrbrthemes", "gghighlight", "dplyr") %>%  # What will you need to load for this script?
  (function (x) ifelse(t =!(x %in% installed.packages()), 
    install.packages(x[t]),
    lapply(x, require)))