Cara elegan untuk memeriksa paket yang hilang dan menginstalnya?

Saya tampaknya berbagi banyak kode dengan rekan penulis hari ini. Banyak dari mereka adalah pengguna R pemula dan menengah dan tidak menyadari bahwa mereka harus menginstal paket yang belum mereka miliki.

Apakah ada cara yang elegan untuk menelepon installed.packages(), bandingkan dengan yang saya muat dan instal jika tidak ada?

Iya. Jika Anda memiliki daftar paket, bandingkan dengan output dari installed.packages()[,"Package"]dan instal paket yang hilang. Sesuatu seperti ini:

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)

Jika tidak:

Jika Anda memasukkan kode Anda dalam sebuah paket dan menjadikannya dependensi, maka mereka akan secara otomatis diinstal ketika Anda menginstal paket Anda.

Dason K. dan saya memiliki paket pacman yang dapat melakukan ini dengan baik. Fungsi p_loaddalam paket melakukan ini. Baris pertama hanya untuk memastikan bahwa pacman diinstal.

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

Anda bisa menggunakan nilai pengembalian require:

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

Saya menggunakan librarysetelah instalasi karena akan mengeluarkan pengecualian jika instalasi tidak berhasil atau paket tidak dapat dimuat karena alasan lain. Anda menjadikan ini lebih kuat dan dapat digunakan kembali:

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

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

Kelemahan dari metode ini adalah Anda harus memberikan nama paket dalam tanda kutip, yang sebenarnya tidak Anda lakukan require.

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

"ggplot2" adalah paketnya. Ia memeriksa untuk melihat apakah paket diinstal, jika tidak menginstalnya. Itu kemudian memuat paket terlepas dari cabang yang dibutuhkan.

Solusi ini akan mengambil vektor karakter dari nama paket dan mencoba memuatnya, atau menginstalnya jika pemuatan gagal. Itu bergantung pada perilaku pengembalian requireuntuk melakukan ini karena ...

require mengembalikan (tak terlihat) logika yang menunjukkan apakah paket yang diperlukan tersedia

Karena itu kita bisa melihat apakah kita dapat memuat paket yang diperlukan dan jika tidak, instal dengan dependensi. Jadi diberi vektor karakter paket yang ingin Anda muat ...

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

Banyak jawaban di atas (dan duplikat dari pertanyaan ini) bergantung pada installed.packagesbentuk mana yang buruk. Dari dokumentasi:

Ini bisa lambat ketika ribuan paket diinstal, jadi jangan gunakan ini untuk mencari tahu apakah paket bernama diinstal (gunakan system.file atau find.package) atau untuk mengetahui apakah suatu paket dapat digunakan (panggilan membutuhkan dan periksa nilai balik) atau untuk menemukan rincian sejumlah kecil paket (gunakan packageDescription). Perlu membaca beberapa file per paket yang diinstal, yang akan lambat pada Windows dan pada beberapa sistem file yang dipasang di jaringan.

Jadi, pendekatan yang lebih baik adalah mencoba memuat paket menggunakan requiredan menginstal jika pemuatan gagal ( requireakan kembali FALSEjika tidak ditemukan). Saya lebih suka implementasi ini:

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

yang bisa digunakan seperti ini:

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

Dengan cara ini memuat semua paket, lalu kembali dan menginstal semua paket yang hilang (yang jika Anda mau, adalah tempat yang berguna untuk memasukkan prompt untuk menanyakan apakah pengguna ingin menginstal paket). Alih-alih memanggil install.packagessecara terpisah untuk setiap paket, ia hanya mengirimkan seluruh vektor paket yang dihapus instalasinya sekali saja.

Berikut fungsi yang sama tetapi dengan dialog windows yang menanyakan apakah pengguna ingin menginstal paket yang hilang

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

Walaupun jawaban Shane sangat bagus, untuk salah satu proyek saya, saya perlu menghapus pesan, peringatan, dan menginstal paket ouput secara otomatis . Saya akhirnya berhasil mendapatkan skrip ini:

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

Menggunakan:

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)

Ini adalah tujuan dari paket rbundler : untuk menyediakan cara untuk mengontrol paket-paket yang diinstal untuk proyek tertentu. Saat ini paket bekerja dengan fungsi devtools untuk menginstal paket ke direktori proyek Anda. Fungsionalitasnya mirip dengan bundler Ruby .

Jika proyek Anda adalah sebuah paket (disarankan) maka yang harus Anda lakukan adalah memuat rbundler dan menggabungkan paket-paket tersebut. The bundlefungsi akan melihat paket Anda DESCRIPTIONberkas untuk menentukan paket bundel.

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

Sekarang paket akan diinstal di direktori .Rundle.

Jika proyek Anda bukan paket, maka Anda bisa memalsunya dengan membuat DESCRIPTIONfile di direktori root proyek Anda dengan bidang Tergantung yang mencantumkan paket yang ingin Anda instal (dengan informasi versi opsional):

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

Inilah repo github untuk proyek ini jika Anda tertarik untuk berkontribusi: rbundler .

Tentu.

Anda perlu membandingkan 'paket yang diinstal' dengan 'paket yang diinginkan'. Itu sangat dekat dengan apa yang saya lakukan dengan CRANberries karena saya perlu membandingkan 'paket yang dikenal tersimpan' dengan 'paket yang dikenal saat ini' untuk menentukan paket baru dan / atau yang diperbarui.

Jadi lakukan sesuatu seperti

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

untuk mendapatkan semua paket yang dikenal, panggilan simular untuk paket yang diinstal saat ini dan bandingkan dengan paket target yang diberikan.

Gunakan packratagar pustaka bersama sama persis dan tidak mengubah lingkungan orang lain.

Dalam hal keanggunan dan praktik terbaik, saya pikir Anda pada dasarnya akan melakukannya dengan cara yang salah. Paket packratini dirancang untuk masalah ini. Ini dikembangkan oleh RStudio oleh Hadley Wickham. Alih-alih mereka harus menginstal dependensi dan mungkin mengacaukan sistem lingkungan seseorang, packratgunakan direktori sendiri dan instal semua dependensi untuk program Anda di sana dan tidak menyentuh lingkungan seseorang.

Packrat adalah sistem manajemen ketergantungan untuk R.

Ketergantungan paket R bisa membuat frustasi. Pernahkah Anda menggunakan trial-and-error untuk mencari tahu paket R apa yang perlu Anda instal untuk membuat kode orang lain berfungsi - dan kemudian ditinggalkan dengan paket-paket tersebut terinstal secara global selamanya, karena sekarang Anda tidak yakin apakah Anda membutuhkannya ? Apakah Anda pernah memperbarui paket untuk mendapatkan kode di salah satu proyek Anda untuk bekerja, hanya untuk menemukan bahwa paket yang diperbarui membuat kode di proyek lain berhenti bekerja?

Kami membangun packrat untuk menyelesaikan masalah ini. Gunakan packrat untuk membuat proyek R Anda lebih banyak:

• Terisolasi: Menginstal paket baru atau yang diperbarui untuk satu proyek tidak akan merusak proyek Anda yang lain, dan sebaliknya. Itu karena packrat memberikan setiap proyek perpustakaan paket pribadi mereka sendiri.
• Portable: Mudah mengangkut proyek Anda dari satu komputer ke komputer lain, bahkan di seluruh platform yang berbeda. Packrat memudahkan untuk menginstal paket yang bergantung pada proyek Anda.
• Reproducible: Packrat mencatat versi paket persis yang Anda andalkan, dan memastikan versi yang tepat adalah yang diinstal di mana pun Anda pergi.

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

Fungsi sederhana berikut berfungsi seperti pesona:

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

(bukan milikku, menemukan ini di web beberapa waktu lalu dan telah menggunakannya sejak itu. tidak yakin dengan sumber aslinya)

Saya menggunakan fungsi berikut untuk menginstal paket jika require("<package>")keluar dengan paket tidak ditemukan kesalahan. Ini akan meminta baik - repositori CRAN dan Bioconductor untuk paket yang hilang.

Diadaptasi dari karya asli oleh Joshua Wiley, http://r.789695.n4.nabble.com/Install-package-automatically-if-not-ther-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)))
  }
}

Contoh:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)akan memperbarui semua paket yang diinstal pada sistem. Ini bisa memakan waktu lama dan menganggapnya sebagai upgrade R penuh yang mungkin tidak dijamin sepanjang waktu!

Anda cukup menggunakan setdifffungsi untuk mendapatkan paket yang tidak diinstal dan kemudian menginstalnya. Dalam contoh di bawah ini, kami memeriksa apakah ggplot2dan Rcpppaket diinstal sebelum menginstalnya.

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

Dalam satu baris, yang di atas dapat ditulis sebagai:

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

Saya telah mengimplementasikan fungsi untuk menginstal dan memuat paket R yang diperlukan secara diam-diam. Semoga bisa membantu. Ini kodenya:

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

Versi RStudio (1.2) yang akan datang, sudah tersedia sebagai pratinjau, akan menyertakan fitur untuk mendeteksi paket library()dan require()panggilan yang hilang , dan meminta pengguna untuk menginstalnya:

Mendeteksi paket R yang hilang

Banyak skrip R terbuka dengan panggilan ke library()dan require()untuk memuat paket yang mereka butuhkan untuk dieksekusi. Jika Anda membuka skrip R yang mereferensikan paket yang belum Anda instal, RStudio sekarang akan menawarkan untuk menginstal semua paket yang dibutuhkan dalam satu klik. Tidak perlu lagi mengetik install.packages()berulang kali hingga kesalahan hilang!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Hal ini tampaknya menyikapi keprihatinan asli OP dengan sangat baik:

Banyak dari mereka adalah pengguna R pemula dan menengah dan tidak menyadari bahwa mereka harus menginstal paket yang belum mereka miliki.

Mengenai tujuan utama Anda "untuk menginstal perpustakaan yang belum mereka miliki." Dan terlepas dari menggunakan "instllaed.packages ()". Fungsi berikut menutupi fungsi asli yang diminta. Mencoba memuat dan memeriksa paket bernama "x", jika tidak diinstal, instal langsung termasuk dependensi; dan terakhir memuatnya secara normal. Anda mengganti nama fungsi dari 'wajib' ke 'perpustakaan' untuk menjaga integritas. Satu-satunya batasan adalah nama paket harus dikutip.

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

Jadi Anda dapat memuat dan menginstal paket dengan cara mode lama dari R. Butuhkan ("ggplot2") memerlukan ("Rcpp")

Cukup mendasar.

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

Saya pikir saya akan berkontribusi yang saya gunakan:

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

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

Menggunakan pendekatan keluarga lapply dan fungsi anonim, Anda dapat:

1. Coba lampirkan semua paket yang terdaftar.
2. Instal hanya hilang (menggunakan || evaluasi malas).
3. Coba pasang kembali yang hilang di langkah 1 dan pasang di langkah 2.

4. Cetak setiap paket status pemuatan akhir ( 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 

Saya menggunakan yang berikut ini yang akan memeriksa apakah paket diinstal dan jika dependensi diperbarui, kemudian memuat 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, ])
}

Ini kode saya untuk itu:

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

Ini berfungsi dengan nama paket yang tidak dikutip dan cukup elegan (lih. Jawaban GeoObserver)

Dalam kasus saya, saya ingin satu liner yang dapat saya jalankan dari commandline (sebenarnya melalui Makefile). Berikut adalah contoh menginstal "VGAM" dan "feather" jika belum diinstal:

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

Dari dalam R itu hanya akan:

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

Tidak ada apa pun di sini selain solusi sebelumnya kecuali bahwa:

• Saya menyimpannya dalam satu baris
• Saya sulit mengode reposparameter (untuk menghindari sembulan menanyakan tentang mirror untuk digunakan)
• Saya tidak peduli untuk mendefinisikan fungsi yang akan digunakan di tempat lain

Perhatikan juga yang penting character.only=TRUE(tanpa itu, requireakan mencoba memuat paket 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)
}

Biarkan saya berbagi sedikit kegilaan:

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