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

336

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?

Maiasaura
quelle
1
@krlmlr Was ist mit der akzeptierten Antwort, die veraltet ist und überarbeitet werden muss? Es funktioniert bei mir (für ein paar schnelle Tests) unter R version 3.0.2 (2013-09-25) x86_64-w64-mingw32/x64 (64-bit).
Brian Diggs
1
@BrianDiggs: Es sind mindestens drei Pakete erschienen, die dieses Problem beheben. Im Folgenden wird nur auf eines verwiesen. Gibt es noch mehr - das ist die Frage.
krlmlr
2
@krlmlr Es scheint ein ironisches Henne-Ei-Problem zu sein, ein Paket zu verwenden, um sicherzustellen, dass (andere) die erforderlichen Pakete haben. Aber es lohnt sich auf jeden Fall, jemanden, der über sie Bescheid weiß, eine Antwort schreiben zu lassen.
Brian Diggs
2
@BrianDiggs: Das Bootstrapping dieses Installationsprüfungspakets ist ein notwendiges, aber kleines Ärgernis. Es sei denn natürlich, die Funktionalität findet ihren Weg in base... ;-)
krlmlr

Antworten:

303

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.

Shane
quelle
11
Ich denke, die richtige Syntax ist: if(length(new.packages)>0) {install.packages(new.packages)}
5
@psql, Shine ist richtig, da "> 0" innerhalb der if-Bedingung "implizit" ist. Führen Sie dies aus, um es zu überprüfen:new.packages <- c(1,2) length(new.packages) if(length(new.packages)){print("hello!")}else{print("oh no!")}
Andrea Cirillo
7
Im Dokument von install.packages heißt es: "Dies kann langsam sein, wenn Tausende von Paketen installiert sind. Verwenden Sie dies also nicht, um herauszufinden, ob ein benanntes Paket installiert ist (verwenden Sie system.file oder find.package) ..."
Thomas Materna
2
Stimmen Sie mit Thomas überein, dies wäre eine bessere Leistung, requireanstatt zu überprüfeninstalled.packages
Matthew
1
packratwurde dafür gemacht. Es ist ein reproduzierbares Paketverwaltungssystem. Dieser Weg geht falsch vor und beeinträchtigt die Umgebung eines anderen und ist nicht reproduzierbar. Packrat hat einen eigenen Ordner und eine eigene Umgebung für die gemeinsam genutzten Bibliotheken. rstudio.github.io/packrat
mtelesha
231

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)
Tyler Rinker
quelle
1
Wie ist der Status des Pakets? Ich kann C-RAN nicht sehen.
MERose
4
@MERose Pacman ist jetzt auf CRAN cran.r-project.org/web/packages/pacman/index.html
Tyler Rinker
6
Habe jetzt installiert und funktioniert wunderbar; sollte Teil der Basis sein!
AndyF
3
Der einzige Weg, wie dies besser wäre, wäre, wenn es überprüft /und, falls gefunden, automatisch von github installiert / geladen wird.
Luftangriff
4
@NealBarsch, wenn Sie meinen, dass if (!require("pacman")) install.packages("pacman")es in pacman eine Funktion namens gibt p_boot(), die diese Zeile automatisch für Sie erstellt und in die Zwischenablage kopiert.
Tyler Rinker
72

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.

Livius
quelle
4
Sie können Ihr Leben viel vereinfachen, indem Sie character.only = TRUEin verwenden require, aber dann gibt es wohl nichts, was Ihre Antwort von meiner unterscheidet.
Simon O'Hanlon
Das sieht gut aus, scheint aber nicht zu funktionieren, zumindest für mich. Als ich die robuste Version davon ausprobiert habe, erhalte ich zwei Fehlermeldungen, da R aus irgendeinem Grund nicht weiß, wie er mit "return True" und "return eval" umgehen soll. Ich hätte also gerne eine solche Funktion, die ein Paket lädt, wenn es in meiner Bibliothek vorhanden ist, und das Paket anderweitig installiert (und anschließend lädt). Idealerweise würde ich dies dann als Standard zum Laden von Paketen verwenden. Zumindest scheint es sinnvoll, dies zu tun und Zeit zu sparen.
Fabian Habersack
23
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.

user6784955
quelle
21

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" ) )
Simon O'Hanlon
quelle
Möchten Sie requirenach der Installation nicht erneut anrufen ?
krlmlr
@krlmlr Nein, denn damit die ifAnweisung ausgewertet werden kann, muss sie zuerst ausgewertet requirewerden. Der Nebeneffekt ist, dass das Paket geladen wird, wenn es verfügbar ist!
Simon O'Hanlon
1
SimonO101: Ich denke, krlmlr bedeutet in der if-Anweisung nach dem Aufruf von install.packages, da dies das Paket nicht wirklich laden würde. Aber (zu @krlmlr) Ich vermute, die Absicht ist, dass dieses Codefragment nur einmal aufgerufen wird; Sie würden dies nicht jedes Mal schreiben, wenn Sie das Paket benötigen. Stattdessen würden Sie es einmal im Voraus ausführen und dann requirewie gewohnt anrufen .
Aaron verließ Stack Overflow
@ Aaron ah ja ok, ich verstehe was du meinst und ja deine Interpretation ist korrekt. Ich werde es etwas bearbeiten, um das Laden nach der Installation genauer zu beschreiben.
Simon O'Hanlon
1
Wäre es nicht besser, den zweiten requireAnruf zu tätigen , librarydamit er lautstark fehlschlägt, wenn das Paket aus irgendeinem Grund immer noch nicht angehängt werden kann?
Kabdulla
18

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)
        }
    }
}
Matthew
quelle
Dies ist ein ziemlich eleganter Weg, viel besser als der akzeptierte. Ich werde es in meine persönliche Bibliothek aufnehmen. Vielen Dank.
Bing
15

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)
    }
}
Juan Antonio Cano
quelle
9
# 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)
Brian Spiering
quelle
6

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 .

Erik Shilts
quelle
5

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.

Dirk Eddelbuettel
quelle
5

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/

mtelesha
quelle
4

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.)

Anish Sugathan
quelle
4

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!

Samir
quelle
Es könnte verbessert werden, indem überprüft wird, ob Pakete tatsächlich auf cran oder bc verfügbar sind. Außerdem sollte am Ende die Bibliothek verwendet werden, um einen Fehler auszulösen, wenn die Installation fehlgeschlagen ist oder kein Paket vorhanden ist. Siehe meine verbesserte Version loadpack()unter raw.githubusercontent.com/holgerbrandl/datautils/master/R/…
Holger Brandl
4

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())))
Alex Essilfie
quelle
Ich benutze den gleichen Ansatz. Wir können auch installed.packages()[,'Package']anstelle von verwenden rownames(installed.packages()).
Scudelletti
3

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);
Pratik Patil
quelle
3

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.

Aurèle
quelle
2

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")

GeoObserver
quelle
Wenn Ihnen Ihre Antwort nicht mehr gefällt, zerstören Sie sie nicht - löschen Sie sie einfach.
Michael Petrotta
Nun, ich habe es versucht, aber ich konnte nicht. Ich denke, meine NoScript-Erweiterung von FF deaktiviert sie oder ich habe nicht die Rechte und Credits, um meine eigene Antwort zu löschen. LoL Ich denke jedoch, Livius ist meiner Antwort ziemlich nahe, dachte ohne Maskierung. Danke Michael Petrotta. für die Benachrichtigung.
GeoObserver
Sie sollten einen deleteLink über diesen Kommentaren sehen. Wenn Sie dies nicht tun und dennoch löschen möchten, verwenden Sie den flagLink, wählen Sie "Andere" aus und erklären Sie einem Moderator, dass die Antwort entfernt werden soll.
Michael Petrotta
2

Ganz einfach.

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

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

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")
Ben
quelle
2
source("https://bioconductor.org/biocLite.R")
if (!require("ggsci")) biocLite("ggsci")
Shicheng Guo
quelle
2

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 
Georgie Shimanovsky
quelle
1

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, ])
}
Metasequoia
quelle
1

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)
Edward Tyler
quelle
1
 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 }
Rue morgue
quelle
1
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)

sn
quelle
1

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).

user3780389
quelle
0
  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)
}
KVemuri
quelle
0

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))) 
lf_araujo
quelle