Elegancki sposób na sprawdzenie brakujących pakietów i zainstalowanie ich?

Dason K. i mam pacman pakiet, który może to zrobić ładnie. Funkcja p_load w pakiecie robi to. Pierwsza linia jest tylko po to, aby upewnić się, że pacman jest zainstalowany.

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

Możesz po prostu użyć zwracanej wartości require:

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

Używam library Po instalacji, ponieważ spowoduje to wyrzucenie wyjątku, jeśli instalacja nie powiodła się lub pakiet nie może zostać załadowany z jakiegoś innego powodu. Możesz to zrobić bardziej wytrzymałe i wielokrotnego użytku:

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

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

Minusem tej metody jest to, że musisz podać nazwę pakietu w cudzysłowie, czego nie robisz dla prawdziwego require.

Chociaż odpowiedź Shane ' a jest naprawdę dobra, w jednym z moich projektów musiałem usunąć komunikaty ouput, ostrzeżenia i zainstalować pakiety automagicznie. W końcu udało mi się zdobyć ten skrypt:

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

Użycie:

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

To rozwiązanie pobierze wektor znaków z nazwami pakietów i spróbuje je załadować lub zainstalować, jeśli Ładowanie się nie powiedzie. Opiera się na Return behavior of require, aby to zrobić, ponieważ...

require zwraca (niewidocznie) logiczne wskazanie, czy wymagany pakiet jest dostępny

Dlatego możemy po prostu sprawdzić, czy udało nam się załadować wymagany pakiet, a jeśli nie, zainstalować go z zależnościami. Więc biorąc pod uwagę wektor znaków pakietów, które chcesz ładuj...

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

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

"ggplot2" jest pakietem. Sprawdza, czy pakiet jest zainstalowany, a jeśli nie, instaluje go. Następnie ładuje pakiet niezależnie od tego, która gałąź zajęła.

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

Wiele powyższych odpowiedzi (i na duplikaty tego pytania) opiera się na installed.packages, która jest złą formą. Z dokumentacji:

Może to być powolne, gdy zainstalowane są tysiące pakietów, więc nie używaj tego, aby dowiedzieć się, czy dany pakiet jest zainstalowany (użyj system./ align = "left" / package), ani aby dowiedzieć się, czy pakiet jest użyteczny (call require i sprawdź wartość zwracaną), ani aby znaleźć szczegóły niewielkiej liczby pakietów (użyj packageDescription). Musi odczytać kilka plików na zainstalowany pakiet, który będzie wolny w systemie Windows i niektórych systemach plików montowanych w sieci.

Więc lepszym podejściem jest próba załadowania pakietu za pomocą require i zainstalowania, jeśli Ładowanie się nie powiedzie (require zwróci FALSE Jeśli nie zostanie znaleziony). Wolę tę implementację:

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

Które mogą być użyte w ten sposób:

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

W ten sposób ładuje wszystkie pakiety, a następnie wraca i instaluje wszystkie brakujące pakiety (co, jeśli chcesz, jest przydatnym miejscem do wstawienia zachęty aby zapytać, czy użytkownik chce zainstalować pakiety). Zamiast wywoĹ 'ywaÄ ‡ install.packages oddzielnie dla kaĹźdego pakietu, mija on caĹ' y wektor odinstalowanych pakietăłw tylko raz.

Tutaj jest ta sama funkcja, ale z oknem dialogowym windows, które pyta, czy użytkownik chce zainstalować brakujące pakiety

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

To jest cel pakietu rbundler: aby zapewnić sposób kontrolowania pakietów, które są zainstalowane dla określonego projektu. Obecnie pakiet współpracuje z funkcjami devtools, aby zainstalować pakiety w katalogu twojego projektu. Funkcjonalność jest podobna do bundler.

Jeśli twój projekt jest pakietem (zalecanym), to wystarczy załadować rbundlera i spakować Pakiety. Funkcja bundle spojrzy na plik DESCRIPTION twojego pakietu do określ, które pakiety należy połączyć.

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

Teraz pakiety zostaną zainstalowane wKatalog Rbundle.

Jeśli twój projekt nie jest pakietem, możesz go sfałszować, tworząc plik DESCRIPTION w katalogu głównym projektu z polem Depends, który zawiera listę pakietów, które chcesz zainstalować (z opcjonalnymi informacjami o wersji):

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

Oto repo github dla projektu, jeśli jesteś zainteresowany udziałem: rbundler .

Jasne.

Musisz porównać 'zainstalowane pakiety' z 'żądanymi pakietami'. Jest to bardzo zbliżone do tego, co robię z CRANberries, ponieważ muszę porównać "przechowywane Znane pakiety" z "obecnie znane pakiety", aby określić nowe i/lub zaktualizowane pakiety.

Więc zrób coś takiego

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

Aby uzyskać wszystkie znane Pakiety, należy wywołać symulację aktualnie zainstalowanych pakietów i porównać je z danym zestawem pakietów docelowych.

Następująca prosta funkcja działa jak urok:

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

(nie mój, znalazłem to w sieci jakiś czas temu i używałem go od tego czasu. nie jestem pewien oryginalnego źródła)

Używam poniższej funkcji, aby zainstalować pakiet, jeśli require("<package>") zakończy się z błędem package not found. Odpytuje zarówno repozytoria-CRAN, jak i Bioconductor o brakujący pakiet.

Adaptacja oryginalnego dzieła Joshuy 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)))
  }
}

Przykład:

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

PS: update.packages(ask = FALSE) & biocLite(character(), ask=FALSE) zaktualizuje wszystkie zainstalowane pakiety w systemie. Może to zająć dużo czasu i uznać to za pełny R uaktualnienie, które może nie być gwarantowane przez cały czas!

Możesz po prostu użyć funkcji setdiff, Aby pobrać pakiety, które nie są zainstalowane, a następnie je zainstalować. W poniższej próbce sprawdzamy, czy ggplot2 oraz Rcpp pakiety są instalowane przed ich zainstalowaniem.

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

W jednej linijce powyższe można zapisać jako:

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

Zaimplementowałem funkcję do cichego instalowania i ładowania wymaganych pakietów R. Nadzieja może pomóc. Oto kod:

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

Użyj packrat, aby biblioteki współdzielone były dokładnie takie same i nie zmieniały środowiska innych.

Packrat jest systemem zarządzania zależnościami dla R.

R zależności pakietów mogą być frustrujące. Czy kiedykolwiek musiałeś użyć metody prób i błędów, aby dowiedzieć się, jakie pakiety R musisz zainstalować, aby Kod kogoś innego działał–a potem zostałeś z tymi pakietami zainstalowanymi globalnie na zawsze, ponieważ teraz nie jesteś pewien, czy ich potrzebujesz? Czy kiedykolwiek zaktualizowałeś pakiet, aby kod w jednym z projektów działał, tylko po to, aby znaleźć że zaktualizowany pakiet sprawia, że kod w innym projekcie przestaje działać?

Zbudowaliśmy packrata, by rozwiązać te problemy. Użyj packrat, aby twoje projekty R były więcej:

• izolowane: Instalacja nowego lub zaktualizowanego pakietu dla jednego projektu nie zepsuje innych projektów i vice versa. To dlatego, że packrat daje każdemu projektowi własną prywatną bibliotekę pakietów.
• przenośny: łatwo przenoś swoje projekty z jednego komputera na drugi, nawet na różnych platformach. Packrat ułatwia instalację pakietów, od których zależy twój projekt.
• Reproducible: Packrat rejestruje dokładne wersje pakietów, od których zależy, i zapewnia, że te dokładne wersje są instalowane gdziekolwiek jesteś.

Https://rstudio.github.io/packrat/

Odnośnie Twojego głównego celu " instalowania bibliotek, których jeszcze nie mają. "i niezależnie od użycia" instllaed.packages() ". Następująca funkcja maskuje oryginalną funkcję require. Próbuje załadować i sprawdzić nazwany pakiet "x" , Jeśli nie jest zainstalowany, zainstaluj go bezpośrednio wraz z zależnościami; i na koniec załaduj go normalnie. zmieniasz nazwę funkcji z "require" na "library", aby zachować integralność . Jedynym ograniczeniem jest to, że nazwy pakietów powinny być cytowany.

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

Więc możesz załadować i zainstalować pakiet w starym stylu R. require ("ggplot2") require ("Rcpp")

Dość podstawowy.

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

Pomyślałem, że dodam ten, którego używam:

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

Używam następującej opcji, która sprawdzi czy pakiet jest zainstalowany i czy zależności są zaktualizowane, a następnie załaduje pakiet.

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

Oto Mój kod na to:

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

Działa to z nienotowanymi nazwami pakietów i jest dość eleganckie (por. Odpowiedź GeoObserver)

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

Używając metody lapply family I anonymous function Można:

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

plyr psych    tm 
TRUE  TRUE  TRUE 

1. spróbuj załączyć wszystkie wymienione Pakiety.
2. Install missing only (using || lazy evaluation).
3. spróbuj ponownie załadować te, których brakowało w kroku 1 i zainstalowano w Kroku 2.
4. wypisuje sumaryczny status załadowania dla każdego pakietu (TRUE / FALSE).

W moim przypadku chciałem jednego linera, który mógłbym uruchomić z linii poleceń (właściwie przez plik Makefile). Oto przykład instalacji "VGAM " i" feather", jeśli nie są już zainstalowane:

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

From within R it would just be:

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

Nie ma tu nic poza wcześniejszymi rozwiązaniami poza tym, że:

• trzymam go do jednej linii
• i hard code the repos parametr (aby uniknąć wyskakujących okienek pytających o użycie lustra)
• I don ' t problem z zdefiniowaniem funkcji, która ma być używana gdzie indziej

Zwróć również uwagę na Ważne character.only=TRUE (bez niego,require próbuje załadować pakiet p).

Spróbuj tego:

if (!require(MyDesiredLibrary)) {
   install.packages("MyDesiredLibrary")
}