remove - ggtitle




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

Dason K. und ich haben das Pacman- Paket, das das gut machen kann. Die Funktion p_load im Paket erledigt dies. Die erste Zeile ist nur um sicherzustellen, dass Pacman installiert ist.

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

Ich scheine heutzutage viel Code mit Co-Autoren 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, installed.packages() aufzurufen, diese mit denen zu vergleichen, die ich lade und installiere, wenn sie fehlen?


Die folgende einfache Funktion funktioniert wie ein Charm:

  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 das vor einiger Zeit im Internet gefunden und habe es seither benutzt. Ich bin mir nicht sicher, von der ursprünglichen Quelle)


Diese Lösung nimmt einen Zeichenvektor von Paketnamen und versucht, sie zu laden, oder installiert sie, wenn das Laden fehlschlägt. Es beruht auf dem Rückkehrverhalten von require , dies zu tun, weil ...

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

Daher können wir einfach sehen, ob wir in der Lage waren, das benötigte Paket zu laden, und wenn nicht, installieren Sie es mit Abhängigkeiten. Also einen gegebenen Vektor der Pakete, die du laden willst ...

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

Ganz einfach.

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

Ich benutze folgende Funktion, um das Paket zu installieren, falls dies require("<package>") Exits mit Fehler Paket nicht gefunden. Es fragt beide - CRAN- und Bioconductor-Repositories nach fehlendem Paket ab.

Angepasst von der ursprünglichen Arbeit 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 installierten Pakete auf dem System. Dies kann eine lange Zeit dauern und es als eine vollständige R-Erweiterung betrachten, die möglicherweise nicht immer gewährleistet ist!


Ich dachte, ich würde den einen beitragen, den ich benutze:

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

Ich verwende Folgendes, das prüft, ob das Paket installiert ist und ob Abhängigkeiten aktualisiert werden, und lädt 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, ])
}

In Bezug auf Ihr Hauptziel "Bibliotheken zu installieren, die sie noch nicht haben." Und unabhängig davon, "infllaed.packages ()" zu verwenden. Die folgende Funktion maskiert die ursprüngliche Funktion von require. Es versucht, das benannte Paket "x" zu laden und zu prüfen, wenn es nicht installiert ist, es direkt zu installieren, einschließlich Abhängigkeiten; und laden Sie es zuletzt normal. Sie benennen den Funktionsnamen von "require" in "library" um, um die Integrität zu erhalten. Die einzige Einschränkung ist, 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 kann man den alten Modeweg von R laden und installieren. Require ("ggplot2") require ("Rcpp")


Ja. Wenn Sie Ihre Liste von Paketen haben, vergleichen Sie sie 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 Abhängigkeiten festlegen, werden diese bei der Installation des Pakets automatisch installiert.


Obwohl die Antwort von Shane wirklich gut ist, musste ich für eines meiner Projekte die Ausgabenachrichten, Warnungen 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"] != "@[email protected]")
}

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

Benutzen:

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

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

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

Ich benutze library nach 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 wiederverwendbar:

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 übergeben müssen, was Sie nicht für die tatsächliche require tun.


Sie können einfach die Funktion setdiff verwenden, um die Pakete zu erhalten, die nicht installiert sind, und sie dann installieren. Im folgenden Beispiel überprüfen wir, ob die Pakete ggplot2 und Rcpp vor der Installation installiert wurden.

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

In einer Zeile kann das obige wie folgt geschrieben werden:

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

Verwenden Sie packrat damit die gemeinsam genutzten Bibliotheken identisch sind und die Umgebung des anderen nicht ändern.

In Bezug auf Eleganz und Best Practice denke ich, dass es grundsätzlich falsch läuft. Das Paket packrat wurde für diese Probleme entwickelt. Es wird von RStudio von Hadley Wickham entwickelt. Anstatt dass sie Abhängigkeiten installieren und möglicherweise eine Umgebung durcheinander bringen müssen, verwendet das System packrat sein eigenes Verzeichnis und installiert alle Abhängigkeiten für Ihre Programme in deren Umgebung und berührt nicht die Umgebung eines anderen Benutzers.

Packrat ist ein Abhängigkeitsmanagementsystem für R.

R-Paketabhängigkeiten können frustrierend sein. Mussten Sie schon einmal ausprobieren und herausfinden, welche R-Pakete Sie installieren müssen, damit der Code von jemand anderem funktioniert - und diese Pakete dann für immer global installiert bleiben, weil Sie sich jetzt nicht sicher sind, ob Sie sie brauchen? ? Haben Sie jemals ein Paket aktualisiert, um Code in einem Ihrer Projekte zum Laufen zu bekommen, nur um festzustellen, dass das aktualisierte Paket 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 erweitern:

  • Isoliert: Durch die Installation eines neuen oder aktualisierten Pakets für ein Projekt werden Ihre anderen Projekte nicht beschädigt und umgekehrt. Das liegt daran, dass Packrat jedem Projekt seine eigene private Paketbibliothek zur Verfügung stellt.
  • Portabel: Transportieren Sie Ihre Projekte einfach von einem Computer zu einem anderen, sogar über verschiedene Plattformen hinweg. Packrat vereinfacht die Installation der Pakete, von denen Ihr Projekt abhängig ist.
  • Reproduzierbar: Packrat zeichnet die genauen Paketversionen auf, von denen Sie abhängig sind, und stellt sicher, dass genau diese Versionen installiert werden, die Sie überall installieren können.

rstudio.github.io/packrat


Viele der obigen Antworten (und Duplikate dieser Frage) beruhen auf installed.packages was eine schlechte Form ist. Aus der Dokumentation:

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

Ein besserer Ansatz besteht also darin, zu versuchen, das Paket mit require und install zu laden, wenn das Laden fehlschlägt ( require gibt FALSE wenn 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)
    }
}

das kann so verwendet werden:

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

Auf diese Weise lädt es alle Pakete, dann geht es zurück und installiert alle fehlenden Pakete (die, wenn Sie möchten, ist ein praktischer Ort, um eine Eingabeaufforderung einzufügen, um zu fragen, ob der Benutzer Pakete installieren möchte). Anstatt install.packages für jedes Paket einzeln aufzurufen, übergibt es den gesamten Vektor der nicht installierten Pakete nur einmal.

Hier ist die gleiche Funktion, aber mit einem Windows-Dialog, der fragt, 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)
        }
    }
}

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

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

"ggplot2" ist das Paket. Es prüft, ob das Paket installiert ist, wenn es nicht installiert ist. Es lädt dann das Paket unabhängig davon, welcher Zweig es dauerte.


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




r-faq