Элегантный способ проверить отсутствующие пакеты и установить их?

Кажется, я делюсь большим количеством кода с соавторами в эти дни. Многие из них являются новичками / пользователями среднего уровня и не понимают, что им нужно устанавливать пакеты, которых у них еще нет.

Есть ли элегантный способ вызова installed.packages(), сравните его с теми, которые я загружаю и устанавливаю, если отсутствует?

Да. Если у вас есть список пакетов, сравните его с выходными данными installed.packages()[,"Package"]и установите недостающие пакеты. Что-то вроде этого:

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)

В противном случае:

Если вы поместите свой код в пакет и сделаете их зависимостями, они будут автоматически установлены при установке пакета.

У Дэйсона К. и у меня есть пакет pacman , который может сделать это красиво. Функция p_loadв пакете делает это. Первая строка просто для того, чтобы убедиться, что pacman установлен.

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

Вы можете просто использовать возвращаемое значение require:

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

Я использую libraryпосле установки, потому что он выдаст исключение, если установка не удалась или пакет не может быть загружен по какой-либо другой причине. Вы делаете это более надежным и многократно используемым:

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

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

Недостатком этого метода является то, что вы должны передавать имя пакета в кавычках, что вы не делаете на самом деле require.

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

"ggplot2" - это пакет. Он проверяет, установлен ли пакет, если он не установлен, то устанавливает его. Затем он загружает пакет независимо от того, какую ветку он принял.

Это решение будет использовать символьный вектор имен пакетов и попытаться загрузить их или установить их, если загрузка не удалась. Это зависит от поведения возврата, requireчтобы сделать это, потому что ...

require возвращает (невидимо) логическое указание, доступен ли требуемый пакет

Поэтому мы можем просто увидеть, смогли ли мы загрузить требуемый пакет, а если нет, установить его с зависимостями. Итак, учитывая символьный вектор пакетов, которые вы хотите загрузить ...

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

Многие из приведенных выше ответов (и дубликатов этого вопроса) полагаются на то, installed.packagesчто это дурной тон. Из документации:

Это может быть медленным, когда установлены тысячи пакетов, поэтому не используйте это, чтобы узнать, установлен ли названный пакет (используйте system.file или find.package), а также чтобы выяснить, можно ли использовать пакет (вызовите require и проверьте возвращаемое значение) ни для того, чтобы найти сведения о небольшом количестве пакетов (используйте packageDescription). Для каждого установленного пакета необходимо прочитать несколько файлов, что будет медленно в Windows и в некоторых сетевых файловых системах.

Таким образом, лучший подход - попытаться загрузить пакет с помощью requireи и установить, если загрузка не удалась ( requireвернется, FALSEесли он не найден). Я предпочитаю эту реализацию:

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

который можно использовать так:

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

Таким образом, он загружает все пакеты, затем возвращается и устанавливает все отсутствующие пакеты (что, если хотите, является удобным местом для вставки подсказки с вопросом, хочет ли пользователь установить пакеты). Вместо того, чтобы вызывать install.packagesотдельно для каждого пакета, он пропускает весь вектор неустановленных пакетов только один раз.

Вот та же самая функция, но с диалоговым окном, которое спрашивает, хочет ли пользователь установить отсутствующие пакеты

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

Хотя ответ Шейн действительно хорош, для одного моего проекта мне нужно удалить Ouput сообщение, предупреждение и установку пакетов автоматически . Мне наконец удалось получить этот скрипт:

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

Использование:

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)

Это цель пакета rbundler : предоставить способ управления пакетами, установленными для конкретного проекта. Прямо сейчас пакет работает с функциональностью devtools для установки пакетов в каталог вашего проекта. Функциональность похожа на пакет Ruby .

Если ваш проект представляет собой пакет (рекомендуется), тогда все, что вам нужно сделать, это загрузить rbundler и связать пакеты. bundleФункция будет выглядеть в вашем пакете DESCRIPTIONфайл , чтобы определить , какие пакеты для объединения.

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

Теперь пакеты будут установлены в каталог .Rbundle.

Если ваш проект не является пакетом, то вы можете подделать его, создав DESCRIPTIONфайл в корневом каталоге вашего проекта с полем Depends, в котором перечислены пакеты, которые вы хотите установить (с дополнительной информацией о версии):

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

Вот репозиторий Github для проекта, если вы заинтересованы в участии: rbundler .

Конечно.

Вам нужно сравнить «установленные пакеты» с «желаемыми пакетами». Это очень близко к тому, что я делаю с CRANberries, так как мне нужно сравнить «сохраненные известные пакеты» с «известными на данный момент пакетами», чтобы определить новые и / или обновленные пакеты.

Так что-то вроде

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

чтобы получить все известные пакеты, выполните симуляцию вызова установленных в данный момент пакетов и сравните их с заданным набором целевых пакетов.

Используйте packratтак, чтобы разделяемые библиотеки были точно такими же и не меняли окружение других.

С точки зрения элегантности и лучшей практики, я думаю, что вы в корне ошибаетесь. Пакет packratбыл разработан для этих проблем. Он разработан RStudio Хэдли Уикхем. Вместо этого им приходится устанавливать зависимости и, возможно, портить чью-то систему окружения, packratиспользовать свой собственный каталог и устанавливать там все зависимости для ваших программ и не затрагивать чью-то среду.

Packrat - это система управления зависимостями для R.

Зависимости пакета R могут быть разочаровывающими. Приходилось ли вам когда-либо использовать метод проб и ошибок, чтобы выяснить, какие R-пакеты вам нужно установить, чтобы заставить работать чужой код, а затем навсегда оставить эти пакеты глобально установленными, потому что теперь вы не уверены, нужны ли они вам? ? Вы когда-нибудь обновляли пакет, чтобы заставить код в одном из ваших проектов работать, только чтобы обнаружить, что из-за обновленного пакета код в другом проекте перестает работать?

Мы создали пакет для решения этих проблем. Используйте packrat, чтобы сделать ваши R проекты более:

• Изолированный: установка нового или обновленного пакета для одного проекта не нарушит другие ваши проекты, и наоборот. Это потому, что packrat предоставляет каждому проекту свою собственную библиотеку пакетов.
• Переносимость: легко переносить свои проекты с одного компьютера на другой, даже на разные платформы. Packrat позволяет легко устанавливать пакеты, от которых зависит ваш проект.
• Воспроизводимые: Packrat записывает точные версии пакетов, от которых вы зависите, и гарантирует, что именно эти версии будут установлены везде, где бы вы ни находились.

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

Следующая простая функция работает как брелок:

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

(Не мой, нашел это в Интернете некоторое время назад и использовал его с тех пор. Не уверен в первоначальном источнике)

Я использую следующую функцию, чтобы установить пакет, если require("<package>")выход с ошибкой пакета не найден. Он запросит оба хранилища - CRAN и Bioconductor на предмет отсутствия пакета.

Адаптировано из оригинальной работы Джошуа Уайли, http://r.789695.n4.nabble.com/Install-package-automatics-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)))
  }
}

Пример:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)обновит все установленные пакеты в системе. Это может занять много времени и рассматривать его как полное обновление R, которое не может быть гарантировано все время!

Вы можете просто использовать setdiffфункцию, чтобы получить пакеты, которые не установлены, а затем установить их. В приведенном ниже примере мы проверяем , если ggplot2и Rcppпакеты установлены перед их установкой.

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

В одну строку вышеприведенное можно записать так:

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

Я реализовал функцию для установки и загрузки необходимых пакетов R в автоматическом режиме. Надежда может помочь. Вот код:

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

Предстоящая версия RStudio (1.2), уже доступная в качестве предварительного просмотра, будет включать функцию обнаружения пропущенных пакетов library()и require()вызовов и подсказки пользователю для их установки:

Обнаружить пропущенные пакеты R

Многие R-скрипты открываются с помощью вызовов library()и require()загрузки пакетов, которые им необходимы для выполнения. Если вы откроете скрипт R, который ссылается на пакеты, которые вы не установили, RStudio предложит установить все необходимые пакеты одним щелчком мыши. Не нужно больше печатать, install.packages()пока ошибки не исчезнут!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Похоже, это особенно хорошо отвечает первоначальной проблеме ОП:

Многие из них являются новичками / пользователями среднего уровня и не понимают, что им нужно устанавливать пакеты, которых у них еще нет.

Относительно вашей главной цели «установить библиотеки, которых у них еще нет.» И независимо от использования «instllaed.packages ()». Следующая функция маскирует исходную функцию require. Он пытается загрузить и проверить указанный пакет «x», если он не установлен, установить его напрямую, включая зависимости; и наконец загрузите это обычно. вы переименовываете имя функции из 'require' в 'library', чтобы сохранить целостность. Единственное ограничение - имена пакетов должны быть в кавычках.

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

Таким образом, вы можете загрузить и установить пакет старым способом R. require ("ggplot2") require ("Rcpp")

Довольно простой.

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

Думаю, я внесу тот, который я использую:

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

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

Используя семейный подход и анонимную функцию, вы можете:

1. Попробуйте прикрепить все перечисленные пакеты.
2. Установка отсутствует только (используя ||ленивую оценку).
3. Попытайтесь снова присоединить те, которые отсутствовали на шаге 1 и были установлены на шаге 2.

4. Напечатайте окончательную загрузку каждого пакета ( 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 

Я использую следующее, которое проверит, установлен ли пакет и обновлены ли зависимости, затем загружает пакет.

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

Вот мой код для этого:

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

Это работает с именами пакетов без кавычек и довольно элегантно (см. Ответ GeoObserver)

В моем случае я хотел один лайнер, который мог бы запускаться из командной строки (на самом деле через Makefile). Вот пример установки «VGAM» и «Перо», если они еще не установлены:

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

Изнутри R это будет просто:

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

Здесь нет ничего кроме предыдущих решений, кроме того, что:

• Я держу это в одной строке
• Я жестко запрограммировал reposпараметр (чтобы избежать всплывающих окон, спрашивающих о том, какое зеркало использовать)
• Я не пытаюсь определить функцию, которая будет использоваться в другом месте

Также обратите внимание на важное character.only=TRUE(без него requireбудет пытаться загрузить пакет 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)
}

Позвольте мне поделиться немного безумия:

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